volleyballsimtypes 0.0.1

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

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

package/src/service/event/serve.ts

@@ -0,0 +1,39 @@
+import { InPlayEvent, InPlayEventOpts } from './in-play-event'
+import { PerformanceStats } from '../player'
+
+export enum ServeType {
+  UNDERHAND = 0,
+  OVERHAND_TOPSPIN = 1,
+  OVERHAND_FLOAT = 2,
+  JUMP_TOPSPIN = 3,
+  JUMP_FLOAT = 4
+}
+
+export enum ServeFailure {
+  NO_FAILURE = 0,
+  FAULT = 1,
+  MISS = 2,
+  NET = 3,
+  OUT_OF_BOUNDS = 4
+}
+
+interface ServeOpts extends InPlayEventOpts {
+  readonly type: ServeType
+  readonly failure: ServeFailure
+}
+
+export class Serve extends InPlayEvent {
+  readonly failure: ServeFailure
+  readonly type: ServeType
+
+  constructor ({ id, order, score, player, target, failure, type, eventType, modifier }: ServeOpts) {
+    super({ id, order, score, player, target, eventType, modifier })
+
+    this.type = type
+    this.failure = failure
+  }
+
+  static getScore (stats: PerformanceStats, type: ServeType, modifier: number): number {
+    return Serve.calculateScore(stats, 'SERVE', ServeType[type]) * modifier
+  }
+}

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

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

package/src/service/event/set.ts

@@ -0,0 +1,38 @@
+import { PerformanceStats } from '../player'
+import { InPlayEvent, InPlayEventOpts } from './in-play-event'
+
+export enum SetType {
+  OVERHAND = 0,
+  UNDERHAND = 1,
+  SPIKE = 2,
+  DUMP = 3
+}
+
+export enum SetFailure {
+  NO_FAILURE = 0,
+  FAULT = 1,
+  MISS = 2,
+  BAD_PASS = 3,
+  OUT_OF_BOUNDS = 4
+}
+
+interface SetOpts extends InPlayEventOpts {
+  readonly type: SetType
+  readonly failure: SetFailure
+}
+
+export class Set extends InPlayEvent {
+  readonly failure: SetFailure
+  readonly type: SetType
+
+  constructor ({ id, order, score, player, target, failure, type, eventType, modifier }: SetOpts) {
+    super({ id, order, score, player, target, eventType, modifier })
+
+    this.type = type
+    this.failure = failure
+  }
+
+  static getScore (stats: PerformanceStats, type: SetType, modifier: number): number {
+    return Set.calculateScore(stats, 'SET', SetType[type]) * modifier
+  }
+}

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

@@ -0,0 +1,64 @@
+import { describe, expect, test } from '@jest/globals'
+import { Spike, SpikeFailure, SpikeType } from './spike'
+import { player } from '../player/__stubs__'
+import { CourtTarget } from '../match'
+import { EventType } from './rally-event'
+import { v4 as uuidv4 } from 'uuid'
+
+describe('Spike Test Module', () => {
+  let spike: Spike
+  let failed: Spike
+  let backAttack: Spike
+
+  beforeEach(() => {
+    spike = new Spike({
+      id: uuidv4(),
+      order: 1,
+      player: player,
+      target: CourtTarget.OPPONENT_RIGHT_BACK,
+      failure: SpikeFailure.NO_FAILURE,
+      type: SpikeType.CROSS_SHOT,
+      eventType: EventType.SPIKE,
+      modifier: 1,
+      score: Spike.getScore(player, SpikeType.CROSS_SHOT, 1, false)
+    })
+    failed = new Spike({
+      id: uuidv4(),
+      order: 1,
+      player: player,
+      target: CourtTarget.NO_TARGET,
+      failure: SpikeFailure.OUT_OF_BOUNDS,
+      type: SpikeType.TIP,
+      eventType: EventType.SPIKE,
+      modifier: 1,
+      score: Spike.getScore(player, SpikeType.TIP, 1, false)
+    })
+    backAttack = new Spike({
+      id: uuidv4(),
+      order: 1,
+      player: player,
+      target: CourtTarget.OPPONENT_RIGHT_BACK,
+      failure: SpikeFailure.NO_FAILURE,
+      type: SpikeType.CROSS_SHOT,
+      eventType: EventType.SPIKE,
+      modifier: 1,
+      score: Spike.getScore(player, SpikeType.CROSS_SHOT, 1, true)
+    })
+  })
+
+  test('Should instantiate object properly', () => {
+    expect(spike.target).toBe(CourtTarget.OPPONENT_RIGHT_BACK)
+    expect(spike.type).toBe(SpikeType.CROSS_SHOT)
+    expect(spike.eventType).toBe(EventType.SPIKE)
+    expect(spike.player.id).toBe(player.id)
+    expect(spike.failure).toBe(SpikeFailure.NO_FAILURE)
+    expect(failed.failure).toBe(SpikeFailure.OUT_OF_BOUNDS)
+    expect(spike.modifier).toBe(1)
+  })
+  // getScore Tests
+  test('Should get the correct score for all Spike types', () => {
+    expect(spike.score).toBe(8)
+    expect(failed.score).toBe(7)
+    expect(backAttack.score).toBe(6.5)
+  })
+})

package/src/service/event/spike.ts

@@ -0,0 +1,46 @@
+import { InPlayEvent, InPlayEventOpts } from './in-play-event'
+import { Player } from '../player'
+
+export enum SpikeType {
+  CROSS_SHOT = 0,
+  LINE_SHOT = 1,
+  TOOL_SHOT = 2,
+  TIP = 3,
+  DOWN_BALL = 4,
+  OVERHAND = 5
+}
+
+export enum SpikeFailure {
+  NO_FAILURE = 0,
+  FAULT = 1,
+  MISS = 2,
+  OUT_OF_BOUNDS = 3,
+  NET = 4
+}
+
+interface SpikeOpts extends InPlayEventOpts {
+  readonly type: SpikeType
+  readonly failure: SpikeFailure
+}
+
+export class Spike extends InPlayEvent {
+  readonly failure: SpikeFailure
+  readonly type: SpikeType
+
+  constructor ({ id, order, score, player, target, failure, type, eventType, modifier }: SpikeOpts) {
+    super({ id, order, score, player, target, eventType, modifier })
+
+    this.type = type
+    this.failure = failure
+  }
+
+  static getScore (player: Player, type: SpikeType, modifier: number, isBackRow: boolean): number {
+    let score: number = Spike.calculateScore(player.stats, 'SPIKE', SpikeType[type])
+
+    if (![SpikeType.DOWN_BALL, SpikeType.OVERHAND, SpikeType.TIP].includes(type) && isBackRow) {
+      score = score * 0.7 + player.stats.backAttack * 0.3
+    }
+
+    return score * modifier
+  }
+}

package/src/service/event/substitution.ts

@@ -0,0 +1,16 @@
+import { RallyEvent, RallyEventOpts } from './rally-event'
+import { Player } from '../player'
+
+export interface SubstitutionOpts extends RallyEventOpts {
+  readonly playerOut: Player
+}
+
+export class Substitution extends RallyEvent {
+  readonly playerOut: Player
+
+  constructor ({ id, order, playerOut, player, eventType }: SubstitutionOpts) {
+    super({ eventType, player, order, id })
+
+    this.playerOut = playerOut
+  }
+}

package/src/service/index.ts

@@ -0,0 +1,17 @@
+export * from './match'
+export * from './coach'
+export * from './country'
+export * from './team'
+export * from './event/rally-event'
+export * from './event/in-play-event'
+export * from './event/score'
+export * from './event/substitution'
+export * from './event/libero-replacement'
+export * from './event/serve'
+export * from './event/reception'
+export * from './event/set'
+export * from './event/spike'
+export * from './event/block'
+export * from './player'
+export * from './league'
+export * from './utils'

package/src/service/league/index.ts

@@ -0,0 +1,3 @@
+export * from './standing'
+export * from './season'
+export * from './league'

package/src/service/league/league.ts

@@ -0,0 +1,112 @@
+import { Season } from './season'
+import { Country } from '../country'
+import { Team } from '../team'
+import { Match } from '../match'
+import moment, { Moment } from 'moment/moment'
+import { shuffle } from '../utils'
+import { v4 as uuidv4 } from 'uuid'
+
+export interface LeagueOpts {
+  readonly id: string
+  readonly name: string
+  readonly country: Country
+  readonly seasons: Season[]
+}
+
+export class League {
+  readonly id: string
+  readonly name: string
+  readonly seasons: Season[]
+  readonly country: Country
+
+  constructor ({ id, name, country, seasons }: LeagueOpts) {
+    this.id = id
+    this.name = name
+    this.country = country
+    this.seasons = seasons
+  }
+
+  newSeason (teams: Team[]): Season {
+    const matches: Match[] = League.generateMatches(teams, moment().add(4, 'hour').toDate())
+    const season: Season = new Season({
+      id: uuidv4(),
+      iteration: this.seasons.length,
+      teams,
+      matches
+    })
+
+    this.seasons.push(season)
+
+    return season
+  }
+
+  static generateMatches (teams: Team[], baseDate: Date): Match[] {
+    const t: Set<string> = new Set(teams.map(x => x.id))
+    const date: Moment = moment(baseDate)
+    date.startOf('hour')
+
+    if (t.size !== teams.length) {
+      throw new Error('DUPLICATE_TEAMS')
+    }
+
+    let shuffled: Team[] = shuffle([...teams])
+    const l = shuffled.length - 1
+    const half = Math.ceil(shuffled.length / 2)
+    const matches: Match[] = []
+
+    // We fix the first team
+    let firstTeam: Team = shuffled.shift() as Team
+
+    if (firstTeam == null) {
+      throw new Error('EMPTY_TEAM_ARRAY')
+    }
+
+    let homeRow: Team[]
+    let awayRow: Team[]
+
+    for (let i = 0; i < l; i++) {
+      // split array in 2 halves
+      const row1: Team[] = shuffled.slice(0, half)
+      const row2: Team[] = shuffled.slice(half)
+      const scheduledDate = date.add(30, 'minutes').toDate()
+
+      row2.push(firstTeam)
+
+      if (i % 2 === 0) {
+        homeRow = row1
+        awayRow = row2
+      } else {
+        homeRow = row2
+        awayRow = row1
+      }
+
+      for (let j = 0; j < half; j++) {
+        matches.push(new Match({
+          id: uuidv4(),
+          homeTeam: homeRow[j],
+          awayTeam: awayRow[j],
+          scheduledDate,
+          sets: []
+        }))
+      }
+
+      firstTeam = row2.pop() as Team
+
+      row1.unshift(row2.shift() as Team)
+      row2.push(row1.pop() as Team)
+
+      shuffled = [...row1, ...row2]
+    }
+
+    // Generate Inverted matches for home-away pairings
+    matches.push(...matches.map(match => new Match({
+      id: uuidv4(),
+      homeTeam: match.awayTeam,
+      awayTeam: match.homeTeam,
+      scheduledDate: date.add(30, 'minutes').toDate(),
+      sets: []
+    })))
+
+    return matches
+  }
+}

package/src/service/league/season.ts

@@ -0,0 +1,41 @@
+import { Team } from '../team'
+import { Match } from '../match'
+import { Standing } from './standing'
+
+export interface SeasonOpts {
+  readonly id: string
+  readonly teams: Team[]
+  readonly matches: Match[]
+  readonly iteration: number
+}
+
+export class Season {
+  readonly id: string
+  readonly teams: Team[]
+  readonly matches: Match[]
+  readonly iteration: number
+  readonly standings: Standing[]
+
+  constructor ({ id, iteration, teams, matches }: SeasonOpts) {
+    this.id = id
+    this.teams = teams
+    this.matches = matches
+    this.iteration = iteration
+    this.standings = this.calculateStandings()
+  }
+
+  calculateStandings (): Standing[] {
+    return this.teams.map(team => {
+      const standing = new Standing({ teamId: team.id })
+
+      standing.calculateStanding(this.matches)
+
+      return standing
+    }).sort(Standing.sortFn)
+  }
+
+  get champion (): Team | undefined {
+    if (this.matches.every(match => !match.isOver())) return undefined
+    return this.teams.find(team => team.id === this.standings[0].teamId)
+  }
+}

package/src/service/league/standing.ts

@@ -0,0 +1,82 @@
+import { Match, MatchTeam } from '../match'
+
+export interface StandingOpts {
+  readonly teamId: string
+}
+
+export class Standing {
+  readonly teamId: string
+  won30: number = 0
+  won31: number = 0
+  won32: number = 0
+  lost03: number = 0
+  lost13: number = 0
+  lost23: number = 0
+  pointsWon: number = 0
+  pointsLost: number = 0
+  points: number = 0
+  pointsRatio: number = 0
+  setsWon: number = 0
+  setsLost: number = 0
+  setsRatio: number = 0
+  matchesWon: number = 0
+  matchesLost: number = 0
+  totalMatches: number = 0
+
+  constructor ({ teamId }: StandingOpts) {
+    this.teamId = teamId
+  }
+
+  calculateStanding (matches: Match[]): void {
+    matches = matches.filter(match => match.homeTeam.id === this.teamId || match.awayTeam.id === this.teamId)
+      .filter(match => match.isOver())
+
+    let teamSide: MatchTeam
+    let otherSide: MatchTeam
+    let teamScore: string
+    let otherScore: string
+
+    for (const match of matches) {
+      if (this.teamId === match.homeTeam.id) {
+        teamSide = MatchTeam.HOME
+        otherSide = MatchTeam.AWAY
+      } else {
+        teamSide = MatchTeam.AWAY
+        otherSide = MatchTeam.HOME
+      }
+
+      if (match.getWinner().id === this.teamId) {
+        (this as any)[`won3${match.getTeamSets(otherSide)}`]++
+      } else {
+        (this as any)[`lost${match.getTeamSets(teamSide)}3`]++
+      }
+
+      teamScore = `${teamSide === MatchTeam.HOME ? 'home' : 'away'}Score`
+      otherScore = `${otherSide === MatchTeam.HOME ? 'home' : 'away'}Score`
+
+      for (const set of match.sets) {
+        this.pointsWon += (set as any)[teamScore] as number
+        this.pointsLost += (set as any)[otherScore] as number
+      }
+    }
+
+    this.points = (this.won30 + this.won31) * 3 + this.won32 * 2 + this.lost23
+    this.pointsRatio = this.pointsWon / this.pointsLost
+    this.setsWon = (this.won32 + this.won31 + this.won30) * 3 + this.lost23 * 2 + this.lost13
+    this.setsLost = (this.lost03 + this.lost13 + this.lost23) * 3 + this.won32 * 2 + this.won31
+    this.setsRatio = this.setsWon / this.setsLost
+    this.matchesWon = this.won32 + this.won31 + this.won30
+    this.matchesLost = this.lost03 + this.lost13 + this.lost23
+    this.totalMatches = this.matchesWon + this.matchesLost
+  }
+
+  static sortFn (standingA: Standing, standingB: Standing): number {
+    if (standingB.points > standingA.points) return 1
+    else if (standingA.points > standingB.points) return -1
+    else if (standingB.setsRatio > standingA.setsRatio) return 1
+    else if (standingA.setsRatio > standingB.setsRatio) return -1
+    else if (standingB.pointsRatio > standingA.pointsRatio) return 1
+    else if (standingA.pointsRatio > standingB.pointsRatio) return -1
+    else return 0
+  }
+}

package/src/service/main.ts

@@ -0,0 +1,52 @@
+import weights from '../../data/formula/role.formula.json'
+import events from '../../data/formula/event.formula.json'
+import stats from '../../data/formula/stat.formula.json'
+
+export function validateRoleFormulas (): void {
+  console.log('---------------------------------------------------')
+  console.log('Starting Role-Weight validation process:')
+  console.log('---------------------------------------------------')
+
+  weights.forEach(({ role, weight }) => {
+    const val: number = Object.values(weight).reduce((a, b) => a + b, 0)
+    console.log(`Weight sum for ${role} is ${val}`)
+    if (val !== 1.0 && (Math.abs(1.0 - val) > 0.0001)) throw new Error(`Invalid weight sum for ${role}`)
+  })
+
+  console.log('---------------------------------------------------')
+  console.log('Role-Weight validation finished successfully!')
+  console.log('---------------------------------------------------')
+  console.log('Starting Events validation process:')
+  console.log('---------------------------------------------------')
+
+  Object.keys(events).forEach((event) => {
+    // @ts-ignore
+    Object.entries(events[event]).forEach(([type, formula]: [type: string, formula: any]) => {
+      let val: number = 0
+
+      Object.entries(formula as { [key: string]: number })
+        .forEach(([key, value]) => {
+          if (key === 'penalty') return
+          val += value
+        })
+
+      console.log(`Weight sum for ${event}|${type} is ${val}`)
+      if (val !== 1.0 && (Math.abs(1.0 - val) > 0.0001)) throw new Error(`Invalid weight sum for ${event}|${type}: ${val} | ${1.0 - val}`)
+    })
+  })
+
+  console.log('---------------------------------------------------')
+  console.log('Events validation finished successfully!')
+  console.log('---------------------------------------------------')
+  console.log('Starting Stat validation process:')
+  console.log('---------------------------------------------------')
+
+  stats.forEach(({ statName, weight }) => {
+    const val: number = Object.values(weight).reduce((a, b) => a + b, 0)
+    console.log(`Weight sum for ${statName} is ${val}`)
+    if (val !== 1.0 && (Math.abs(1.0 - val) > 0.0001)) throw new Error(`Invalid weight sum for ${statName}`)
+  })
+  console.log('---------------------------------------------------')
+  console.log('Stat validation finished successfully!')
+  console.log('---------------------------------------------------')
+}