10946795972

Committed 19 Sep 2024 06:28PM UTC coverage: 96.824% (-0.3%) from 97.116%

Build # 10946795972

Build Type

push

github

Committed by

web-flow

Commit Message

Improvements (#7)

* fixed mongoose types

* using nodemailer instead of sendGrid

* use source instead of origin

* activeResearch & researched props within player.research

* bump deps

Run Details

75 of 79 branches covered (94.94%)

Branch coverage included in aggregate %.

66 of 66 new or added lines in 19 files covered. (100.0%)

2 existing lines in 2 files now uncovered.

748 of 771 relevant lines covered (97.02%)

5.57 hits per line

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

95.24

/packages/game-engine/src/engine/processTasks.ts

import { MongoServerError } from 'mongodb'

import groupTasksBySeconds from '../helpers/groupTasksBySeconds'
import {
  ERROR_TASK_STATUS,
  FINISH_RESEARCH_TASK_TYPE,
  ITaskDocument,
  ITaskTypeDocument,
  NEW_PLAYER_TASK_TYPE,
  PROCESSED_TASK_STATUS,
  START_RESEARCH_TASK_TYPE,
  TaskType
} from '../models/TaskModel'
import { IUniverseDocument } from '../models/UniverseModel'
import GameEngineError from './errors/GameEngineError'
import { TASK_HANDLER, TaskHandler } from './tasks/taskHandlers'
import calculateResourceProduction from './resources/calculateResourceProduction'

async function processTasks(tasks: ITaskDocument[], universe: IUniverseDocument) {
  const tasksGroupedBySeconds = groupTasksBySeconds(tasks, universe)

  for (const { tasks, second } of tasksGroupedBySeconds) {
    // TODO: execute tasks by type

    // 0.- Calculate player resources
    await calculateResourceProduction(tasks, second)

    // 1.- New player Tasks
    const newPlayerTasks = tasks.filter((task) => task.type === NEW_PLAYER_TASK_TYPE)

    const newPlayerTaskHandler = TASK_HANDLER[NEW_PLAYER_TASK_TYPE].handler

    await processTasksSequentially(newPlayerTasks, newPlayerTaskHandler, second)

    // 2.- Finish Research Tasks
    const finishResearchTaskHandler = TASK_HANDLER[FINISH_RESEARCH_TASK_TYPE].handler

    const finishResearchTasks = tasks.filter((task) => task.type === FINISH_RESEARCH_TASK_TYPE)
    await processTasksInParallel(finishResearchTasks, finishResearchTaskHandler, second)

    // 3.- Start Research Tasks
    const startResearchTaskHandler = TASK_HANDLER[START_RESEARCH_TASK_TYPE].handler

    const startResearchTasks = tasks.filter((task) => task.type === START_RESEARCH_TASK_TYPE)
    await processTasksSequentially(startResearchTasks, startResearchTaskHandler, second)

    // update universe
    universe.lastProcessedTime = second
    await universe.save()
  }
}

export default processTasks

// TODO: add tests here
async function processTasksSequentially<Type extends TaskType>(
  tasks: ITaskDocument[],
  handler: TaskHandler<Type>,
  second: number
) {
  for (const task of tasks) {
    await setTaskAsProcessed(task, handler, second)
  }
}

async function processTasksInParallel<Type extends TaskType>(
  tasks: ITaskDocument[],
  handler: TaskHandler<Type>,
  second: number
) {
  return Promise.all(tasks.map((task) => setTaskAsProcessed(task, handler, second)))
}

async function setTaskAsProcessed<Type extends TaskType>(
  task: ITaskDocument,
  handler: TaskHandler<Type>,
  second: number
) {
  const startTime = new Date().getTime()
  try {
    await handler(task as ITaskTypeDocument<Type>, second)
    task.status = PROCESSED_TASK_STATUS
    task.history.push({ taskStatus: PROCESSED_TASK_STATUS, updatedAt: new Date().getTime() })
  } catch (error) {
    if (error instanceof MongoServerError) {
      task.errorDetails = error.message
    }
    if (error instanceof GameEngineError) {
      task.errorDetails = error.message
    }

    task.status = ERROR_TASK_STATUS
    task.history.push({ taskStatus: ERROR_TASK_STATUS, updatedAt: new Date().getTime() })
  }

  task.isCancellable = false
  task.processedAt = second
  const endTime = new Date().getTime()
  task.processingDuration = endTime - startTime
  return task.save()
}

1	import { MongoServerError } from 'mongodb'	4✔
2
3	import groupTasksBySeconds from '../helpers/groupTasksBySeconds'	4✔
4	import {	4✔
5	ERROR_TASK_STATUS,
6	FINISH_RESEARCH_TASK_TYPE,
7	ITaskDocument,
8	ITaskTypeDocument,
9	NEW_PLAYER_TASK_TYPE,
10	PROCESSED_TASK_STATUS,
11	START_RESEARCH_TASK_TYPE,
12	TaskType
13	} from '../models/TaskModel'
14	import { IUniverseDocument } from '../models/UniverseModel'
15	import GameEngineError from './errors/GameEngineError'	4✔
16	import { TASK_HANDLER, TaskHandler } from './tasks/taskHandlers'	4✔
17	import calculateResourceProduction from './resources/calculateResourceProduction'	4✔
18
19	async function processTasks(tasks: ITaskDocument[], universe: IUniverseDocument) {
20	const tasksGroupedBySeconds = groupTasksBySeconds(tasks, universe)	23✔
21
22	for (const { tasks, second } of tasksGroupedBySeconds) {	23✔
23	// TODO: execute tasks by type
24
25	// 0.- Calculate player resources
26	await calculateResourceProduction(tasks, second)	23✔
27
28	// 1.- New player Tasks
29	const newPlayerTasks = tasks.filter((task) => task.type === NEW_PLAYER_TASK_TYPE)	23✔
30
31	const newPlayerTaskHandler = TASK_HANDLER[NEW_PLAYER_TASK_TYPE].handler	23✔
32
33	await processTasksSequentially(newPlayerTasks, newPlayerTaskHandler, second)	23✔
34
35	// 2.- Finish Research Tasks
36	const finishResearchTaskHandler = TASK_HANDLER[FINISH_RESEARCH_TASK_TYPE].handler	23✔
37
38	const finishResearchTasks = tasks.filter((task) => task.type === FINISH_RESEARCH_TASK_TYPE)	23✔
39	await processTasksInParallel(finishResearchTasks, finishResearchTaskHandler, second)	23✔
40
41	// 3.- Start Research Tasks
42	const startResearchTaskHandler = TASK_HANDLER[START_RESEARCH_TASK_TYPE].handler	23✔
43
44	const startResearchTasks = tasks.filter((task) => task.type === START_RESEARCH_TASK_TYPE)	23✔
45	await processTasksSequentially(startResearchTasks, startResearchTaskHandler, second)	23✔
46
47	// update universe
48	universe.lastProcessedTime = second	23✔
49	await universe.save()	23✔
50	}
51	}
52
53	export default processTasks	4✔
54
55	// TODO: add tests here
56	async function processTasksSequentially<Type extends TaskType>(
57	tasks: ITaskDocument[],
58	handler: TaskHandler<Type>,
59	second: number
60	) {
61	for (const task of tasks) {	46✔
62	await setTaskAsProcessed(task, handler, second)	12✔
63	}
64	}
65
66	async function processTasksInParallel<Type extends TaskType>(
67	tasks: ITaskDocument[],
68	handler: TaskHandler<Type>,
69	second: number
70	) {
71	return Promise.all(tasks.map((task) => setTaskAsProcessed(task, handler, second)))	23✔
72	}
73
74	async function setTaskAsProcessed<Type extends TaskType>(
75	task: ITaskDocument,
76	handler: TaskHandler<Type>,
77	second: number
78	) {
79	const startTime = new Date().getTime()	23✔
80	try {	23✔
81	await handler(task as ITaskTypeDocument<Type>, second)	23✔
82	task.status = PROCESSED_TASK_STATUS	13✔
83	task.history.push({ taskStatus: PROCESSED_TASK_STATUS, updatedAt: new Date().getTime() })	13✔
84	} catch (error) {
85	if (error instanceof MongoServerError) {	10!
UNCOV 86	task.errorDetails = error.message	×
87	}
88	if (error instanceof GameEngineError) {	10✔
89	task.errorDetails = error.message	10✔
90	}
91
92	task.status = ERROR_TASK_STATUS	10✔
93	task.history.push({ taskStatus: ERROR_TASK_STATUS, updatedAt: new Date().getTime() })	10✔
94	}
95
96	task.isCancellable = false	23✔
97	task.processedAt = second	23✔
98	const endTime = new Date().getTime()	23✔
99	task.processingDuration = endTime - startTime	23✔
100	return task.save()	23✔
101	}

DaniSomoza / galactic-commander / 10946795972

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