11940541664

Committed 20 Nov 2024 07:39PM UTC coverage: 65.587% (-31.2%) from 96.824%

Build # 11940541664

Build Type

push

github

Committed by

web-flow

Commit Message

Frontend initial implementation and player perks feature (#10)

* added vite react-ts template

* Add register and login pages

* Add initial frontend implementation

* Add first iteration of research queue

* first version of the research page

* added assets

* Added pirate research assets

* Added translation support

* updated planet images

* added first version of the bonus

Run Details

181 of 418 branches covered (43.3%)

Branch coverage included in aggregate %.

532 of 983 new or added lines in 110 files covered. (54.12%)

8 existing lines in 4 files now uncovered.

1176 of 1651 relevant lines covered (71.23%)

4.75 hits per line

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

92.0

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

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

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

  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.research)
  )

  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.universe._id,
        player._id,
        nextResearch._id
      )

      await Promise.all([
        player.save(),
        await 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,
    universe: player.universe._id,

    data: {
      player: player._id,
      research: task.data.research,
      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._id,
    level: level + 1,
    executeTaskAt,
    taskId: newTask._id
  }

  player.researches.activeResearch = activeResearch

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

export default processStartResearchTask

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

DaniSomoza / galactic-commander / 11940541664

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