volleyballsimtypes 0.0.1

package/src/service/player/index.ts

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,124 @@
+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)
+  }
+}