Stable AI improvements

server/services/basicAi.ts

@@ -0,0 +1,61 @@
+import {Game} from "./types/Game";
+import {Player} from "./types/Player";
+import StarUpgradeService from "./starUpgrade";
+
+const FIRST_TICK_BULK_UPGRADE_SCI_PERCENTAGE = 20;
+const FIRST_TICK_BULK_UPGRADE_IND_PERCENTAGE = 30;
+const LAST_TICK_BULK_UPGRADE_ECO_PERCENTAGE = 100;
+
+export default class BasicAIService {
+    starUpgradeService: StarUpgradeService;
+
+    constructor(starUpgradeService: StarUpgradeService) {
+        this.starUpgradeService = starUpgradeService;
+    }
+
+    async _doBasicLogic(game: Game, player: Player, isFirstTickOfCycle: boolean, isLastTickOfCycle: boolean) {
+        if (isFirstTickOfCycle) {
+            await this._playFirstTick(game, player);
+        } else if (isLastTickOfCycle) {
+            await this._playLastTick(game, player);
+        }
+
+        // TODO: Not sure if this is an issue but there was an occassion during debugging
+        // where the player credits amount was less than 0, I assume its the AI spending too much somehow
+        // so adding this here just in case but need to investigate.
+        player.credits = Math.max(0, player.credits);
+    }
+
+    async _playFirstTick(game: Game, player: Player) {
+        if (!player.credits || player.credits < 0) {
+            return
+        }
+
+        // On the first tick after production:
+        // 1. Bulk upgrade X% of credits to ind and sci.
+        let creditsToSpendSci = Math.floor(player.credits / 100 * FIRST_TICK_BULK_UPGRADE_SCI_PERCENTAGE);
+        let creditsToSpendInd = Math.floor(player.credits / 100 * FIRST_TICK_BULK_UPGRADE_IND_PERCENTAGE);
+
+        if (creditsToSpendSci) {
+            await this.starUpgradeService.upgradeBulk(game, player, 'totalCredits', 'science', creditsToSpendSci, false);
+        }
+
+        if (creditsToSpendInd) {
+            await this.starUpgradeService.upgradeBulk(game, player, 'totalCredits', 'industry', creditsToSpendInd, false);
+        }
+    }
+
+    async _playLastTick(game: Game, player: Player) {
+        if (!player.credits || player.credits <= 0) {
+            return
+        }
+
+        // On the last tick of the cycle:
+        // 1. Spend remaining credits upgrading economy.
+        let creditsToSpendEco = Math.floor(player.credits / 100 * LAST_TICK_BULK_UPGRADE_ECO_PERCENTAGE);
+
+        if (creditsToSpendEco) {
+            await this.starUpgradeService.upgradeBulk(game, player, 'totalCredits', 'economy', creditsToSpendEco, false);
+        }
+    }
+}

server/services/gameTick.ts

@@ -198,6 +198,9 @@ export default class GameTickService extends EventEmitter {
 
             logTime(`Tick ${game.state.tick}`);
 
+            await this._playAI(game);
+            logTime('AI controlled players turn');
+
             await this._captureAbandonedStars(game, gameUsers);
             logTime('Capture abandoned stars');
 
@@ -222,9 +225,6 @@ export default class GameTickService extends EventEmitter {
 
             await this._gameLoseCheck(game, gameUsers);
             logTime('Game lose check');
-
-            await this._playAI(game);
-            logTime('AI controlled players turn');
 
             await this.researchService.conductResearchAll(game, gameUsers);
             logTime('Conduct research');

server/services/index.ts

@@ -1,5 +1,3 @@
-import UserLeaderboardService from "./userLeaderboard";
-
 const bcrypt = require('bcrypt');
 
 import GameModel from '../db/models/Game';
@@ -55,6 +53,7 @@ import SpecialStarBanService from './specialStarBan';
 import AchievementService from './achievement';
 import ConversationService from './conversation';
 import ReputationService from './reputation';
+import BasicAIService from "./basicAi";
 import AIService from './ai';
 import GuildService from './guild';
 import GuildUserService from './guildUser';
@@ -86,6 +85,7 @@ import NotificationService from './notification';
 import DiscordService from './discord';
 import ShipService from './ship';
 import SpectatorService from './spectator';
+import PathfindingService from "./pathfinding";
 
 import { DependencyContainer } from './types/DependencyContainer';
 
@@ -98,6 +98,7 @@ import { Guild } from './types/Guild';
 import { Payment } from './types/Payment';
 import { Report } from './types/Report';
 import TeamService from "./team";
+import UserLeaderboardService from './userLeaderboard';
 
 const gameNames = require('../config/game/gameNames');
 const starNames = require('../config/game/starNames');
@@ -183,7 +184,9 @@ export default (config): DependencyContainer => {
     const specialistHireService = new SpecialistHireService(gameRepository, specialistService, achievementService, waypointService, playerCreditsService, starService, gameTypeService, specialistBanService, technologyService);
     const starUpgradeService = new StarUpgradeService(gameRepository, starService, carrierService, achievementService, researchService, technologyService, playerCreditsService, gameTypeService, shipService);
     const shipTransferService = new ShipTransferService(gameRepository, carrierService, starService);
-    const aiService = new AIService(starUpgradeService, carrierService, starService, distanceService, waypointService, combatService, shipTransferService, technologyService, playerService, playerAfkService, reputationService, diplomacyService, playerStatisticsService, shipService);
+    const pathfindingService = new PathfindingService(distanceService, starService, waypointService);
+    const basicAIService = new BasicAIService(starUpgradeService);
+    const aiService = new AIService(starUpgradeService, carrierService, starService, distanceService, waypointService, combatService, shipTransferService, technologyService, playerService, playerAfkService, reputationService, diplomacyService, shipService, playerStatisticsService, basicAIService, pathfindingService);
     const historyService = new HistoryService(historyRepository, playerService, gameService, playerStatisticsService);
     const battleRoyaleService = new BattleRoyaleService(starService, carrierService, mapService, starDistanceService, waypointService, carrierMovementService);
     const starMovementService = new StarMovementService(mapService, starDistanceService, specialistService, waypointService);
@@ -251,6 +254,7 @@ export default (config): DependencyContainer => {
         achievementService,
         conversationService,
         reputationService,
+        basicAIService,
         aiService,
         battleRoyaleService,
         starMovementService,
@@ -274,5 +278,6 @@ export default (config): DependencyContainer => {
         shipService,
         spectatorService,
         teamService,
+        pathfindingService,
     };
 };

server/services/pathfinding.ts

@@ -0,0 +1,120 @@
+import {Game} from "./types/Game";
+import {Player} from "./types/Player";
+import {Carrier} from "./types/Carrier";
+import {DBObjectId} from "./types/DBObjectId";
+import DistanceService from "./distance";
+import StarService from "./star";
+import { Star } from "./types/Star";
+import WaypointService from "./waypoint";
+
+// Copied and adapted from WaypointHelper in the frontend
+// Should probably be put into a shared library at some point
+
+interface Node {
+    cost: number;
+    costFromStart: number;
+    neighbors: Node[] | null;
+    parent: Node | null;
+    star: Star;
+}
+
+export default class PathfindingService {
+    distanceService: DistanceService;
+    starService: StarService;
+    waypointService: WaypointService;
+
+    constructor(distanceService: DistanceService, starService: StarService, waypointService: WaypointService) {
+        this.distanceService = distanceService;
+        this.starService = starService;
+        this.waypointService = waypointService;
+    }
+
+    calculateShortestRoute(game: Game, player: Player, carrier: Carrier, sourceStarId: string, destinStarId: string): Node[] {
+        const hyperspaceDistance = this.distanceService.getHyperspaceDistance(game, player.research.hyperspace.level);
+
+        const graph: Node[] = game.galaxy.stars.map(star => {
+            return {
+                star,
+                cost: 0,
+                costFromStart: 0,
+                neighbors: null,
+                parent: null
+            }
+        })
+
+        const getNeighbors = (node: Node) => graph
+            .filter(s => s.star._id.toString() !== node.star._id.toString())
+            .filter(s => this.distanceService.getDistanceBetweenLocations(s.star.location, node.star.location) <= hyperspaceDistance || this.starService.isStarPairWormHole(s.star, node.star));
+
+        const start = graph.find(s => s.star._id.toString() === sourceStarId)!;
+        const end = graph.find(s => s.star._id.toString() === destinStarId)!;
+
+        const openSet: Node[] = [start]
+        const closedSet: Node[] = []
+
+        while (openSet.length) {
+            // This sort makes us look at the nodes where we can get the quickest first.
+            // This guarantees that all nodes that already have a calculated route (which may not be the quickest)
+            // will have their quickest route found. This in turn guarantees that the final fastest route can be found.
+
+            // Note from Tristanvds: Unfortunately we cannot also take into account a sorting system where we look at the
+            // distance to the end star. This kind of sorting system would favour going in a direct line towards that star
+            // instead of going for wormholes. Therefore we have to take a (computationally) slower approach by sorting
+            // based on the distance from the start.
+            openSet.sort((a, b) => a.costFromStart - b.costFromStart); // Ensure we start with the node that has the lowest total cost
+            const current = openSet.shift()!;
+
+            closedSet.push(current); // We're evaluating, so might as well close it.
+
+            // If we've found the end, return the reversed path.
+            if (current.star._id.toString() === end.star._id.toString()) {
+                let temp = current;
+
+                const path: Node[] = [];
+
+                path.push(temp);
+
+                while (temp.parent) {
+                    path.push(temp.parent);
+                    temp = temp.parent;
+                }
+
+                return path.reverse();
+            }
+
+            // Dynamically load neighbors as its more efficient
+            if (!current.neighbors) {
+                current.neighbors = getNeighbors(current);
+            }
+
+            for (const neighbor of current.neighbors) {
+                // If the neighbor has already been checked, then no need to check again.
+                const isClosed = closedSet.find(n => n.star._id.toString() === neighbor.star._id.toString()) != null;
+
+                if (!isClosed) {
+                    neighbor.cost = this.waypointService.calculateTicksForDistance(game, player, carrier, current.star, neighbor.star);
+
+                    // Calculate what the next cost will be, we don't want to check
+                    // any paths that lead us to more cost.
+                    const nextCost = current.costFromStart + neighbor.cost;
+
+                    // But if we haven't tried this path, enqueue it.
+                    const isOpen = openSet.find(n => n.star._id.toString() === neighbor.star._id.toString()) != null;
+
+                    if (!isOpen) {
+                        openSet.push(neighbor);
+                    } else if (nextCost >= neighbor.costFromStart) {
+                        continue;
+                    }
+
+                    // Calculate the final cost from the start to the end
+                    // while updating the path taken.
+                    neighbor.costFromStart = nextCost
+                    neighbor.parent = current
+                }
+            }
+        }
+
+        return []
+    }
+}

server/services/starDistance.ts

@@ -35,7 +35,7 @@ export default class StarDistanceService {
 
     getClosestStars(star: Star, stars: Star[], amount: number) {
         let sorted = stars
-            .filter(s => s._id !== star._id) // Exclude the current star.
+            .filter(s => s._id.toString() !== star._id.toString()) // Exclude the current star.
             .sort((a, b) => {
                 return this.getDistanceBetweenStars(star, a)
                     - this.getDistanceBetweenStars(star, b);
@@ -46,7 +46,7 @@ export default class StarDistanceService {
 
     getClosestUnownedStars(star: Star, stars: Star[], amount: number) {
         let sorted = stars
-            .filter(s => s._id !== star._id) // Exclude the current star.
+            .filter(s => s._id.toString() !== star._id.toString()) // Exclude the current star.
             .filter(s => !s.ownedByPlayerId)
             .sort((a, b) => {
                 return this.getDistanceBetweenStars(star, a)
@@ -62,7 +62,7 @@ export default class StarDistanceService {
 
     getClosestOwnedStars(star: Star, stars: Star[]) {
         return stars
-            .filter(s => s._id !== star._id) // Exclude the current star.
+            .filter(s => s._id.toString() !== star._id.toString()) // Exclude the current star.
             .filter(s => s.ownedByPlayerId)
             .sort((a, b) => {
                 return this.getDistanceBetweenStars(star, a)
@@ -110,7 +110,7 @@ export default class StarDistanceService {
 
     getStarsWithinRadiusOfStar(star: Star, stars: Star[], radius: number) {
         let nearby = stars
-            .filter(s => (s._id !== star._id) && (this.getDistanceBetweenStars(star, s) <= radius))
+            .filter(s => (s._id.toString() !== star._id.toString()) && (this.getDistanceBetweenStars(star, s) <= radius))
 
         return nearby;
     }

server/services/types/DependencyContainer.ts

@@ -68,6 +68,8 @@ import UserLevelService from "../userLevel";
 import SpecialStarBanService from "../specialStarBan";
 import ShipService from "../ship";
 import SpectatorService from "../spectator";
+import BasicAIService from "../basicAi";
+import PathfindingService from "../pathfinding";
 import UserLeaderboardService from "../userLeaderboard";
 import TeamService from "../team";
 
@@ -122,6 +124,7 @@ export interface DependencyContainer {
     conversationService: ConversationService,
     reputationService: ReputationService,
     aiService: AIService,
+    basicAIService: BasicAIService,
     battleRoyaleService: BattleRoyaleService,
     starMovementService: StarMovementService,
     cacheService: CacheService,
@@ -144,4 +147,5 @@ export interface DependencyContainer {
     shipService: ShipService,
     spectatorService: SpectatorService,
     teamService: TeamService,
+    pathfindingService: PathfindingService,
 };

server/services/waypoint.ts

@@ -342,6 +342,19 @@ export default class WaypointService {
         return distanceBetweenStars <= hyperspaceDistance
     }
 
+    calculateTicksForDistance(game: Game, player: Player, carrier: Carrier, sourceStar: Star, destinationStar: Star): number {
+        const distance = this.distanceService.getDistanceBetweenLocations(sourceStar.location, destinationStar.location);
+        const warpSpeed = this.carrierMovementService.canTravelAtWarpSpeed(game, player, carrier, sourceStar, destinationStar);
+
+        let tickDistance = this.carrierMovementService.getCarrierDistancePerTick(game, carrier, warpSpeed, false);
+
+        if (tickDistance) {
+            return Math.ceil(distance / tickDistance);
+        }
+
+        return 1;
+    }
+
     calculateWaypointTicks(game: Game, carrier: Carrier, waypoint: CarrierWaypoint) {
         const delayTicks = waypoint.delayTicks || 0;