import * as config from '../config';
import { BuildQueue, BuildQueueRepository } from './build-queue';
import { DateTime, Duration } from 'luxon';
-import { UnitTrainingQueue, UnitTrainingQueueRepository } from './training-queue';
+import { UnitTrainingQueue, UnitTrainingQueueRepository, UnitTrainingQueueWithName } from './training-queue';
import { coalesce, pluck } from '../lib/util';
import { Building, BuildingRepository } from './buildings';
import { Unit, UnitRepository } from './unit';
warehouses: number;
solar_panels: number;
accumulators: number;
+ mining_facilities: number;
+ ore_refinery: number;
barracks: number;
special_attacker_trainer: number;
special_defender_trainer: number;
icon: string;
+ max_construction_queue: number;
+ max_training_queue: number;
}
export type CityWithLocation = {
warehouses: 5,
solar_panels: 5,
accumulators: 5,
+ mining_facilities: 5,
+ ore_refinery: 5,
barracks: 0,
special_attacker_trainer: 0,
special_defender_trainer: 0,
+ max_construction_queue: 2,
+ max_training_queue: 2,
icon
};
return sample.sector_id;
}
- async save(city: City) {
+ async save(city: Partial<City>) {
+ if(!city.id) {
+ throw new Error('Unknown city to save');
+ }
const fieldsToSave = [
'totalSpace', 'usedSpace', 'credits', 'alloys', 'energy', 'food',
'poulation', 'soldiers', 'attackers', 'defenders', 'sp_attackers', 'sp_defenders',
throw new InsufficientResourceError('energy', building.energy, city.energy);
}
+ // validate that they have enough empty construction queues
+ const concurrentConstruction = await this.buildQueue.list(city.owner);
+ if(concurrentConstruction.length >= city.max_construction_queue) {
+ throw new InsufficientResourceError('Construction queues', concurrentConstruction.length + 1, city.max_construction_queue);
+ }
+
city.usedSpace += (building.land * amount);
city.credits -= (building.credits * amount);
city.alloys -= (building.alloys * amount);
throw new InsufficientResourceError('defenders', unit.defenders, city.defenders);
}
- // validate that they have enough of the buildings to support this
+ // validate that they have enough empty training queues
+ const concurrentTraining = await this.unitTrainigQueue.list(city.owner);
+ if(concurrentTraining.length >= city.max_training_queue) {
+ throw new InsufficientResourceError('Training queues', concurrentTraining.length + 1, city.max_training_queue);
+ }
// ok they have everything, lets update their city
// and create the entry in the training queue
city.credits -= unit.credits * amount;
city.food -= unit.food * amount;
- city.population -= coalesce(unit.population, 0) * amount;
- city.soldiers -= coalesce(unit.soldiers, 0) * amount;
- city.attackers -= coalesce(unit.attackers, 0) * amount;
- city.defenders -= coalesce(unit.defenders, 0) * amount;
+ city.population -= unit.population * amount;
+ city.soldiers -= unit.soldiers * amount;
+ city.attackers -= unit.attackers * amount;
+ city.defenders -= unit.defenders * amount;
+
+ console.log(city);
await this.save(city);
return city.accumulators * 150;
}
+ maxAlloy(city: City): number {
+ return city.ore_refinery * 75;
+ }
+
async foodProductionPerTick(city: City): Promise<number> {
// eventually we should supply the warehouse formula
// to calculate the max amount of food created per tick
- return _.max([
- city.population + _.round(city.farms * 50)
- ])
+ return city.farms * 50;
}
async foodUsagePerTick(city: City): Promise<number> {
async energyUsagePerTick(city: City): Promise<number> {
const buildings = await this.buildingRepository.list();
const buildingsMap = pluck<Building>(buildings, 'slug');
- const totalEnergy = _.sum([
- city.farms * buildingsMap['farms'].energy,
- city.barracks * buildingsMap['barracks'].energy,
- city.special_defender_trainer * buildingsMap['special_defender_trainer'].energy,
- city.special_attacker_trainer * buildingsMap['special_attacker_trainer'].energy,
- city.homes * buildingsMap['homes'].energy,
- city.warehouses * buildingsMap['warehouses'].energy,
- city.solar_panels * buildingsMap['solar_panels'].energy
- ]);
+ const totalEnergy = Math.ceil(_.sum([
+ city.farms * (buildingsMap['farms'].energy * 0.1),
+ city.barracks * (buildingsMap['barracks'].energy * 0.1),
+ city.special_defender_trainer * (buildingsMap['special_defender_trainer'].energy * 0.1),
+ city.special_attacker_trainer * (buildingsMap['special_attacker_trainer'].energy * 0.1),
+ city.homes * (buildingsMap['homes'].energy * 0.1),
+ city.warehouses * (buildingsMap['warehouses'].energy * 0.1),
+ city.solar_panels * (buildingsMap['solar_panels'].energy * 0.1),
+ city.mining_facilities * (buildingsMap['mining_facilities'].energy * 0.1),
+ city.ore_refinery * (buildingsMap['ore_refinery'].energy * 0.1)
+ ]));
return totalEnergy;
}
return this.buildQueue.list(owner);
}
- async getUnitTrainingQueues(owner: string): Promise<UnitTrainingQueue[]> {
+ async getUnitTrainingQueues(owner: string): Promise<UnitTrainingQueueWithName[]> {
return this.unitTrainigQueue.list(owner);
}
}