12457139241

Committed 22 Dec 2024 07:38PM UTC coverage: 52.086% (-13.5%) from 65.587%

Build # 12457139241

Build Type

push

github

Committed by

web-flow

Commit Message

Build units (#11)

* update models in game-engine

* added fleets

* add build unit service and troops page

* added build units dialog

* added build units queue

Run Details

206 of 790 branches covered (26.08%)

Branch coverage included in aggregate %.

366 of 893 new or added lines in 84 files covered. (40.99%)

10 existing lines in 7 files now uncovered.

1417 of 2326 relevant lines covered (60.92%)

3.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

15.73

/packages/game-engine/src/engine/tasks/processStartBuildUnitsTask.ts

import {
  ITask,
  PENDING_TASK_STATUS,
  StartBuildUnitsTaskType,
  FinishBuildUnitsTaskType,
  FINISH_BUILD_UNITS_TASK_TYPE
} from '../../types/ITask'
import getTaskModel, { ITaskTypeDocument } from '../../models/TaskModel'
import playerRepository from '../../repositories/playerRepository'
import GameEngineError from '../errors/GameEngineError'
import getSecond from '../../helpers/getSecond'
import checkUnitRequirements from '../units/checkUnitRequirements'
import isHeroAlreadyBuild from '../units/isHeroAlreadyBuild'
import isValidUnitAmount from '../units/isValidUnitAmount'
import computedBonus from '../bonus/computedBonus'
import { UnitTypes } from '../../types/IUnit'
import { IBonus } from '../../types/IBonus'
import { IPlanet } from '../../types/IPlanet'
import getPlayerUnit from '../units/getPlayerUnit'
import getFirstUnitInTheBuildQueue from '../units/getFirstUnitInTheBuildQueue'
import taskRepository from '../../repositories/taskRepository'
import createStartBuildUnitsTask from './utils/createStartBuildUnitsTask'

async function processStartBuildUnitsTask(
  task: ITaskTypeDocument<StartBuildUnitsTaskType>,
  second: number
) {
  // get all the required data from DB
  const player = await playerRepository.findPlayerById(task.data.playerId)

  if (!player) {
    throw new GameEngineError('invalid player')
  }

  const planet = player.planets.colonies.find(
    (playerColony) => playerColony._id.toString() === task.data.planetId
  )

  if (!planet) {
    throw new GameEngineError('invalid planet owner')
  }

  const unit = getPlayerUnit(player, task.data.build.unitId, planet)

  if (!unit) {
    throw new GameEngineError('invalid unit')
  }

  if (unit.type === 'TROOP' && !!planet.unitBuild.troops.activeBuild) {
    throw new GameEngineError('player already building troops in this planet')
  }

  if (unit.type === 'SPACESHIP' && !!planet.unitBuild.spaceships.activeBuild) {
    throw new GameEngineError('player already building spaceships in this planet')
  }

  if (unit.type === 'DEFENSE' && !!planet.unitBuild.defenses.activeBuild) {
    throw new GameEngineError('player already building defenses in this planet')
  }

  const buildUnitsType: Record<UnitTypes, keyof IPlanet['unitBuild']> = {
    TROOP: 'troops',
    SPACESHIP: 'spaceships',
    DEFENSE: 'defenses'
  }

  const { isUnitAvailable, requirements } = checkUnitRequirements(unit, player)
  const isValidAmount = isValidUnitAmount(unit, task.data.build.amount, player)
  const isHeroUnitAlreadyBuild = isHeroAlreadyBuild(unit, player.fleets)

  const resourceCost = unit.resourceCost * task.data.build.amount
  const unitEnergyCost = unit.energyCost || 0
  const energy = unitEnergyCost * task.data.build.amount

  const hasEnoughResources = planet.resources >= resourceCost

  const checkBuildUnitsQueue =
    !isUnitAvailable || !isValidAmount || isHeroUnitAlreadyBuild || !hasEnoughResources

  if (checkBuildUnitsQueue) {
    const nextBuildUnits = planet.unitBuild[buildUnitsType[unit.type]].queue.shift()
    const nextUnitInTheQueue = getFirstUnitInTheBuildQueue(player, planet, nextBuildUnits)

    if (nextUnitInTheQueue && nextBuildUnits) {
      const buildUnitsTask = createStartBuildUnitsTask(
        task.universeId,
        player._id.toString(),
        planet._id.toString(),
        nextUnitInTheQueue._id.toString(),
        nextBuildUnits.amount
      )

      await Promise.all([planet.save(), taskRepository.createStartBuildUnitsTask(buildUnitsTask)])
    }
  }

  if (!isUnitAvailable) {
    throw new GameEngineError('unit not available for this player', requirements)
  }

  if (!isValidAmount) {
    throw new GameEngineError('invalid unit amount')
  }

  if (isHeroUnitAlreadyBuild) {
    throw new GameEngineError('invalid unit, hero already build')
  }

  if (!hasEnoughResources) {
    throw new GameEngineError('no resources available', {
      resourceCost,
      planetResources: planet.resources
    })
  }

  const buildUnitsBono: Record<UnitTypes, keyof IBonus> = {
    TROOP: 'TROOPS_TRAINING_BONUS',
    SPACESHIP: 'FLEET_BUILDING_BONUS',
    DEFENSE: 'DEFENSES_BUILDING_BONUS'
  }

  const buildUnitsBonus = computedBonus(player.perks, buildUnitsBono[unit.type])
  const duration = task.data.build.amount * unit.buildBaseTime * (100 / buildUnitsBonus)

  const executeTaskAt = getSecond(second + duration)

  // TODO: implement createBaseTask helper function
  const finishBuildUnitsTask: ITask<FinishBuildUnitsTaskType> = {
    type: FINISH_BUILD_UNITS_TASK_TYPE,
    universeId: player.universeId,
    data: {
      playerId: player._id.toString(),
      planetId: planet._id.toString(),
      build: {
        unitId: task.data.build.unitId,
        amount: task.data.build.amount,
        unitType: unit.type,
        duration,
        resourceCost,
        energy
      }
    },
    status: PENDING_TASK_STATUS,
    isCancellable: true,
    executeTaskAt,
    processedAt: null,
    processingDuration: null,
    history: [
      {
        taskStatus: PENDING_TASK_STATUS,
        updatedAt: new Date().getTime()
      }
    ],
    errorDetails: null
  }
  const taskModel = getTaskModel<FinishBuildUnitsTaskType>()
  const newTask = new taskModel(finishBuildUnitsTask)

  planet.unitBuild[buildUnitsType[unit.type]].activeBuild = {
    unitId: unit._id.toString(),
    unitName: unit.name,
    unitType: unit.type,
    amount: task.data.build.amount,
    taskId: newTask._id.toString(),
    executeTaskAt,
    energy,
    resourceCost
  }

  planet.resources -= resourceCost

  return Promise.all([newTask.save(), planet.save(), player.save()])
}

export default processStartBuildUnitsTask

1	import {	4✔
2	ITask,
3	PENDING_TASK_STATUS,
4	StartBuildUnitsTaskType,
5	FinishBuildUnitsTaskType,
6	FINISH_BUILD_UNITS_TASK_TYPE
7	} from '../../types/ITask'
8	import getTaskModel, { ITaskTypeDocument } from '../../models/TaskModel'	4✔
9	import playerRepository from '../../repositories/playerRepository'	4✔
10	import GameEngineError from '../errors/GameEngineError'	4✔
11	import getSecond from '../../helpers/getSecond'	4✔
12	import checkUnitRequirements from '../units/checkUnitRequirements'	4✔
13	import isHeroAlreadyBuild from '../units/isHeroAlreadyBuild'	4✔
14	import isValidUnitAmount from '../units/isValidUnitAmount'	4✔
15	import computedBonus from '../bonus/computedBonus'	4✔
16	import { UnitTypes } from '../../types/IUnit'
17	import { IBonus } from '../../types/IBonus'
18	import { IPlanet } from '../../types/IPlanet'
19	import getPlayerUnit from '../units/getPlayerUnit'	4✔
20	import getFirstUnitInTheBuildQueue from '../units/getFirstUnitInTheBuildQueue'	4✔
21	import taskRepository from '../../repositories/taskRepository'	4✔
22	import createStartBuildUnitsTask from './utils/createStartBuildUnitsTask'	4✔
23
24	async function processStartBuildUnitsTask(
25	task: ITaskTypeDocument<StartBuildUnitsTaskType>,
26	second: number
27	) {
28	// get all the required data from DB
NEW 29	const player = await playerRepository.findPlayerById(task.data.playerId)	×
30
NEW 31	if (!player) {	×
NEW 32	throw new GameEngineError('invalid player')	×
33	}
34
NEW 35	const planet = player.planets.colonies.find(	×
NEW 36	(playerColony) => playerColony._id.toString() === task.data.planetId	×
37	)
38
NEW 39	if (!planet) {	×
NEW 40	throw new GameEngineError('invalid planet owner')	×
41	}
42
NEW 43	const unit = getPlayerUnit(player, task.data.build.unitId, planet)	×
44
NEW 45	if (!unit) {	×
NEW 46	throw new GameEngineError('invalid unit')	×
47	}
48
NEW 49	if (unit.type === 'TROOP' && !!planet.unitBuild.troops.activeBuild) {	×
NEW 50	throw new GameEngineError('player already building troops in this planet')	×
51	}
52
NEW 53	if (unit.type === 'SPACESHIP' && !!planet.unitBuild.spaceships.activeBuild) {	×
NEW 54	throw new GameEngineError('player already building spaceships in this planet')	×
55	}
56
NEW 57	if (unit.type === 'DEFENSE' && !!planet.unitBuild.defenses.activeBuild) {	×
NEW 58	throw new GameEngineError('player already building defenses in this planet')	×
59	}
60
NEW 61	const buildUnitsType: Record<UnitTypes, keyof IPlanet['unitBuild']> = {	×
62	TROOP: 'troops',
63	SPACESHIP: 'spaceships',
64	DEFENSE: 'defenses'
65	}
66
NEW 67	const { isUnitAvailable, requirements } = checkUnitRequirements(unit, player)	×
NEW 68	const isValidAmount = isValidUnitAmount(unit, task.data.build.amount, player)	×
NEW 69	const isHeroUnitAlreadyBuild = isHeroAlreadyBuild(unit, player.fleets)	×
70
NEW 71	const resourceCost = unit.resourceCost * task.data.build.amount	×
NEW 72	const unitEnergyCost = unit.energyCost \|\| 0	×
NEW 73	const energy = unitEnergyCost * task.data.build.amount	×
74
NEW 75	const hasEnoughResources = planet.resources >= resourceCost	×
76
77	const checkBuildUnitsQueue =
NEW 78	!isUnitAvailable \|\| !isValidAmount \|\| isHeroUnitAlreadyBuild \|\| !hasEnoughResources	×
79
NEW 80	if (checkBuildUnitsQueue) {	×
NEW 81	const nextBuildUnits = planet.unitBuild[buildUnitsType[unit.type]].queue.shift()	×
NEW 82	const nextUnitInTheQueue = getFirstUnitInTheBuildQueue(player, planet, nextBuildUnits)	×
83
NEW 84	if (nextUnitInTheQueue && nextBuildUnits) {	×
NEW 85	const buildUnitsTask = createStartBuildUnitsTask(	×
86	task.universeId,
87	player._id.toString(),
88	planet._id.toString(),
89	nextUnitInTheQueue._id.toString(),
90	nextBuildUnits.amount
91	)
92
NEW 93	await Promise.all([planet.save(), taskRepository.createStartBuildUnitsTask(buildUnitsTask)])	×
94	}
95	}
96
NEW 97	if (!isUnitAvailable) {	×
NEW 98	throw new GameEngineError('unit not available for this player', requirements)	×
99	}
100
NEW 101	if (!isValidAmount) {	×
NEW 102	throw new GameEngineError('invalid unit amount')	×
103	}
104
NEW 105	if (isHeroUnitAlreadyBuild) {	×
NEW 106	throw new GameEngineError('invalid unit, hero already build')	×
107	}
108
NEW 109	if (!hasEnoughResources) {	×
NEW 110	throw new GameEngineError('no resources available', {	×
111	resourceCost,
112	planetResources: planet.resources
113	})
114	}
115
NEW 116	const buildUnitsBono: Record<UnitTypes, keyof IBonus> = {	×
117	TROOP: 'TROOPS_TRAINING_BONUS',
118	SPACESHIP: 'FLEET_BUILDING_BONUS',
119	DEFENSE: 'DEFENSES_BUILDING_BONUS'
120	}
121
NEW 122	const buildUnitsBonus = computedBonus(player.perks, buildUnitsBono[unit.type])	×
NEW 123	const duration = task.data.build.amount * unit.buildBaseTime * (100 / buildUnitsBonus)	×
124
NEW 125	const executeTaskAt = getSecond(second + duration)	×
126
127	// TODO: implement createBaseTask helper function
NEW 128	const finishBuildUnitsTask: ITask<FinishBuildUnitsTaskType> = {	×
129	type: FINISH_BUILD_UNITS_TASK_TYPE,
130	universeId: player.universeId,
131	data: {
132	playerId: player._id.toString(),
133	planetId: planet._id.toString(),
134	build: {
135	unitId: task.data.build.unitId,
136	amount: task.data.build.amount,
137	unitType: unit.type,
138	duration,
139	resourceCost,
140	energy
141	}
142	},
143	status: PENDING_TASK_STATUS,
144	isCancellable: true,
145	executeTaskAt,
146	processedAt: null,
147	processingDuration: null,
148	history: [
149	{
150	taskStatus: PENDING_TASK_STATUS,
151	updatedAt: new Date().getTime()
152	}
153	],
154	errorDetails: null
155	}
NEW 156	const taskModel = getTaskModel<FinishBuildUnitsTaskType>()	×
NEW 157	const newTask = new taskModel(finishBuildUnitsTask)	×
158
NEW 159	planet.unitBuild[buildUnitsType[unit.type]].activeBuild = {	×
160	unitId: unit._id.toString(),
161	unitName: unit.name,
162	unitType: unit.type,
163	amount: task.data.build.amount,
164	taskId: newTask._id.toString(),
165	executeTaskAt,
166	energy,
167	resourceCost
168	}
169
NEW 170	planet.resources -= resourceCost	×
171
NEW 172	return Promise.all([newTask.save(), planet.save(), player.save()])	×
173	}
174
175	export default processStartBuildUnitsTask	4✔

DaniSomoza / galactic-commander / 12457139241

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous