14945988074

Committed 10 May 2025 01:53PM UTC coverage: 47.968% (-4.1%) from 52.086%

Build # 14945988074

Build Type

Pull #12

github

Committed by

web-flow

Commit Message

Merge c2bc38153 into a8e301a23

Pull Request Pull Request #12: [fleets] Explore planets

Run Details

215 of 915 branches covered (23.5%)

Branch coverage included in aggregate %.

160 of 514 new or added lines in 56 files covered. (31.13%)

10 existing lines in 9 files now uncovered.

1567 of 2800 relevant lines covered (55.96%)

3.45 hits per line

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

15.49

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

import FleetModel, { IFleetDocument } from '../../models/FleetModel'
import { IPlanetDocument } from '../../models/PlanetModel'
import { IPlayerDocument } from '../../models/PlayerModel'
import PlayerUnitsModel from '../../models/PlayerUnitsModel'
import getTaskModel, { ITaskTypeDocument } from '../../models/TaskModel'
import fleetRepository from '../../repositories/fleetRepository'
import planetRepository from '../../repositories/planetRepository'
import playerRepository from '../../repositories/playerRepository'
import playerUnitsRepository from '../../repositories/playerUnitsRepository'
import unitRepository from '../../repositories/unitRepository'
import {
  FINISH_FLEET_TASK_TYPE,
  FinishFleetTaskType,
  ITask,
  PENDING_TASK_STATUS
} from '../../types/ITask'
import GameEngineError from '../errors/GameEngineError'

async function processFinishFleetTask(
  task: ITaskTypeDocument<FinishFleetTaskType>,
  second: number
) {
  // TODO: USE PROMISE ALL ???
  // get all the required data from DB
  const player = await playerRepository.findPlayerById(task.data.playerId)
  const fromPlanet = await planetRepository.findPlanetById(task.data.fromPlanetId)
  const toPlanet = await planetRepository.findPlanetById(task.data.toPlanetId)
  const fleet = await fleetRepository.findFleetById(task.data.fleetId)

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

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

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

  if (toPlanet._id.equals(fromPlanet._id)) {
    throw new GameEngineError('invalid planet')
  }

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

  if (task.data.isReturning) {
    return processReturningFleetTask({
      fleet,
      player,
      toPlanet,
      taskData: task.data
    })
  }

  if (task.data.fleetType === 'EXPLORE_FLEET_TYPE') {
    return processFinishExploreFleetTask({
      fleet,
      player,
      fromPlanet,
      toPlanet,
      taskData: task.data,
      second
    })
  }

  throw 'fleet type not implemented'
}

export default processFinishFleetTask

type ReturningFleetType = {
  fleet: IFleetDocument
  player: IPlayerDocument
  toPlanet: IPlanetDocument
  taskData: ITask<'FINISH_FLEET_UNITS_TASK'>['data']
}

async function processReturningFleetTask({
  fleet,
  player,
  toPlanet,
  taskData
}: ReturningFleetType) {
  const playerUnitsInThePlanet = await playerUnitsRepository.findPlayerUnitsInThePlanet(
    player._id.toString(),
    toPlanet._id.toString()
  )

  const unitsInThePlanet =
    playerUnitsInThePlanet ||
    new PlayerUnitsModel({
      planet: toPlanet,
      player,
      units: []
    })

  const units = await unitRepository.findUnits()

  // restore units in the fleet planet
  for (let i = 0; i < taskData.units.length; i++) {
    const fleetUnit = taskData.units[i]

    const planetUnit = unitsInThePlanet.units.find(({ unit }) => unit.name === fleetUnit.unit.name)

    if (planetUnit) {
      planetUnit.amount += fleetUnit.amount
    } else {
      const unit = units.find((unit) => unit.name === fleetUnit.unit.name)

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

      unitsInThePlanet.units.push({
        unit,
        amount: fleetUnit.amount
      })
    }
  }

  // planet resources
  toPlanet.resources += fleet.resources

  fleet.isFinished = true

  return Promise.all([fleet.save(), unitsInThePlanet.save()])
}

type FinishExploreFleetType = {
  fleet: IFleetDocument
  player: IPlayerDocument
  fromPlanet: IPlanetDocument
  toPlanet: IPlanetDocument
  taskData: ITask<'FINISH_FLEET_UNITS_TASK'>['data']
  second: number
}

async function processFinishExploreFleetTask({
  fleet,
  player,
  fromPlanet,
  toPlanet,
  taskData,
  second
}: FinishExploreFleetType) {
  const executeTaskAt = second + fleet.duration

  // finish actual fleet
  fleet.isFinished = true

  // create returning fleet
  const newReturningFleet = new FleetModel({
    playerId: player._id.toString(),
    units: taskData.units,
    isReturning: true,
    isFinished: false,
    fromPlanet: toPlanet,
    toPlanet: fromPlanet,
    startedAt: second,
    arriveAt: executeTaskAt,
    duration: fleet.duration,
    fleetType: taskData.fleetType,
    resources: 0
  })

  toPlanet.isExplored = true

  // TODO: implement createBaseTask helper function
  const finishBuildUnitsTask: ITask<FinishFleetTaskType> = {
    type: FINISH_FLEET_TASK_TYPE,
    universeId: player.universeId,
    data: {
      playerId: player._id.toString(),
      fromPlanetId: toPlanet._id.toString(),
      toPlanetId: fromPlanet._id.toString(),
      units: taskData.units,
      resources: taskData.resources,
      fleetType: taskData.fleetType,
      allUnitsInThePlanet: taskData.allUnitsInThePlanet,
      allResourcesInThePlanet: taskData.allResourcesInThePlanet,
      isReturning: true,
      arriveAt: executeTaskAt,
      fleetId: newReturningFleet._id.toString()
    },
    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<FinishFleetTaskType>()
  const newTask = new taskModel(finishBuildUnitsTask)

  newReturningFleet.taskId = newTask._id.toString()

  // TODO: create exploration report

  const isAlreadyExplored = toPlanet.exploredBy.some(
    (exploredPlayer) => exploredPlayer === player._id.toString()
  )

  if (!isAlreadyExplored) {
    toPlanet.exploredBy.push(player._id.toString())
  }

  return Promise.all([newTask.save(), toPlanet.save(), fleet.save(), newReturningFleet.save()])
}

1	import FleetModel, { IFleetDocument } from '../../models/FleetModel'	4✔
2	import { IPlanetDocument } from '../../models/PlanetModel'
3	import { IPlayerDocument } from '../../models/PlayerModel'
4	import PlayerUnitsModel from '../../models/PlayerUnitsModel'	4✔
5	import getTaskModel, { ITaskTypeDocument } from '../../models/TaskModel'	4✔
6	import fleetRepository from '../../repositories/fleetRepository'	4✔
7	import planetRepository from '../../repositories/planetRepository'	4✔
8	import playerRepository from '../../repositories/playerRepository'	4✔
9	import playerUnitsRepository from '../../repositories/playerUnitsRepository'	4✔
10	import unitRepository from '../../repositories/unitRepository'	4✔
11	import {	4✔
12	FINISH_FLEET_TASK_TYPE,
13	FinishFleetTaskType,
14	ITask,
15	PENDING_TASK_STATUS
16	} from '../../types/ITask'
17	import GameEngineError from '../errors/GameEngineError'	4✔
18
19	async function processFinishFleetTask(
20	task: ITaskTypeDocument<FinishFleetTaskType>,
21	second: number
22	) {
23	// TODO: USE PROMISE ALL ???
24	// get all the required data from DB
NEW 25	const player = await playerRepository.findPlayerById(task.data.playerId)	×
NEW 26	const fromPlanet = await planetRepository.findPlanetById(task.data.fromPlanetId)	×
NEW 27	const toPlanet = await planetRepository.findPlanetById(task.data.toPlanetId)	×
NEW 28	const fleet = await fleetRepository.findFleetById(task.data.fleetId)	×
29
NEW 30	if (!player) {	×
NEW 31	throw new GameEngineError('invalid player')	×
32	}
33
NEW 34	if (!fromPlanet) {	×
NEW 35	throw new GameEngineError('invalid from planet')	×
36	}
37
NEW 38	if (!toPlanet) {	×
NEW 39	throw new GameEngineError('invalid to planet')	×
40	}
41
NEW 42	if (toPlanet._id.equals(fromPlanet._id)) {	×
NEW 43	throw new GameEngineError('invalid planet')	×
44	}
45
NEW 46	if (!fleet) {	×
NEW 47	throw new GameEngineError('invalid fleet')	×
48	}
49
NEW 50	if (task.data.isReturning) {	×
NEW 51	return processReturningFleetTask({	×
52	fleet,
53	player,
54	toPlanet,
55	taskData: task.data
56	})
57	}
58
NEW 59	if (task.data.fleetType === 'EXPLORE_FLEET_TYPE') {	×
NEW 60	return processFinishExploreFleetTask({	×
61	fleet,
62	player,
63	fromPlanet,
64	toPlanet,
65	taskData: task.data,
66	second
67	})
68	}
69
NEW 70	throw 'fleet type not implemented'	×
71	}
72
73	export default processFinishFleetTask	4✔
74
75	type ReturningFleetType = {
76	fleet: IFleetDocument
77	player: IPlayerDocument
78	toPlanet: IPlanetDocument
79	taskData: ITask<'FINISH_FLEET_UNITS_TASK'>['data']
80	}
81
82	async function processReturningFleetTask({
83	fleet,
84	player,
85	toPlanet,
86	taskData
87	}: ReturningFleetType) {
NEW 88	const playerUnitsInThePlanet = await playerUnitsRepository.findPlayerUnitsInThePlanet(	×
89	player._id.toString(),
90	toPlanet._id.toString()
91	)
92
93	const unitsInThePlanet =
NEW 94	playerUnitsInThePlanet \|\|	×
95	new PlayerUnitsModel({
96	planet: toPlanet,
97	player,
98	units: []
99	})
100
NEW 101	const units = await unitRepository.findUnits()	×
102
103	// restore units in the fleet planet
NEW 104	for (let i = 0; i < taskData.units.length; i++) {	×
NEW 105	const fleetUnit = taskData.units[i]	×
106
NEW 107	const planetUnit = unitsInThePlanet.units.find(({ unit }) => unit.name === fleetUnit.unit.name)	×
108
NEW 109	if (planetUnit) {	×
NEW 110	planetUnit.amount += fleetUnit.amount	×
111	} else {
NEW 112	const unit = units.find((unit) => unit.name === fleetUnit.unit.name)	×
113
NEW 114	if (!unit) {	×
NEW 115	throw new GameEngineError('invalid fleet unit')	×
116	}
117
NEW 118	unitsInThePlanet.units.push({	×
119	unit,
120	amount: fleetUnit.amount
121	})
122	}
123	}
124
125	// planet resources
NEW 126	toPlanet.resources += fleet.resources	×
127
NEW 128	fleet.isFinished = true	×
129
NEW 130	return Promise.all([fleet.save(), unitsInThePlanet.save()])	×
131	}
132
133	type FinishExploreFleetType = {
134	fleet: IFleetDocument
135	player: IPlayerDocument
136	fromPlanet: IPlanetDocument
137	toPlanet: IPlanetDocument
138	taskData: ITask<'FINISH_FLEET_UNITS_TASK'>['data']
139	second: number
140	}
141
142	async function processFinishExploreFleetTask({
143	fleet,
144	player,
145	fromPlanet,
146	toPlanet,
147	taskData,
148	second
149	}: FinishExploreFleetType) {
NEW 150	const executeTaskAt = second + fleet.duration	×
151
152	// finish actual fleet
NEW 153	fleet.isFinished = true	×
154
155	// create returning fleet
NEW 156	const newReturningFleet = new FleetModel({	×
157	playerId: player._id.toString(),
158	units: taskData.units,
159	isReturning: true,
160	isFinished: false,
161	fromPlanet: toPlanet,
162	toPlanet: fromPlanet,
163	startedAt: second,
164	arriveAt: executeTaskAt,
165	duration: fleet.duration,
166	fleetType: taskData.fleetType,
167	resources: 0
168	})
169
NEW 170	toPlanet.isExplored = true	×
171
172	// TODO: implement createBaseTask helper function
NEW 173	const finishBuildUnitsTask: ITask<FinishFleetTaskType> = {	×
174	type: FINISH_FLEET_TASK_TYPE,
175	universeId: player.universeId,
176	data: {
177	playerId: player._id.toString(),
178	fromPlanetId: toPlanet._id.toString(),
179	toPlanetId: fromPlanet._id.toString(),
180	units: taskData.units,
181	resources: taskData.resources,
182	fleetType: taskData.fleetType,
183	allUnitsInThePlanet: taskData.allUnitsInThePlanet,
184	allResourcesInThePlanet: taskData.allResourcesInThePlanet,
185	isReturning: true,
186	arriveAt: executeTaskAt,
187	fleetId: newReturningFleet._id.toString()
188	},
189	status: PENDING_TASK_STATUS,
190	isCancellable: true,
191	executeTaskAt,
192	processedAt: null,
193	processingDuration: null,
194	history: [
195	{
196	taskStatus: PENDING_TASK_STATUS,
197	updatedAt: new Date().getTime()
198	}
199	],
200	errorDetails: null
201	}
NEW 202	const taskModel = getTaskModel<FinishFleetTaskType>()	×
NEW 203	const newTask = new taskModel(finishBuildUnitsTask)	×
204
NEW 205	newReturningFleet.taskId = newTask._id.toString()	×
206
207	// TODO: create exploration report
208
NEW 209	const isAlreadyExplored = toPlanet.exploredBy.some(	×
NEW 210	(exploredPlayer) => exploredPlayer === player._id.toString()	×
211	)
212
NEW 213	if (!isAlreadyExplored) {	×
NEW 214	toPlanet.exploredBy.push(player._id.toString())	×
215	}
216
NEW 217	return Promise.all([newTask.save(), toPlanet.save(), fleet.save(), newReturningFleet.save()])	×
218	}

DaniSomoza / galactic-commander / 14945988074

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