volleyballsimtypes 0.0.7 → 0.0.8

package/src/service/player/index.ts

@@ -1,5 +0,0 @@
-export * from './player'
-export * from './performance-stats'
-export * from './role'
-export * from './trait'
-export * from './stats'

package/src/service/player/performance-stats.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-import { performance } from './__stubs__'
-
-describe('PerformanceStats Test Module', () => {
-  test('Should instantiate object properly', () => {
-    expect(performance.serve).toBe(6)
-    expect(performance.setting).toBe(1)
-    expect(performance.pass).toBe(11)
-    expect(performance.reception).toBe(2)
-    expect(performance.spike).toBe(7)
-    expect(performance.backAttack).toBe(3)
-    expect(performance.jump).toBe(10)
-    expect(performance.block).toBe(4)
-    expect(performance.awareness).toBe(5)
-    expect(performance.defense).toBe(8)
-    expect(performance.stamina).toBe(11)
-  })
-
-  test('Should print all stats properly', () => {
-    const expected: string = 'serve: 6, pass: 11, setting: 1, reception: 2, spike: 7, backAttack: 3, jump: 10, block: 4, awareness: 5, defense: 8, stamina: 11'
-
-    expect(performance.toString()).toBe(expected)
-  })
-})

package/src/service/player/performance-stats.ts

@@ -1,47 +0,0 @@
-import { getKeys } from '../utils'
-
-export interface PerformanceStatsOpts {
-  readonly setting: number
-  readonly pass: number
-  readonly reception: number
-  readonly spike: number
-  readonly backAttack: number
-  readonly jump: number
-  readonly block: number
-  readonly awareness: number
-  readonly serve: number
-  readonly defense: number
-  readonly stamina: number
-}
-
-export class PerformanceStats {
-  readonly setting: number
-  readonly pass: number
-  readonly reception: number
-  readonly spike: number
-  readonly backAttack: number
-  readonly jump: number
-  readonly block: number
-  readonly awareness: number
-  readonly serve: number
-  readonly defense: number
-  readonly stamina: number
-
-  constructor (opts: PerformanceStatsOpts) {
-    this.serve = opts.serve
-    this.pass = opts.pass
-    this.setting = opts.setting
-    this.reception = opts.reception
-    this.spike = opts.spike
-    this.backAttack = opts.backAttack
-    this.jump = opts.jump
-    this.block = opts.block
-    this.awareness = opts.awareness
-    this.defense = opts.defense
-    this.stamina = opts.stamina
-  }
-
-  toString (): string {
-    return getKeys(this).map(key => `${key as string}: ${this[key] as number}`).join(', ')
-  }
-}

package/src/service/player/player.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-import { Player } from './player'
-import { Role } from './role'
-import { libero, player, players } from './__stubs__'
-import { country } from '../country/__stubs__'
-
-describe('Player Test Module', () => {
-  test('Should instantiate object properly', () => {
-    expect(player.id).toBe('622c36dc-f2d2-44b3-a744-667ea53218b7')
-    expect(player.roles).toEqual([Role.SETTER, Role.OPPOSITE_HITTER])
-    expect(player.name.first).toEqual( 'Francisco')
-    expect(player.name.last).toEqual( 'Farias')
-    expect(player.stats).toEqual({
-      serve: 6,
-      setting: 1,
-      reception: 2,
-      spike: 7,
-      backAttack: 3,
-      jump: 10,
-      block: 4,
-      awareness: 5,
-      defense: 8,
-      stamina: 11,
-      pass: 11
-    })
-  })
-  test('Should sort players according to Role Score', () => {
-    const sortedArrays = {
-      single: [...players].sort(Player.sortPlayers([Role.LIBERO])),
-      multiple: [...players].sort(Player.sortPlayers([Role.MIDDLE_BLOCKER, Role.SETTER])),
-      all: [...players].sort(Player.sortPlayers(Role.getRoles()))
-    }
-
-    const expected = {
-      single: [players[2], players[0], players[1]],
-      multiple: [players[1], players[2], players[0]],
-      all: [players[2], players[1], players[0]]
-    }
-
-    expect(sortedArrays.single).toStrictEqual(expected.single)
-    expect(sortedArrays.multiple).toStrictEqual(expected.multiple)
-    expect(sortedArrays.all).toStrictEqual(expected.all)
-  })
-  // canPlayLibero Tests
-  test('Should return false when player does not have the Libero role', () => {
-    expect(player.canPlayLibero()).toBe(false)
-  })
-  test('Should return true when player has the Libero role', () => {
-    expect(libero.canPlayLibero()).toBe(true)
-  })
-})

package/src/service/player/player.ts

@@ -1,101 +0,0 @@
-import { PerformanceStats } from './performance-stats'
-import { Role } from './role'
-import { validateUUID } from '../utils'
-import { Trait } from './trait'
-import { Country } from '../country'
-import { GeneralStat } from './stats'
-
-export interface Stat {
-  name: GeneralStat
-  value: number
-}
-
-export interface PlayerOpts {
-  readonly id: string
-  readonly name: Name
-  readonly country: Country
-  readonly stats: PerformanceStats
-  readonly roles: Role[]
-  readonly traits: Trait[]
-  readonly jerseyNumber: number
-  readonly team?: string
-}
-
-export interface Name {
-  first: string
-  last: string
-}
-
-export class Player {
-  readonly id: string
-  readonly name: Name
-  readonly country: Country
-  readonly stats: PerformanceStats
-  readonly roles: Role[]
-  readonly traits: Trait[]
-  readonly jerseyNumber: number
-  readonly team?: string
-  readonly generalStats: Stat[]
-
-  constructor ({ id, name, country, stats, roles, traits, jerseyNumber, team }: PlayerOpts) {
-    validateUUID(id)
-
-    this.id = id
-    this.name = name
-    this.country = country
-    this.stats = stats
-    this.roles = roles
-    this.traits = traits
-    this.jerseyNumber = jerseyNumber
-    this.team = team
-    this.generalStats = GeneralStat.getStats()
-      .map(stat => ({
-        name: stat,
-        value: GeneralStat.calculateScore(stats, stat)
-      }))
-  }
-
-  // Used as a base sorting function for players
-  public static sortPlayers (roles: Role[]): (p1: Player, p2: Player) => number {
-    return (p1: Player, p2: Player) => roles.reduce((x, role) => {
-      const p2Score = Role.calculateScore(p2.stats, role)
-      const p1Score = Role.calculateScore(p1.stats, role)
-
-      return x + p2Score - p1Score
-    }, 0)
-  }
-
-  public canPlayLibero (): boolean {
-    return this.roles.includes(Role.LIBERO)
-  }
-
-  public static compareStats (p1: Player, p2: Player): number {
-    const compareFn = (acc: number, current: Stat): number => {
-      let x = current.value
-
-      switch (current.name) {
-        case GeneralStat.ATTACK:
-          x *= 0.35
-          break
-        case GeneralStat.DEFENSE:
-          x *= 0.35
-          break
-        case GeneralStat.SERVE:
-          x *= 0.2
-          break
-        case GeneralStat.PHYSICAL:
-          x *= 0.1
-          break
-        default:
-          x *= 0
-      }
-
-      return acc + x
-    }
-
-    const s1: number = p1.generalStats.reduce(compareFn, 0)
-    const s2: number = p2.generalStats.reduce(compareFn, 0)
-
-    return s2 - s1
-  }
-}

package/src/service/player/role.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-import { Role } from './role'
-import { performanceStats, roles } from './__stubs__'
-
-describe('Role Test Module', () => {
-  // getRoles Test
-  test('Should return an array with all the Roles', () => {
-    expect(Role.getRoles().sort()).toEqual(roles.sort())
-  })
-  // calculateScore Tests
-  test('Should calculate Score for SETTER Role', () => {
-    expect(Role.calculateScore(performanceStats, Role.SETTER)).toBe(39)
-  })
-  test('Should calculate Score for OPPOSITE_HITTER Role', () => {
-    expect(Role.calculateScore(performanceStats, Role.OPPOSITE_HITTER)).toBe(50)
-  })
-  test('Should calculate Score for OUTSIDE_HITTER Role', () => {
-    expect(Role.calculateScore(performanceStats, Role.OUTSIDE_HITTER)).toBe(51)
-  })
-  test('Should calculate Score for MIDDLE_BLOCKER Role', () => {
-    expect(Role.calculateScore(performanceStats, Role.MIDDLE_BLOCKER)).toBe(53)
-  })
-  test('Should calculate Score for LIBERO Role', () => {
-    expect(Role.calculateScore(performanceStats, Role.LIBERO)).toBe(52)
-  })
-  test('Should calculate Score for DEFENSIVE_SPECIALIST Role', () => {
-    expect(Role.calculateScore(performanceStats, Role.DEFENSIVE_SPECIALIST)).toBe(53)
-  })
-})

package/src/service/player/role.ts

@@ -1,33 +0,0 @@
-import roleWeights from '../../../data/formula/role.formula.json'
-import { PerformanceStats } from './performance-stats'
-
-export enum Role {
-  SETTER = 'Setter',
-  LIBERO = 'Libero',
-  OUTSIDE_HITTER = 'Outside Hitter',
-  OPPOSITE_HITTER = 'Opposite Hitter',
-  MIDDLE_BLOCKER = 'Middle Blocker',
-  DEFENSIVE_SPECIALIST = 'Defensive Specialist'
-}
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export namespace Role {
-  const ROLES: Role[] = [Role.LIBERO, Role.SETTER, Role.OPPOSITE_HITTER, Role.OUTSIDE_HITTER, Role.MIDDLE_BLOCKER,
-    Role.DEFENSIVE_SPECIALIST]
-
-  export function getRoles (): Role[] {
-    return [...ROLES]
-  }
-
-  export function calculateScore (stats: PerformanceStats, role: Role): number {
-    const weights = roleWeights.find(r => r.role === role)
-
-    if (weights == null) throw new Error('COULD_NOT_FIND_ROLE_WEIGHT')
-
-    const score = Object.entries(weights.weight)
-      .reduce((score, [key, value]) =>
-        score + ((stats as any)[key] * (weights.weight as any)[key]), 0)
-
-    return Math.round(score)
-  }
-}

package/src/service/player/stats.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-import { GeneralStat } from './stats'
-import { performanceStats, stats } from './__stubs__'
-
-describe('Stat Test Module', () => {
-  // getStats Test
-  test('Should return an array with all the Stats', () => {
-    expect(GeneralStat.getStats().sort()).toEqual(stats.sort())
-  })
-  // calculateScore Tests
-  test('Should calculate Score for ATTACK Stat', () => {
-    expect(GeneralStat.calculateScore(performanceStats, GeneralStat.ATTACK)).toBe(49)
-  })
-  test('Should calculate Score for DEFENSE Stat', () => {
-    expect(GeneralStat.calculateScore(performanceStats, GeneralStat.DEFENSE)).toBe(60)
-  })
-  test('Should calculate Score for SERVE Stat', () => {
-    expect(GeneralStat.calculateScore(performanceStats, GeneralStat.SERVE)).toBe(20)
-  })
-  test('Should calculate Score for PHYSICAL Stat', () => {
-    expect(GeneralStat.calculateScore(performanceStats, GeneralStat.PHYSICAL)).toBe(58)
-  })
-})

package/src/service/player/stats.ts

@@ -1,29 +0,0 @@
-import stats from '../../../data/formula/stat.formula.json'
-import { PerformanceStats } from './performance-stats'
-
-export enum GeneralStat {
-  ATTACK = 'Attack',
-  DEFENSE = 'Defense',
-  SERVE = 'Serve',
-  PHYSICAL = 'Physical'
-}
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export namespace GeneralStat {
-  const STATS: GeneralStat[] = [GeneralStat.ATTACK, GeneralStat.DEFENSE, GeneralStat.SERVE, GeneralStat.PHYSICAL]
-
-  export function getStats (): GeneralStat[] {
-    return [...STATS]
-  }
-
-  export function calculateScore (performanceStats: PerformanceStats, statName: GeneralStat): number {
-    const weights = stats.find(s => s.statName === statName)
-
-    if (weights == null) throw new Error('COULD_NOT_FIND_ROLE_WEIGHT')
-
-    const score: number = Object.entries(weights.weight)
-      .reduce((score, [key, value]) => score + ((performanceStats as any)[key] * value), 0)
-
-    return Math.round(score)
-  }
-}

package/src/service/player/trait.test.ts

@@ -1,10 +0,0 @@
-import { describe, expect, test } from '@jest/globals'
-import { Trait } from './trait'
-
-// TODO
-describe('Trait Test Module', () => {
-  // getTraits Test
-  test('Should return an array with all the Traits', () => {
-    expect(Trait.VIGOROUS.name).toEqual('Vigorous')
-  })
-})

package/src/service/player/trait.ts

@@ -1,124 +0,0 @@
-import { Role } from './role'
-import { GeneralStat } from './stats'
-import { PerformanceStats } from './performance-stats'
-
-interface TraitProps {
-  readonly name: string
-  readonly roles: Role[]
-  readonly modifier: number
-  readonly chance: number
-  readonly statThreshold: number
-  readonly stat: GeneralStat
-  readonly weight: number
-}
-
-export class Trait {
-  static readonly MASTER_MIND: Trait = new Trait({
-    name: 'Master Mind',
-    roles: [Role.SETTER],
-    modifier: 1.25,
-    chance: 0.15,
-    statThreshold: 80,
-    stat: GeneralStat.ATTACK,
-    weight: 10
-  })
-
-  static readonly MOVING_WALL: Trait = new Trait({
-    name: 'Moving Wall',
-    roles: [Role.MIDDLE_BLOCKER, Role.DEFENSIVE_SPECIALIST],
-    modifier: 1,
-    chance: 1,
-    statThreshold: 75,
-    stat: GeneralStat.DEFENSE,
-    weight: 5
-  })
-
-  static readonly MARKSMAN: Trait = new Trait({
-    name: 'Marksman',
-    roles: [Role.OUTSIDE_HITTER, Role.OPPOSITE_HITTER, Role.SETTER],
-    modifier: 1,
-    chance: 0.33,
-    statThreshold: 75,
-    stat: GeneralStat.ATTACK,
-    weight: 5
-  })
-
-  static readonly METEOR_SERVE: Trait = new Trait({
-    name: 'Meteor Serve',
-    roles: [Role.OUTSIDE_HITTER, Role.OPPOSITE_HITTER, Role.SETTER, Role.DEFENSIVE_SPECIALIST, Role.MIDDLE_BLOCKER],
-    modifier: 1.33,
-    chance: 0.25,
-    statThreshold: 75,
-    stat: GeneralStat.SERVE,
-    weight: 10
-  })
-
-  static readonly VIGOROUS: Trait = new Trait({
-    name: 'Vigorous',
-    roles: [],
-    modifier: 1,
-    statThreshold: 60,
-    chance: 0.5,
-    stat: GeneralStat.PHYSICAL,
-    weight: 1
-  })
-
-  static readonly GUARDIAN: Trait = new Trait({
-    name: 'Guardian',
-    roles: [Role.DEFENSIVE_SPECIALIST, Role.LIBERO],
-    chance: 0.33,
-    statThreshold: 75,
-    modifier: 1.2,
-    stat: GeneralStat.DEFENSE,
-    weight: 10
-  })
-
-  readonly name: string
-  readonly roles: Role[]
-  readonly modifier: number
-  readonly chance: number
-  readonly statThreshold: number
-  readonly stat: GeneralStat
-  readonly weight: number
-
-  private constructor ({ name, roles, modifier, chance, statThreshold, stat, weight }: TraitProps) {
-    this.name = name
-    this.roles = roles
-    this.modifier = modifier
-    this.chance = chance
-    this.statThreshold = statThreshold
-    this.stat = stat
-    this.weight = weight
-  }
-
-  static getTraits (): Trait[] {
-    return [Trait.GUARDIAN, Trait.MARKSMAN, Trait.METEOR_SERVE, Trait.VIGOROUS, Trait.MOVING_WALL, Trait.MASTER_MIND]
-  }
-
-  static assignTraitsToPlayer (roles: Role[], performanceStats: PerformanceStats): Trait[] {
-    const qualifiedTraits: Trait[] = this.getTraits().filter(trait => {
-      return (trait.roles.length < 1 || trait.roles.some(role => roles.includes(role))) &&
-        GeneralStat.calculateScore(performanceStats, trait.stat) >= trait.statThreshold
-    })
-
-    const random: number = Math.random()
-    let traitCount: number
-
-    switch (true) {
-      case random > 0.9:
-        traitCount = 3
-        break
-      case random > 0.75:
-        traitCount = 2
-        break
-      case random > 0.4:
-        traitCount = 1
-        break
-      default:
-        traitCount = 0
-    }
-
-    return qualifiedTraits.sort((t1, t2) => t2.weight - t1.weight)
-      .slice(0, traitCount)
-  }
-}