volleyballsimtypes 0.0.1

package/src/service/coach/formation.ts

@@ -0,0 +1,160 @@
+import { Role } from '../player'
+import { CourtPosition } from '../match'
+
+interface FormationOpts {
+  readonly name: string
+  readonly initialRotation: PositionRole
+  readonly base: PositionRole
+  readonly draftingPriorities: Role[][]
+  readonly liberoSubPriority: SubPriority
+}
+
+interface PositionRole {
+  readonly [CourtPosition.LEFT_FRONT]: Role[]
+  readonly [CourtPosition.MIDDLE_FRONT]: Role[]
+  readonly [CourtPosition.RIGHT_FRONT]: Role[]
+  readonly [CourtPosition.LEFT_BACK]: Role[]
+  readonly [CourtPosition.MIDDLE_BACK]: Role[]
+  readonly [CourtPosition.RIGHT_BACK]: Role[]
+}
+
+export interface SubPriority {
+  readonly [Role.MIDDLE_BLOCKER]: number
+  readonly [Role.LIBERO]: number
+  readonly [Role.DEFENSIVE_SPECIALIST]: number
+  readonly [Role.OUTSIDE_HITTER]: number
+  readonly [Role.OPPOSITE_HITTER]: number
+  readonly [Role.SETTER]: number
+}
+
+export class Formation {
+  static readonly '5-1': Formation = new Formation({
+    name: '5-1',
+    initialRotation: {
+      1: [Role.SETTER],
+      2: [Role.OUTSIDE_HITTER],
+      3: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+      4: [Role.OPPOSITE_HITTER],
+      5: [Role.OUTSIDE_HITTER],
+      6: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST]
+    },
+    base: {
+      1: [Role.OPPOSITE_HITTER, Role.SETTER],
+      2: [Role.OPPOSITE_HITTER],
+      3: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+      4: [Role.OUTSIDE_HITTER],
+      5: [Role.OUTSIDE_HITTER],
+      6: [Role.LIBERO, Role.DEFENSIVE_SPECIALIST]
+    },
+    draftingPriorities: [
+      [Role.SETTER, Role.OPPOSITE_HITTER],
+      [Role.OPPOSITE_HITTER],
+      [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+      [Role.MIDDLE_BLOCKER],
+      [Role.OUTSIDE_HITTER],
+      [Role.OUTSIDE_HITTER],
+      [Role.LIBERO]
+    ],
+    liberoSubPriority: {
+      'Middle Blocker': 1,
+      'Outside Hitter': 10,
+      'Opposite Hitter': 100,
+      'Defensive Specialist': 1000,
+      Setter: 10000,
+      Libero: 100000
+    }
+  })
+
+  static readonly '4-2': Formation = new Formation({
+    name: '4-2',
+    initialRotation: {
+      1: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+      2: [Role.SETTER],
+      3: [Role.OUTSIDE_HITTER],
+      4: [Role.MIDDLE_BLOCKER],
+      5: [Role.SETTER],
+      6: [Role.OPPOSITE_HITTER]
+    },
+    base: {
+      1: [Role.SETTER],
+      2: [Role.OPPOSITE_HITTER, Role.SETTER],
+      3: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+      4: [Role.OUTSIDE_HITTER],
+      5: [Role.OUTSIDE_HITTER],
+      6: [Role.LIBERO, Role.DEFENSIVE_SPECIALIST]
+    },
+    draftingPriorities: [
+      [Role.SETTER, Role.OPPOSITE_HITTER],
+      [Role.SETTER],
+      [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+      [Role.MIDDLE_BLOCKER],
+      [Role.OUTSIDE_HITTER],
+      [Role.OUTSIDE_HITTER],
+      [Role.LIBERO]
+    ],
+    liberoSubPriority: {
+      'Middle Blocker': 1,
+      'Outside Hitter': 10,
+      'Opposite Hitter': 100,
+      'Defensive Specialist': 1000,
+      Setter: 10000,
+      Libero: 100000
+    }
+  })
+
+  static readonly '6-2': Formation = new Formation({
+    name: '6-2',
+    initialRotation: {
+      1: [Role.OPPOSITE_HITTER, Role.SETTER],
+      2: [Role.OUTSIDE_HITTER],
+      3: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+      4: [Role.OPPOSITE_HITTER, Role.SETTER],
+      5: [Role.OUTSIDE_HITTER],
+      6: [Role.MIDDLE_BLOCKER]
+    },
+    base: {
+      1: [Role.SETTER],
+      2: [Role.OPPOSITE_HITTER, Role.SETTER],
+      3: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+      4: [Role.OUTSIDE_HITTER],
+      5: [Role.OUTSIDE_HITTER],
+      6: [Role.LIBERO, Role.DEFENSIVE_SPECIALIST]
+    },
+    draftingPriorities: [
+      [Role.SETTER, Role.OPPOSITE_HITTER],
+      [Role.OPPOSITE_HITTER, Role.SETTER],
+      [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
+      [Role.DEFENSIVE_SPECIALIST, Role.MIDDLE_BLOCKER],
+      [Role.OUTSIDE_HITTER],
+      [Role.OUTSIDE_HITTER],
+      [Role.LIBERO]
+    ],
+    liberoSubPriority: {
+      'Middle Blocker': 1,
+      'Outside Hitter': 10,
+      'Opposite Hitter': 100,
+      'Defensive Specialist': 1000,
+      Setter: 10000,
+      Libero: 100000
+    }
+  }
+  )
+
+  readonly name: string
+  readonly initialRotation: PositionRole
+  readonly base: PositionRole
+  readonly draftingPriorities: Role[][]
+  readonly liberoSubPriority: SubPriority
+
+  private constructor ({ name, initialRotation, base, draftingPriorities, liberoSubPriority }: FormationOpts) {
+    this.name = name
+    this.initialRotation = initialRotation
+    this.base = base
+    this.draftingPriorities = draftingPriorities
+    this.liberoSubPriority = liberoSubPriority
+  }
+
+  public static getFormations (): Formation[] {
+    return [this['4-2'], this['5-1'], this['6-2']]
+  }
+}

package/src/service/coach/index.ts

@@ -0,0 +1,2 @@
+export * from './coach'
+export * from './formation'

package/src/service/country/__stubs__/index.ts

@@ -0,0 +1,13 @@
+import { Country } from '../country'
+
+export const countries: Country[] = [
+  new Country({ id: '53e01e62-fcc1-43fb-a38d-105cc7afb9ad', name: 'Republica de Zamunda', short: 'ZAM' }),
+  new Country({ id: 'acfef762-200a-40b8-b9a8-51bd1547ead9', name: 'Nocturna', short: 'NOC' }),
+  new Country({ id: '9e127575-e881-414e-b662-7a0f24caf227', name: 'Azura', short: 'AZU' }),
+  new Country({ id: '95eb288c-e01c-4593-8034-27c427e90823', name: 'Bantuland', short: 'BAN' })
+]
+export const country = new Country({
+  id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+  name: 'Argentina',
+  short: 'ARG'
+})

package/src/service/country/country.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, test } from '@jest/globals'
+import { country } from './__stubs__'
+
+describe('Country Test Module', () => {
+  test('Should instantiate object properly', () => {
+    expect(country.id).toEqual('622c36dc-f2d2-44b3-a744-667ea53218b7')
+    expect(country.name).toEqual('Argentina')
+    expect(country.short).toEqual('ARG')
+  })
+})

package/src/service/country/country.ts

@@ -0,0 +1,23 @@
+export interface CountryOpts {
+  readonly id: string
+  readonly name: string
+  readonly short: string
+  readonly language?: string
+  readonly league?: string
+}
+
+export class Country {
+  readonly id: string
+  readonly name: string
+  readonly short: string
+  readonly language?: string
+  readonly league?: string
+
+  constructor ({ id, name, short, language, league }: CountryOpts) {
+    this.id = id
+    this.name = name
+    this.short = short
+    this.language = language
+    this.league = league
+  }
+}

package/src/service/country/index.ts

@@ -0,0 +1 @@
+export * from './country'

package/src/service/event/__stubs__/index.ts

@@ -0,0 +1,25 @@
+import { Serve, ServeFailure, ServeType } from '../serve'
+import { player } from '../../player/__stubs__'
+import { CourtTarget } from '../../match'
+import { EventType } from '../rally-event'
+import { Score } from '../score'
+import { team } from '../../team/__stubs__'
+
+export const serve: Serve = new Serve({
+  score:50,
+  order:0,
+  id:'e92f4abb-66f4-4b6c-a602-258404d04484',
+  player: player,
+  target: CourtTarget.OPPONENT_RIGHT_BACK,
+  eventType: EventType.SERVE,
+  type: ServeType.JUMP_FLOAT,
+  failure: ServeFailure.NO_FAILURE,
+  modifier: 1
+})
+
+export const score: Score = new Score({
+  id:'e92f4abb-66f4-4b6c-a602-258404d04484',
+  order:0,
+  eventType: EventType.SCORE,
+  player,
+  team })

package/src/service/event/block.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from '@jest/globals'
+import { Block, BlockFailure, BlockType } from './block'
+import {  player } from '../player/__stubs__'
+import { CourtTarget } from '../match'
+import { EventType } from './rally-event'
+import { v4 as uuidv4 } from 'uuid'
+
+describe('Block Test Module', () => {
+  let none: Block
+  let block: Block
+  let double: Block
+  let triple: Block
+  let failed: Block
+
+  beforeEach(() => {
+    none = new Block({
+      id: uuidv4(),
+      order: 1,
+      player: player,
+      target: CourtTarget.OPPONENT_RIGHT_BACK,
+      failure: BlockFailure.NO_FAILURE,
+      type: BlockType.NO_BLOCKER,
+      eventType: EventType.BLOCK,
+      modifier: 1,
+      blockers: [],
+      score: Block.getScore([], 1)
+    })
+    block = new Block({
+      id: uuidv4(),
+      order: 1,
+      player: player,
+      target: CourtTarget.OPPONENT_RIGHT_BACK,
+      failure: BlockFailure.NO_FAILURE,
+      type: BlockType.SINGLE,
+      eventType: EventType.BLOCK,
+      modifier: 1,
+      blockers: [player],
+      score: Block.getScore([player], 1)
+    })
+    double = new Block({
+      id: uuidv4(),
+      order: 1,
+      player: player,
+      target: CourtTarget.OPPONENT_RIGHT_BACK,
+      failure: BlockFailure.NO_FAILURE,
+      type: BlockType.DOUBLE,
+      eventType: EventType.BLOCK,
+      modifier: 1,
+      blockers: [player, player],
+      score: Block.getScore([player, player], 1)
+    })
+    triple = new Block({
+      id: uuidv4(),
+      order: 1,
+      player: player,
+      target: CourtTarget.OPPONENT_RIGHT_BACK,
+      failure: BlockFailure.NO_FAILURE,
+      type: BlockType.TRIPLE,
+      eventType: EventType.BLOCK,
+      modifier: 1,
+      blockers: [player, player, player],
+      score: Block.getScore([player, player, player], 1)
+    })
+    failed = new Block({
+      id: uuidv4(),
+      order: 1,
+      player: player,
+      target: CourtTarget.NO_TARGET,
+      failure: BlockFailure.FAULT,
+      type: BlockType.TRIPLE,
+      eventType: EventType.BLOCK,
+      modifier: 1,
+      blockers: [player],
+      score: Block.getScore([player], 1)
+    })
+  })
+
+  test('Should instantiate object properly', () => {
+    expect(block.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK)
+    expect(block.type).toBe(BlockType.SINGLE)
+    expect(block.eventType).toBe(EventType.BLOCK)
+    expect(block.player.id).toBe(player.id)
+    expect(block.failure).toBe(BlockFailure.NO_FAILURE)
+    expect(failed.failure).toBe(BlockFailure.FAULT)
+    expect(block.modifier).toBe(1)
+  })
+  // getScore Tests
+  test('Should get the correct score for all Block types', () => {
+    expect(none.score).toBe(0)
+    expect(block.score).toBe(7)
+    expect(double.score).toBe(8.4)
+    expect(triple.score).toBe(9.799999999999999)
+    expect(failed.score).toBe(7)
+  })
+  test('Should throw Error when getting score with invalid amount of blockers', () => {
+    function score (): void { Block.getScore([player, player, player, player, player], 1) }
+
+    expect(score).toThrow(/^UNKNOWN_TYPE$/)
+  })
+})

package/src/service/event/block.ts

@@ -0,0 +1,69 @@
+import { InPlayEvent, InPlayEventOpts } from './in-play-event'
+import { Player } from '../player'
+
+export enum BlockFailure {
+  NO_FAILURE = 0,
+  FAULT = 1,
+  MISS = 2,
+  OUT_OF_BOUNDS = 3,
+  WIPE = 4,
+  TOOL = 5
+}
+
+export enum BlockType {
+  NO_BLOCKER = 0,
+  SINGLE = 1,
+  DOUBLE = 2,
+  TRIPLE = 3
+}
+
+interface BlockOpts extends InPlayEventOpts {
+  readonly type: BlockType
+  readonly failure: BlockFailure
+  readonly blockers: Player[]
+}
+
+export class Block extends InPlayEvent {
+  readonly failure: BlockFailure
+  readonly type: BlockType
+  readonly blockers: Player[]
+
+  constructor ({ id, order, score, player, target, failure, type, modifier, eventType, blockers }: BlockOpts) {
+    super({ id, order, score, player, target, modifier, eventType })
+
+    this.type = type
+    this.failure = failure
+    this.blockers = blockers
+  }
+
+  static getScore (blockers: Player[], modifier: number): number {
+    const type: BlockType = blockers.length
+
+    if (blockers.length > 3) throw new Error('UNKNOWN_TYPE')
+
+    let bmod: number
+
+    switch (type) {
+      case BlockType.NO_BLOCKER:
+        return 0
+      case BlockType.SINGLE:
+        bmod = 1
+        break
+      case BlockType.DOUBLE:
+        bmod = 1.2
+        break
+      case BlockType.TRIPLE:
+        bmod = 1.4
+        break
+      default:
+        throw new Error('UNKNOWN_TYPE')
+    }
+
+    const total: number = blockers.reduce((score, player) => {
+      return score + Block.calculateScore(player.stats, 'BLOCK', BlockType[type])
+    }, 0)
+    const avg: number = total / blockers.length
+
+    return avg * bmod * modifier
+  }
+}

package/src/service/event/in-play-event.ts

@@ -0,0 +1,37 @@
+import { RallyEvent, RallyEventOpts } from './rally-event'
+import { CourtTarget } from '../match'
+import { PerformanceStats } from '../player'
+import formula from '../../../data/formula/event.formula.json'
+import { getKeys } from '../utils'
+
+export interface InPlayEventOpts extends RallyEventOpts {
+  readonly target: CourtTarget
+  readonly modifier: number
+  readonly score: number
+}
+
+export abstract class InPlayEvent extends RallyEvent {
+  abstract failure: number
+  abstract type: number
+  readonly target: CourtTarget
+  readonly modifier: number
+  readonly score: number
+
+  protected constructor (opts: InPlayEventOpts) {
+    super(opts)
+
+    this.target = opts.target
+    this.score = opts.score
+    this.modifier = opts.modifier
+  }
+
+  protected static calculateScore (stats: PerformanceStats, eventType: string, type: string): number {
+    const weight = (formula as any)[eventType][type]
+    const penalty: number = weight.penalty ?? 0
+    const score: number = getKeys(weight).reduce((score: number, key) => {
+      return score + (key === 'penalty' ? 0 : (stats as any)[key] * weight[key])
+    }, 0)
+
+    return Math.round(score * (1 - penalty))
+  }
+}

package/src/service/event/libero-replacement.test.ts

@@ -0,0 +1,37 @@
+import { beforeEach, describe, expect, test } from '@jest/globals'
+import { EventType } from './rally-event'
+import { players } from '../player/__stubs__'
+import { LiberoReplacement, LiberoReplacementType } from './libero-replacement'
+import { v4 as uuidv4 } from 'uuid'
+
+describe('LiberoReplacement Test Module', () => {
+  let _in: LiberoReplacement
+  let _out: LiberoReplacement
+
+  beforeEach(() => {
+    _in = new LiberoReplacement({
+      id: uuidv4(),
+      order: 1,
+      player: players[0],
+      libero: players[1],
+      type: LiberoReplacementType.LIBERO_IN,
+      eventType: EventType.LIBERO_REPLACEMENT
+    })
+    _out = new LiberoReplacement({
+      id: uuidv4(),
+      order: 1,
+      player: players[0],
+      libero: players[1],
+      type: LiberoReplacementType.LIBERO_OUT,
+      eventType: EventType.LIBERO_REPLACEMENT
+    })
+  })
+
+  test('Should instantiate object properly', () => {
+    expect(_in.libero.id).toBe('e92f4abb-66f4-4b6c-a602-258404d04484')
+    expect(_in.player.id).toBe('622c36dc-f2d2-44b3-a744-667ea53218b7')
+    expect(_in.type).toBe(LiberoReplacementType.LIBERO_IN)
+    expect(_out.type).toBe(LiberoReplacementType.LIBERO_OUT)
+    expect(_in.eventType).toBe(EventType.LIBERO_REPLACEMENT)
+  })
+})

package/src/service/event/libero-replacement.ts

@@ -0,0 +1,25 @@
+import { EventType, RallyEvent, RallyEventOpts } from './rally-event'
+import { Player } from '../player'
+
+export interface LiberoReplacementOpts extends RallyEventOpts {
+  readonly player: Player
+  readonly libero: Player
+  readonly type: LiberoReplacementType
+}
+
+export enum LiberoReplacementType {
+  LIBERO_IN = 0,
+  LIBERO_OUT = 1
+}
+
+export class LiberoReplacement extends RallyEvent {
+  readonly type: LiberoReplacementType
+  readonly libero: Player
+
+  constructor ({ id, order, player, type, libero }: LiberoReplacementOpts) {
+    super({ id, order, player, eventType: EventType.LIBERO_REPLACEMENT })
+
+    this.type = type
+    this.libero = libero
+  }
+}

package/src/service/event/rally-event.ts

@@ -0,0 +1,33 @@
+import { Player } from '../player'
+
+export enum EventType {
+  LIBERO_REPLACEMENT = 0,
+  SUBSTITUTION = 1,
+  SERVE = 2,
+  RECEPTION = 3,
+  SET = 4,
+  SPIKE = 5,
+  BLOCK = 6,
+  SCORE = 7
+}
+
+export interface RallyEventOpts {
+  readonly id: string
+  readonly player: Player
+  readonly eventType: EventType
+  readonly order: number
+}
+
+export abstract class RallyEvent {
+  readonly id: string
+  readonly order: number
+  readonly player: Player
+  readonly eventType: EventType
+
+  protected constructor ({ id, eventType, player, order }: RallyEventOpts) {
+    this.id = id
+    this.player = player
+    this.order = order
+    this.eventType = eventType
+  }
+}

package/src/service/event/reception.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from '@jest/globals'
+import { Reception, ReceptionFailure, ReceptionType } from './reception'
+import { player } from '../player/__stubs__'
+import { CourtTarget } from '../match'
+import { EventType } from './rally-event'
+
+describe('Reception Test Module', () => {
+  let reception: Reception
+  let failed: Reception
+
+  beforeEach(() => {
+    reception = new Reception({
+      score: 60,
+      id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+      order: 0,
+      player: player,
+      target: CourtTarget.OPPONENT_RIGHT_BACK,
+      failure: ReceptionFailure.NO_FAILURE,
+      type: ReceptionType.DIG,
+      eventType: EventType.RECEPTION,
+      modifier: 1
+    })
+    failed = new Reception({
+      score: 60,
+      id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+      order: 0,
+      player: player,
+      target: CourtTarget.NO_TARGET,
+      failure: ReceptionFailure.OUT_OF_BOUNDS,
+      type: ReceptionType.OTHER_BODY_PART,
+      eventType: EventType.RECEPTION,
+      modifier: 1
+    })
+  })
+
+  test('Should instantiate object properly', () => {
+    expect(reception.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK)
+    expect(reception.type).toBe(ReceptionType.DIG)
+    expect(reception.eventType).toBe(EventType.RECEPTION)
+    expect(reception.player.id).toBe(player.id)
+    expect(reception.failure).toBe(ReceptionFailure.NO_FAILURE)
+    expect(failed.failure).toBe(ReceptionFailure.OUT_OF_BOUNDS)
+    expect(reception.modifier).toBe(1)
+  })
+  // getScore Tests
+  test('Should get the correct score for all Reception types', () => {
+    expect(Reception.getScore(reception.player.stats, reception.type, 1)).toBe(4)
+    expect(Reception.getScore(failed.player.stats, failed.type, 1)).toBe(3)
+  })
+})

package/src/service/event/reception.ts

@@ -0,0 +1,38 @@
+import { PerformanceStats } from '../player'
+import { InPlayEvent, InPlayEventOpts } from './in-play-event'
+
+export enum ReceptionType {
+  DIG = 0,
+  OVERHAND = 1,
+  ONE_HAND = 2,
+  OTHER_BODY_PART = 3
+}
+
+export enum ReceptionFailure {
+  NO_FAILURE = 0,
+  FAULT = 1,
+  MISS = 2,
+  OUT_OF_BOUNDS = 3,
+  BAD_PASS = 4
+}
+
+interface ReceptionOpts extends InPlayEventOpts {
+  readonly type: ReceptionType
+  readonly failure: ReceptionFailure
+}
+
+export class Reception extends InPlayEvent {
+  readonly failure: ReceptionFailure
+  readonly type: ReceptionType
+
+  constructor ({ id, order, score, player, target, failure, type, eventType, modifier }: ReceptionOpts) {
+    super({ id, order, score, player, target, eventType, modifier })
+
+    this.type = type
+    this.failure = failure
+  }
+
+  static getScore (stats: PerformanceStats, type: ReceptionType, modifier: number): number {
+    return Reception.calculateScore(stats, 'RECEPTION', ReceptionType[type]) * modifier
+  }
+}

package/src/service/event/score.test.ts

@@ -0,0 +1,29 @@
+import { beforeEach, describe, expect, test } from '@jest/globals'
+import { Score } from './score'
+import { player } from '../player/__stubs__'
+import { team } from '../team/__stubs__'
+import { EventType } from './rally-event'
+
+describe('Score Test Module', () => {
+  let score: Score
+
+  beforeEach(() => {
+    score = new Score({
+      id: '622c36dc-f2d2-44b3-a744-667ea53218b7',
+      order: 0,
+      eventType: EventType.SCORE,
+      player: player,
+      team
+    })
+  })
+
+  test('Should instantiate object properly', () => {
+    expect(score.eventType).toBe(EventType.SCORE)
+    expect(score.player.id).toBe('e92f4abb-66f4-4b6c-a602-258404d04484')
+    expect(score.team.id).toBe('426b5b9b-5be7-4963-92eb-71b7a3b29ffd')
+  })
+  // printEvent Test
+  test('Should print event properly', () => {
+    expect(score.printEvent()).toBe('event: SCORE, team: Yodo [YOD]')
+  })
+})

package/src/service/event/score.ts

@@ -0,0 +1,22 @@
+import { RallyEvent, RallyEventOpts } from './rally-event'
+import { Team } from '../team'
+import { Player } from '../player'
+
+interface ScoreOpts extends RallyEventOpts {
+  player: Player
+  team: Team
+}
+
+export class Score extends RallyEvent {
+  readonly team: Team
+
+  constructor ({ id, order, player, team, eventType }: ScoreOpts) {
+    super({ id, order, player, eventType })
+
+    this.team = team
+  }
+
+  printEvent (): string {
+    return `event: SCORE, team: ${this.team.name} [${this.team.shortName}]`
+  }
+}