volleyballsimtypes 0.0.7 → 0.0.8

package/src/service/coach/formation.ts

@@ -1,160 +0,0 @@
-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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

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

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

@@ -1,25 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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) as number
-
-    return Math.round(score * (1 - penalty))
-  }
-}

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

@@ -1,37 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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}]`
-  }
-}