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

92.16

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

import {
  ITask,
  FINISH_RESEARCH_TASK_TYPE,
  FinishResearchTaskType,
  PENDING_TASK_STATUS,
  StartResearchTaskType
} from '../../types/ITask'
import getTaskModel, { ITaskTypeDocument } from '../../models/TaskModel'
import playerRepository from '../../repositories/playerRepository'
import taskRepository from '../../repositories/taskRepository'
import GameEngineError from '../errors/GameEngineError'
import getSecond from '../../helpers/getSecond'
import computedBonus from '../bonus/computedBonus'
import createStartResearchTask from './utils/createStartResearchTask'
import calculateResearchDuration from '../research/calculateResearchDuration'
import calculateResearchResourceCost from '../resources/calculateResearchResourceCost'

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

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

  if (player.researches.activeResearch) {
    throw new GameEngineError('player already researching')
  }

  const research = player.race.researches.find((research) =>
    research._id.equals(task.data.researchId)
  )

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

  const playerResearch = player.researches.researched.find(
    (playerResearch) => playerResearch.research.name === research.name
  )

  const level = playerResearch?.level || 0

  const researchResourceCost = calculateResearchResourceCost(research, level)

  const hasEnoughResources = player.planets.principal.resources >= researchResourceCost

  if (!hasEnoughResources) {
    // we try to execute next research present in the player research queue
    const nextResearchName = player.researches.queue.shift()
    const nextResearch = player.race.researches.find(
      (research) => research.name === nextResearchName
    )

    if (nextResearch) {
      const startResearchTask = createStartResearchTask(
        task.universeId,
        player._id.toString(),
        nextResearch._id.toString()
      )

      await Promise.all([player.save(), taskRepository.createStartResearchTask(startResearchTask)])
    }

    throw new GameEngineError('no resources available')
  }

  const researchBonus = computedBonus(player.perks, 'RESEARCH_BONUS')
  const researchDuration = calculateResearchDuration(research.initialTime, level, researchBonus)

  const executeTaskAt = getSecond(second + researchDuration)

  const principalPlanet = player.planets.principal

  principalPlanet.resources -= researchResourceCost

  // TODO: implement createBaseTask helper function
  const finishResearchTask: ITask<FinishResearchTaskType> = {
    type: FINISH_RESEARCH_TASK_TYPE,
    universeId: player.universeId,

    data: {
      playerId: player._id.toString(),
      researchId: task.data.researchId,
      researchDuration,
      researchResourceCost
    },

    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<FinishResearchTaskType>()
  const newTask = new taskModel(finishResearchTask)

  const activeResearch = {
    research: research,
    level: level + 1,
    executeTaskAt,
    taskId: newTask._id.toString()
  }

  player.researches.activeResearch = activeResearch

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

export default processStartResearchTask

1	import {	4✔
2	ITask,
3	FINISH_RESEARCH_TASK_TYPE,
4	FinishResearchTaskType,
5	PENDING_TASK_STATUS,
6	StartResearchTaskType
7	} from '../../types/ITask'
8	import getTaskModel, { ITaskTypeDocument } from '../../models/TaskModel'	4✔
9	import playerRepository from '../../repositories/playerRepository'	4✔
10	import taskRepository from '../../repositories/taskRepository'	4✔
11	import GameEngineError from '../errors/GameEngineError'	4✔
12	import getSecond from '../../helpers/getSecond'	4✔
13	import computedBonus from '../bonus/computedBonus'	4✔
14	import createStartResearchTask from './utils/createStartResearchTask'	4✔
15	import calculateResearchDuration from '../research/calculateResearchDuration'	4✔
16	import calculateResearchResourceCost from '../resources/calculateResearchResourceCost'	4✔
17
18	async function processStartResearchTask(
19	task: ITaskTypeDocument<StartResearchTaskType>,
20	second: number
21	) {
22	// get all the required data from DB
23	const player = await playerRepository.findPlayerById(task.data.playerId)	6✔
24
25	if (!player) {	6✔
26	throw new GameEngineError('invalid player')	1✔
27	}
28
29	if (player.researches.activeResearch) {	5✔
30	throw new GameEngineError('player already researching')	1✔
31	}
32
33	const research = player.race.researches.find((research) =>	4✔
34	research._id.equals(task.data.researchId)	31✔
35	)
36
37	if (!research) {	4✔
38	throw new GameEngineError('invalid research')	1✔
39	}
40
41	const playerResearch = player.researches.researched.find(	3✔
42	(playerResearch) => playerResearch.research.name === research.name	×
43	)
44
45	const level = playerResearch?.level \|\| 0	3✔
46
47	const researchResourceCost = calculateResearchResourceCost(research, level)	3✔
48
49	const hasEnoughResources = player.planets.principal.resources >= researchResourceCost	3✔
50
51	if (!hasEnoughResources) {	3✔
52	// we try to execute next research present in the player research queue
53	const nextResearchName = player.researches.queue.shift()	1✔
54	const nextResearch = player.race.researches.find(	1✔
55	(research) => research.name === nextResearchName	19✔
56	)
57
58	if (nextResearch) {	1!
59	const startResearchTask = createStartResearchTask(	×
60	task.universeId,
61	player._id.toString(),
62	nextResearch._id.toString()
63	)
64
NEW 65	await Promise.all([player.save(), taskRepository.createStartResearchTask(startResearchTask)])	×
66	}
67
68	throw new GameEngineError('no resources available')	1✔
69	}
70
71	const researchBonus = computedBonus(player.perks, 'RESEARCH_BONUS')	2✔
72	const researchDuration = calculateResearchDuration(research.initialTime, level, researchBonus)	2✔
73
74	const executeTaskAt = getSecond(second + researchDuration)	2✔
75
76	const principalPlanet = player.planets.principal	2✔
77
78	principalPlanet.resources -= researchResourceCost	2✔
79
80	// TODO: implement createBaseTask helper function
81	const finishResearchTask: ITask<FinishResearchTaskType> = {	2✔
82	type: FINISH_RESEARCH_TASK_TYPE,
83	universeId: player.universeId,
84
85	data: {
86	playerId: player._id.toString(),
87	researchId: task.data.researchId,
88	researchDuration,
89	researchResourceCost
90	},
91
92	status: PENDING_TASK_STATUS,
93	isCancellable: true,
94
95	executeTaskAt,
96
97	processedAt: null,
98	processingDuration: null,
99
100	history: [
101	{
102	taskStatus: PENDING_TASK_STATUS,
103	updatedAt: new Date().getTime()
104	}
105	],
106
107	errorDetails: null
108	}
109
110	const taskModel = getTaskModel<FinishResearchTaskType>()	2✔
111	const newTask = new taskModel(finishResearchTask)	2✔
112
113	const activeResearch = {	2✔
114	research: research,
115	level: level + 1,
116	executeTaskAt,
117	taskId: newTask._id.toString()
118	}
119
120	player.researches.activeResearch = activeResearch	2✔
121
122	return Promise.all([newTask.save(), principalPlanet.save(), player.save()])	2✔
123	}
124
125	export default processStartResearchTask	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