Skip to content

Commit 418ec09

Browse files
ClashsoftClashsoft
authored
Jobs Refactoring pt.3 (#82)
* refactor: Add JobLogicService * fix: Unlock technologies in JobLogicService And remove ability to unlock technologies via PATCH. * refactor: Upgrade Systems * refactor: Add EmpireLogicService * refactor: Add SystemLogicService * refactor: Move building and district logic to SystemLogicService * fix: Allow colonizing unowned systems * refactor: Remove some unused things * fix: Destroy districts bug * refactor: Move some methods to EmpireLogicService * refactor: Move some methods to SystemLogicService * fix: Emit job created events * fix: Handle jobs per empire * refactor: Move job progress logic to JobService * refactor: Move some save() responsibility
1 parent 09cf093 commit 418ec09

15 files changed

+489
-586
lines changed

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

+108
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,108 @@
1+
import {BadRequestException, Injectable} from '@nestjs/common';
2+
import {EmpireDocument} from './empire.schema';
3+
import {TECHNOLOGIES} from '../game-logic/technologies';
4+
import {notFound} from '@mean-stream/nestx';
5+
import {UserDocument} from '../user/user.schema';
6+
import {Technology, Variable} from '../game-logic/types';
7+
import {calculateVariables, getVariables, VARIABLES} from '../game-logic/variables';
8+
import {RESOURCE_NAMES, ResourceName} from '../game-logic/resources';
9+
import {SystemDocument} from '../system/system.schema';
10+
11+
@Injectable()
12+
export class EmpireLogicService {
13+
constructor(
14+
// Keep injections to a minimum, we want this to be pure logic
15+
) {
16+
}
17+
18+
getCosts(prefix: keyof typeof VARIABLES, name: string, empire: EmpireDocument, system?: SystemDocument): Partial<Record<ResourceName, number>> {
19+
const result: Partial<Record<ResourceName, number>> = {};
20+
const variables = getVariables(prefix);
21+
calculateVariables(variables, empire, system);
22+
for (const resource of RESOURCE_NAMES) { // support custom variables
23+
const variable = `${prefix}.${name}.cost.${resource}`;
24+
if (variable in variables) {
25+
result[resource] = variables[variable as Variable];
26+
}
27+
}
28+
return result;
29+
}
30+
31+
refundResources(empire: EmpireDocument, cost: Partial<Record<ResourceName, number>>) {
32+
for (const [resource, amount] of Object.entries(cost) as [ResourceName, number][] ) {
33+
if (empire.resources[resource] !== undefined) {
34+
empire.resources[resource] += amount;
35+
} else {
36+
empire.resources[resource] = amount;
37+
}
38+
}
39+
empire.markModified('resources');
40+
}
41+
42+
deductResources(empire: EmpireDocument, cost: Partial<Record<ResourceName, number>>): void {
43+
const missingResources = Object.entries(cost)
44+
.filter(([resource, amount]) => empire.resources[resource as ResourceName] < amount)
45+
.map(([resource, _]) => resource);
46+
if (missingResources.length) {
47+
throw new BadRequestException(`Not enough resources: ${missingResources.join(', ')}`);
48+
}
49+
for (const [resource, amount] of Object.entries(cost)) {
50+
empire.resources[resource as ResourceName] -= amount;
51+
}
52+
empire.markModified('resources');
53+
}
54+
55+
getTechnologyCost(user: UserDocument, empire: EmpireDocument, technology: Technology) {
56+
const variables = {
57+
...getVariables('technologies'),
58+
...getVariables('empire'),
59+
};
60+
calculateVariables(variables, empire);
61+
const technologyCount = user.technologies?.[technology.id] || 0;
62+
63+
const difficultyMultiplier = variables['empire.technologies.difficulty'] || 1;
64+
let technologyCost = technology.cost * difficultyMultiplier;
65+
66+
// step 1: if the user has already unlocked this tech, decrease the cost exponentially
67+
if (technologyCount) {
68+
const baseCostMultiplier = variables['empire.technologies.cost_multiplier'] || 1;
69+
const unlockCostMultiplier = baseCostMultiplier ** Math.min(technologyCount, 10);
70+
technologyCost *= unlockCostMultiplier;
71+
}
72+
73+
// step 2: apply tag multipliers
74+
for (const tag of technology.tags) {
75+
const tagCostMultiplier = variables[`technologies.${tag}.cost_multiplier`] || 1;
76+
technologyCost *= tagCostMultiplier;
77+
}
78+
79+
// step 3: round the cost
80+
return Math.round(technologyCost);
81+
}
82+
83+
unlockTechnology(technologyId: string, empire: EmpireDocument) {
84+
const technology = TECHNOLOGIES[technologyId] ?? notFound(`Technology ${technologyId} not found.`);
85+
86+
if (empire.technologies.includes(technologyId)) {
87+
throw new BadRequestException(`Technology ${technologyId} has already been unlocked.`);
88+
}
89+
90+
// Check if all required technologies are unlocked
91+
const missingRequiredTechnologies = technology.requires?.filter(tech => !empire.technologies.includes(tech));
92+
if (missingRequiredTechnologies?.length) {
93+
throw new BadRequestException(`Required technologies for ${technologyId}: ${missingRequiredTechnologies.join(', ')}.`);
94+
}
95+
96+
empire.technologies.push(technologyId);
97+
98+
/* TODO: Increment the user's technology count by 1
99+
if (user.technologies) {
100+
user.technologies[technologyId] = (user.technologies?.[technologyId] ?? 0) + 1;
101+
user.markModified('technologies');
102+
} else {
103+
user.technologies = {[technologyId]: 1};
104+
}
105+
*/
106+
}
107+
108+
}

‎src/empire/empire.controller.ts

+3-1
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,8 @@ export class EmpireController {
5757
if (!currentUser._id.equals(empire.user)) {
5858
throw new ForbiddenException('Cannot modify another user\'s empire.');
5959
}
60-
return this.empireService.updateEmpire(empire, dto, null);
60+
this.empireService.updateEmpire(empire, dto);
61+
await this.empireService.saveAll([empire]); // emits update event
62+
return empire;
6163
}
6264
}

‎src/empire/empire.dto.ts

-6
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,6 @@ export class EmpireTemplate extends PickType(Empire, [
3737

3838
export class UpdateEmpireDto extends PartialType(PickType(Empire, [
3939
'resources',
40-
'technologies',
4140
'effects',
4241
'_private',
4342
'_public',
@@ -47,9 +46,4 @@ export class UpdateEmpireDto extends PartialType(PickType(Empire, [
4746
description: 'Update resources for market trades. The credits are automatically updated as well.',
4847
})
4948
resources?: Record<string, number>;
50-
51-
@ApiProperty({
52-
description: 'Unlock technologies. Only new technologies should be specified, not already unlocked ones.',
53-
})
54-
technologies?: string[];
5549
}

‎src/empire/empire.module.ts

+3-2
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@ import {Empire, EmpireSchema} from './empire.schema';
77
import {EmpireService} from './empire.service';
88
import {MemberModule} from '../member/member.module';
99
import {UserModule} from "../user/user.module";
10+
import {EmpireLogicService} from './empire-logic.service';
1011

1112
@Module({
1213
imports: [
@@ -19,8 +20,8 @@ import {UserModule} from "../user/user.module";
1920
UserModule,
2021
],
2122
controllers: [EmpireController],
22-
providers: [EmpireService, EmpireHandler],
23-
exports: [EmpireService],
23+
providers: [EmpireService, EmpireHandler, EmpireLogicService],
24+
exports: [EmpireService, EmpireLogicService],
2425
})
2526
export class EmpireModule {
2627
}

‎src/empire/empire.service.ts

+3-96
Original file line numberDiff line numberDiff line change
@@ -7,28 +7,14 @@ import {EmpireTemplate, ReadEmpireDto, UpdateEmpireDto} from './empire.dto';
77
import {MemberService} from '../member/member.service';
88
import {COLOR_PALETTE, EMPIRE_PREFIX_PALETTE, EMPIRE_SUFFIX_PALETTE, MIN_EMPIRES} from '../game-logic/constants';
99
import {generateTraits} from '../game-logic/traits';
10-
import {TECH_CATEGORIES, TECHNOLOGIES} from '../game-logic/technologies';
10+
import {TECH_CATEGORIES} from '../game-logic/technologies';
1111
import {UserService} from '../user/user.service';
1212
import {RESOURCE_NAMES, ResourceName, RESOURCES} from '../game-logic/resources';
1313
import {Technology, Variable} from '../game-logic/types';
1414
import {calculateVariable, calculateVariables, flatten, getVariables} from '../game-logic/variables';
1515
import {EMPIRE_VARIABLES} from '../game-logic/empire-variables';
16-
import {UserDocument} from '../user/user.schema';
1716
import {AggregateItem, AggregateResult} from '../game-logic/aggregates';
1817
import {Member} from '../member/member.schema';
19-
import {JobDocument} from "../job/job.schema";
20-
21-
function findMissingTechnologies(technologyId: string): string[] {
22-
const missingTechs: string[] = [];
23-
const technology = TECHNOLOGIES[technologyId];
24-
if (technology.requires) {
25-
for (const requiredTechnology of technology.requires) {
26-
missingTechs.push(requiredTechnology);
27-
missingTechs.push(...findMissingTechnologies(requiredTechnology));
28-
}
29-
}
30-
return missingTechs;
31-
}
3218

3319
@Injectable()
3420
@EventRepository()
@@ -60,91 +46,12 @@ export class EmpireService extends MongooseRepository<Empire> {
6046
return rest;
6147
}
6248

63-
async updateEmpire(empire: EmpireDocument, dto: UpdateEmpireDto, job: JobDocument | null): Promise<EmpireDocument> {
64-
const {technologies, resources, ...rest} = dto;
49+
updateEmpire(empire: EmpireDocument, dto: UpdateEmpireDto) {
50+
const {resources, ...rest} = dto;
6551
empire.set(rest);
66-
if (technologies) {
67-
await this.unlockTechnology(empire, technologies, job);
68-
}
6952
if (resources) {
7053
this.resourceTrading(empire, resources);
7154
}
72-
await this.saveAll([empire]); // emits update event
73-
return empire;
74-
}
75-
76-
async unlockTechnology(empire: EmpireDocument, technologies: string[], job: JobDocument | null) {
77-
const user = await this.userService.find(empire.user) ?? notFound(empire.user);
78-
for (const technologyId of technologies) {
79-
const technology = TECHNOLOGIES[technologyId] ?? notFound(`Technology ${technologyId} not found.`);
80-
81-
if (empire.technologies.includes(technologyId)) {
82-
throw new BadRequestException(`Technology ${technologyId} has already been unlocked.`);
83-
}
84-
85-
// Check if all required technologies are unlocked
86-
const hasAllRequiredTechnologies = !technology.requires || technology.requires.every(
87-
(requiredTechnology: string) => empire.technologies.includes(requiredTechnology)
88-
);
89-
90-
if (!hasAllRequiredTechnologies) {
91-
const missingTechnologies = findMissingTechnologies(technologyId);
92-
throw new BadRequestException(`Required technologies for ${technologyId}: ${missingTechnologies.join(', ')}.`);
93-
}
94-
95-
if (!job) {
96-
// Calculate the technology cost based on the formula
97-
const technologyCost = this.getTechnologyCost(user, empire, technology);
98-
99-
if (empire.resources.research < technologyCost) {
100-
throw new BadRequestException(`Not enough research points to unlock ${technologyId}.`);
101-
}
102-
103-
// Deduct research points and unlock technology
104-
empire.resources.research -= technologyCost;
105-
empire.markModified('resources');
106-
}
107-
108-
if (!empire.technologies.includes(technologyId)) {
109-
empire.technologies.push(technologyId);
110-
// Increment the user's technology count by 1
111-
if (user.technologies) {
112-
user.technologies[technologyId] = (user.technologies?.[technologyId] ?? 0) + 1;
113-
} else {
114-
user.technologies = {[technologyId]: 1};
115-
}
116-
user.markModified('technologies');
117-
}
118-
}
119-
await this.userService.saveAll([user]);
120-
}
121-
122-
public getTechnologyCost(user: UserDocument, empire: EmpireDocument, technology: Technology) {
123-
const variables = {
124-
...getVariables('technologies'),
125-
...getVariables('empire'),
126-
};
127-
calculateVariables(variables, empire);
128-
const technologyCount = user.technologies?.[technology.id] || 0;
129-
130-
const difficultyMultiplier = variables['empire.technologies.difficulty'] || 1;
131-
let technologyCost = technology.cost * difficultyMultiplier;
132-
133-
// step 1: if the user has already unlocked this tech, decrease the cost exponentially
134-
if (technologyCount) {
135-
const baseCostMultiplier = variables['empire.technologies.cost_multiplier'] || 1;
136-
const unlockCostMultiplier = baseCostMultiplier ** Math.min(technologyCount, 10);
137-
technologyCost *= unlockCostMultiplier;
138-
}
139-
140-
// step 2: apply tag multipliers
141-
for (const tag of technology.tags) {
142-
const tagCostMultiplier = variables[`technologies.${tag}.cost_multiplier`] || 1;
143-
technologyCost *= tagCostMultiplier;
144-
}
145-
146-
// step 3: round the cost
147-
return Math.round(technologyCost);
14855
}
14956

15057
async aggregateTechCost(empire: Empire, technology: Technology): Promise<AggregateResult> {

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

+9-65
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ import {SystemService} from '../system/system.service';
44
import {Empire, EmpireDocument} from '../empire/empire.schema';
55
import {System, SystemDocument} from '../system/system.schema';
66
import {calculateVariables, getInitialVariables} from './variables';
7-
import {Technology, TechnologyCategory, Variable} from './types';
7+
import {Technology, Variable} from './types';
88
import {RESOURCE_NAMES, ResourceName} from './resources';
99
import {AggregateItem, AggregateResult} from './aggregates';
1010
import {TECHNOLOGIES} from './technologies';
@@ -16,11 +16,13 @@ import {MemberService} from '../member/member.service';
1616
import {SYSTEM_UPGRADES} from './system-upgrade';
1717
import {JobService} from '../job/job.service';
1818
import {JobDocument} from '../job/job.schema';
19-
import {JobType} from '../job/job-type.enum';
19+
import {SystemLogicService} from '../system/system-logic.service';
2020

2121
@Injectable()
2222
export class GameLogicService {
2323
constructor(
24+
private systemLogicService: SystemLogicService,
25+
// TODO remove these services and try to have only pure logic in this service
2426
private memberService: MemberService,
2527
private empireService: EmpireService,
2628
private systemService: SystemService,
@@ -54,7 +56,7 @@ export class GameLogicService {
5456
if (member?.empire?.homeSystem) {
5557
homeSystem.type = member.empire.homeSystem;
5658
}
57-
this.systemService.generateDistricts(homeSystem, empire);
59+
this.systemLogicService.generateDistricts(homeSystem, empire);
5860

5961
// every home system starts with 15 districts
6062
this.generateDistricts(homeSystem);
@@ -102,79 +104,21 @@ export class GameLogicService {
102104
const empires = await this.empireService.findAll({game: game._id});
103105
const systems = await this.systemService.findAll({game: game._id});
104106
const jobs = await this.jobService.findAll({game: game._id});
105-
106-
this._updateGame(empires, systems);
107-
await this.updateJobs(jobs, empires, systems);
107+
this._updateGame(empires, systems, jobs);
108108
await this.empireService.saveAll(empires);
109109
await this.systemService.saveAll(systems);
110110
await this.jobService.saveAll(jobs);
111111
}
112112

113-
private _updateGame(empires: EmpireDocument[], systems: SystemDocument[]) {
113+
private _updateGame(empires: EmpireDocument[], systems: SystemDocument[], jobs: JobDocument[]) {
114114
for (const empire of empires) {
115115
const empireSystems = systems.filter(system => system.owner?.equals(empire._id));
116+
const empireJobs = jobs.filter(job => job.empire.equals(empire._id));
117+
this.jobService.updateJobs(empire, empireJobs, empireSystems);
116118
this.updateEmpire(empire, empireSystems);
117119
}
118120
}
119121

120-
async updateJobs(jobs: JobDocument[], empires: EmpireDocument[], systems: SystemDocument[]) {
121-
const systemJobsMap: Record<string, JobDocument[]> = {};
122-
const progressingTechnologyTags: Record<string, boolean> = {};
123-
124-
for (const job of jobs) {
125-
if (job.progress === job.total) {
126-
await this.jobService.delete(job._id);
127-
continue;
128-
}
129-
130-
if (job.type === JobType.TECHNOLOGY) {
131-
if (!job.technology) {
132-
continue;
133-
}
134-
const technology = TECHNOLOGIES[job.technology];
135-
if (technology) {
136-
const primaryTag = this.getPrimaryTag(technology);
137-
if (primaryTag && !progressingTechnologyTags[primaryTag]) {
138-
progressingTechnologyTags[primaryTag] = true;
139-
const empire = empires.find(e => e._id.equals(job.empire));
140-
empire && await this.progressJob(job, empire);
141-
}
142-
}
143-
} else {
144-
if (!job.system) {
145-
continue;
146-
}
147-
(systemJobsMap[job.system.toString()] ??= []).push(job);
148-
}
149-
}
150-
151-
for (const [systemId, jobsInSystem] of Object.entries(systemJobsMap)) {
152-
const system = systems.find(s => s._id.equals(systemId));
153-
// Maybe do a priority sorting in v4?
154-
const sortedJobs = jobsInSystem.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
155-
156-
for (const job of sortedJobs) {
157-
if (job.type === JobType.BUILDING || job.type === JobType.DISTRICT || job.type === JobType.UPGRADE) {
158-
const empire = empires.find(e => e._id.equals(job.empire));
159-
empire && await this.progressJob(job, empire, system);
160-
}
161-
}
162-
}
163-
}
164-
165-
private async progressJob(job: JobDocument, empire: EmpireDocument, system?: SystemDocument) {
166-
job.progress += 1;
167-
if (job.progress >= job.total) {
168-
await this.jobService.completeJob(job, empire, system);
169-
} else {
170-
job.markModified('progress');
171-
}
172-
}
173-
174-
private getPrimaryTag(technology: Technology): TechnologyCategory {
175-
return technology.tags[0];
176-
}
177-
178122
private updateEmpire(empire: EmpireDocument, systems: SystemDocument[], aggregates?: Partial<Record<ResourceName, AggregateResult>>) {
179123
const variables = getInitialVariables();
180124
calculateVariables(variables, empire);

0 commit comments

Comments
 (0)