volleyballsimtypes 0.0.7 → 0.0.8

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

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

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

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

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

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

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

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

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

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

package/src/service/league/league.ts

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

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

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

@@ -1,52 +0,0 @@
-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('---------------------------------------------------')
-}