Skip to content

Commit a7edd15

Browse files
ClashsoftClashsoft
authored
Game Ticks via REST (#61)
* feat: Tick game via PATCH instead of schedule * fix: Await game init and tick before returning from PATCH request * docs: Improve documentation for game tick * feat: Allow any speed * docs: Better period docs
1 parent 26dce9d commit a7edd15

8 files changed

+137
-183
lines changed

‎docs/WebSocket.md

+3-3
Original file line numberDiff line numberDiff line change
@@ -62,13 +62,13 @@ However, the payload within the `data` field may contain any JSON value, not jus
6262
The following table shows which events may be sent.
6363
Some events are only visible to certain users for privacy reasons.
6464

65-
| Event Name | Payload | Visible to | Note |
66-
|---------------------------------------------------------------|----------------------------------------------------------------------------------|---------------------|-----------------------------------------|
65+
| Event Name | Payload | Visible to | Note |
66+
|---------------------------------------------------------------|----------------------------------------------------------------------------------|---------------------|-------------------------------------------------------|
6767
| `users.<userId>.{created,updated,deleted}`<sup>1, 2</sup> | [`User`](#model-User) | Everyone |
6868
| `users.<userId>.achievements.<id>.{created,updated,deleted}` | [`Achievement`](#model-Achievement) | Everyone |
6969
| `users.<from>.friends.<to>.{created,updated,deleted}` | [`Friend`](#model-Friend) | `from` or `to` User |
7070
| `games.<gameId>.{created,updated,deleted}` | [`Game`](#model-Game) | Everyone |
71-
| `games.<gameId>.ticked` | [`Game`](#model-Game) | Everyone | Sent when the game updates periodically |
71+
| `games.<gameId>.ticked` | [`Game`](#model-Game) | Everyone | Sent when ticking the game, after the `updated` event |
7272
| `games.<gameId>.members.<userId>.{created,updated,deleted}` | [`Member`](#model-Member) | Everyone |
7373
| `games.<gameId>.systems.<systemId>.{created,updated,deleted}` | [`System`](#model-System) | Game Members |
7474
| `games.<gameId>.empires.<empireId>.{created,updated,deleted}` | [`Empire`](#model-Empire) or [`ReadEmpireDto`](#model-ReadEmpireDto)<sup>3</sup> | Game Members |

‎src/game-logic/game-logic.handler.ts

-102
This file was deleted.

‎src/game-logic/game-logic.module.ts

+4-7
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,19 @@
1-
import {Module} from '@nestjs/common';
1+
import {forwardRef, Module} from '@nestjs/common';
22
import {GameLogicService} from './game-logic.service';
3-
import {environment} from '../environment';
4-
import {GameLogicScheduler} from './game-logic.scheduler';
5-
import {GameModule} from '../game/game.module';
63
import {SystemModule} from '../system/system.module';
74
import {EmpireModule} from '../empire/empire.module';
85
import {GameLogicController} from './game-logic.controller';
9-
import {GameLogicHandler} from './game-logic.handler';
106
import {MemberModule} from '../member/member.module';
117

128
@Module({
139
imports: [
14-
GameModule,
10+
forwardRef(() => require('../game/game.module').GameModule),
1511
MemberModule,
1612
SystemModule,
1713
EmpireModule,
1814
],
19-
providers: environment.passive ? [GameLogicService, GameLogicHandler] : [GameLogicService, GameLogicHandler, GameLogicScheduler],
15+
providers: [GameLogicService],
16+
exports: [GameLogicService],
2017
controllers: [GameLogicController],
2118
})
2219
export class GameLogicModule {

‎src/game-logic/game-logic.scheduler.ts

-38
This file was deleted.

‎src/game-logic/game-logic.service.ts

+79-18
Original file line numberDiff line numberDiff line change
@@ -1,49 +1,110 @@
11
import {Injectable} from '@nestjs/common';
2-
import {GameService} from '../game/game.service';
32
import {EmpireService} from '../empire/empire.service';
43
import {SystemService} from '../system/system.service';
54
import {Empire, EmpireDocument} from '../empire/empire.schema';
65
import {System, SystemDocument} from '../system/system.schema';
7-
import {calculateVariable, calculateVariables, getInitialVariables} from './variables';
6+
import {calculateVariables, getInitialVariables} from './variables';
87
import {Technology, Variable} from './types';
98
import {ResourceName} from './resources';
109
import {DistrictName, DISTRICTS} from './districts';
1110
import {BUILDINGS} from './buildings';
12-
import {SYSTEM_UPGRADES, SystemUpgradeName} from './system-upgrade';
11+
import {SYSTEM_UPGRADES} from './system-upgrade';
1312
import {AggregateItem, AggregateResult} from './aggregates';
1413
import {TECHNOLOGIES} from './technologies';
1514
import {Types} from 'mongoose';
1615
import {notFound} from '@mean-stream/nestx';
16+
import {Game} from '../game/game.schema';
17+
import {HOMESYSTEM_BUILDINGS, HOMESYSTEM_DISTRICT_COUNT, HOMESYSTEM_DISTRICTS} from './constants';
18+
import {MemberService} from '../member/member.service';
1719

1820
@Injectable()
1921
export class GameLogicService {
2022
constructor(
21-
private gameService: GameService,
23+
private memberService: MemberService,
2224
private empireService: EmpireService,
2325
private systemService: SystemService,
2426
) {
2527
}
2628

27-
async updateGames(speed: number) {
28-
const games = await this.gameService.findAll({started: true, speed});
29-
const gameIds = games.map(game => game._id);
30-
const empires = await this.empireService.findAll({game: {$in: gameIds}});
31-
const systems = await this.systemService.findAll({game: {$in: gameIds}});
32-
for (const game of games) {
33-
game.$inc('period', 1);
34-
const gameEmpires = empires.filter(empire => empire.game.equals(game._id));
35-
const gameSystems = systems.filter(system => system.game.equals(game._id));
36-
this.updateGame(gameEmpires, gameSystems);
29+
async startGame(game: Game): Promise<void> {
30+
const members = await this.memberService.findAll({
31+
game: game._id,
32+
empire: {$exists: true},
33+
});
34+
const empires = await this.empireService.initEmpires(members);
35+
if (!empires.length) {
36+
// game was already started
37+
return;
38+
}
39+
40+
const systems = await this.systemService.generateMap(game);
41+
const homeSystems = new Set<string>();
42+
43+
// select a home system for each empire
44+
for (const empire of empires) { // NB: cannot be indexed because some members may not have empires (spectators)
45+
const member = members.find(m => empire.user.equals(m.user));
46+
const homeSystem = this.selectHomeSystem(systems, homeSystems);
47+
48+
homeSystem.owner = empire._id;
49+
homeSystem.population = empire.resources.population;
50+
homeSystem.upgrade = 'developed';
51+
homeSystem.capacity *= SYSTEM_UPGRADES.developed.capacity_multiplier;
52+
if (member?.empire?.homeSystem) {
53+
homeSystem.type = member.empire.homeSystem;
54+
}
55+
this.systemService.generateDistricts(homeSystem, empire);
56+
57+
// every home system starts with 15 districts
58+
this.generateDistricts(homeSystem);
59+
60+
// plus 7 buildings, so 22 jobs in total
61+
homeSystem.buildings = HOMESYSTEM_BUILDINGS;
62+
63+
const totalJobs = Object.values(homeSystem.districts).sum() + homeSystem.buildings.length;
64+
if (homeSystem.capacity < totalJobs) {
65+
homeSystem.capacity = totalJobs;
66+
}
67+
68+
// then 3 pops will be unemployed initially.
69+
empire.homeSystem = homeSystem._id;
3770
}
71+
3872
await this.empireService.saveAll(empires);
3973
await this.systemService.saveAll(systems);
40-
await this.gameService.saveAll(games);
41-
for (const game of games) {
42-
this.gameService.emit('ticked', game);
74+
}
75+
76+
private selectHomeSystem(systems: SystemDocument[], homeSystems: Set<string>) {
77+
let homeSystem: SystemDocument;
78+
do {
79+
homeSystem = systems.random();
80+
} while (
81+
homeSystems.has(homeSystem._id.toString())
82+
|| Object.keys(homeSystem.links).some(link => homeSystems.has(link))
83+
);
84+
homeSystems.add(homeSystem._id.toString());
85+
return homeSystem;
86+
}
87+
88+
private generateDistricts(homeSystem: SystemDocument) {
89+
for (const district of HOMESYSTEM_DISTRICTS) {
90+
homeSystem.districts[district] = HOMESYSTEM_DISTRICT_COUNT;
91+
if (!homeSystem.districtSlots[district] || homeSystem.districtSlots[district]! < HOMESYSTEM_DISTRICT_COUNT) {
92+
homeSystem.districtSlots[district] = HOMESYSTEM_DISTRICT_COUNT;
93+
homeSystem.markModified('districtSlots');
94+
}
4395
}
96+
homeSystem.markModified('districts');
97+
}
98+
99+
async updateGame(game: Game) {
100+
const empires = await this.empireService.findAll({game: game._id});
101+
const systems = await this.systemService.findAll({game: game._id});
102+
this._updateGame(empires, systems);
103+
await this.empireService.saveAll(empires);
104+
await this.systemService.saveAll(systems);
44105
}
45106

46-
private updateGame(empires: EmpireDocument[], systems: SystemDocument[]) {
107+
private _updateGame(empires: EmpireDocument[], systems: SystemDocument[]) {
47108
for (const empire of empires) {
48109
const empireSystems = systems.filter(system => system.owner?.equals(empire._id));
49110
this.updateEmpire(empire, empireSystems);

‎src/game/game.controller.ts

+32-8
Original file line numberDiff line numberDiff line change
@@ -27,8 +27,9 @@ import {Validated} from '../util/validated.decorator';
2727
import {CreateGameDto, UpdateGameDto} from './game.dto';
2828
import {Game} from './game.schema';
2929
import {GameService} from './game.service';
30-
import {NotFound, ObjectIdPipe} from '@mean-stream/nestx';
31-
import {Types} from 'mongoose';
30+
import {notFound, NotFound, ObjectIdPipe} from '@mean-stream/nestx';
31+
import {Types, UpdateQuery} from 'mongoose';
32+
import {GameLogicService} from '../game-logic/game-logic.service';
3233

3334
@Controller('games')
3435
@ApiTags('Games')
@@ -38,6 +39,7 @@ import {Types} from 'mongoose';
3839
export class GameController {
3940
constructor(
4041
private readonly gameService: GameService,
42+
private readonly gameLogicService: GameLogicService,
4143
) {
4244
}
4345

@@ -74,18 +76,40 @@ export class GameController {
7476
@ApiOkResponse({type: Game})
7577
@ApiConflictResponse({description: 'Game is already running.'})
7678
@ApiForbiddenResponse({description: 'Attempt to change a game that the current user does not own.'})
77-
async update(@AuthUser() user: User, @Param('id', ObjectIdPipe) id: Types.ObjectId, @Body() dto: UpdateGameDto): Promise<Game | null> {
78-
const existing = await this.gameService.find(id);
79-
if (!existing) {
80-
throw new NotFoundException(id);
81-
}
79+
@ApiQuery({
80+
name: 'tick',
81+
description: 'Advance the game by one period and run all empire and system calculations.',
82+
type: 'boolean',
83+
required: false,
84+
})
85+
async update(
86+
@AuthUser() user: User,
87+
@Param('id', ObjectIdPipe) id: Types.ObjectId,
88+
@Body() dto: UpdateGameDto,
89+
@Query('tick', new ParseBoolPipe({optional: true})) tick?: boolean,
90+
): Promise<Game | null> {
91+
const existing = await this.gameService.find(id) ?? notFound(id);
8292
if (!user._id.equals(existing.owner)) {
8393
throw new ForbiddenException('Only the owner can change the game.');
8494
}
8595
if (existing.started && !(Object.keys(dto).length === 1 && dto.speed !== undefined)) {
8696
throw new ConflictException('Cannot change a running game.');
8797
}
88-
return this.gameService.update(id, dto, {populate: 'members'});
98+
const update: UpdateQuery<Game> = dto;
99+
if (tick) {
100+
update.started = true;
101+
update.$inc = {period: 1};
102+
update.tickedAt = new Date();
103+
}
104+
const result = await this.gameService.update(id, dto, {populate: 'members'});
105+
if (result && !existing.started && result.started) {
106+
await this.gameLogicService.startGame(result);
107+
}
108+
if (tick && result) {
109+
await this.gameLogicService.updateGame(result);
110+
this.gameService.emit('ticked', result);
111+
}
112+
return result;
89113
}
90114

91115
@Delete(':id')

‎src/game/game.module.ts

+2-1
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
import {Module} from '@nestjs/common';
1+
import {forwardRef, Module} from '@nestjs/common';
22
import {MongooseModule} from '@nestjs/mongoose';
33
import {environment} from '../environment';
44
import {GameController} from './game.controller';
@@ -13,6 +13,7 @@ import {GameService} from './game.service';
1313
name: Game.name,
1414
schema: GameSchema,
1515
}]),
16+
forwardRef(() => require('../game-logic/game-logic.module').GameLogicModule),
1617
],
1718
controllers: [GameController],
1819
providers: [

0 commit comments

Comments
 (0)