SpaceNinjaServer/src/controllers/api/dronesController.ts

import { toMongoDate, toOid } from "@/src/helpers/inventoryHelpers";
import { addMiscItems, getInventory } from "@/src/services/inventoryService";
import { getAccountIdForRequest } from "@/src/services/loginService";
import { getRandomElement, getRandomInt } from "@/src/services/rngService";
import { IMongoDate, IOid } from "@/src/types/commonTypes";
import { IInventoryChanges } from "@/src/types/purchaseTypes";
import { RequestHandler } from "express";
import { ExportDrones, ExportResources, ExportSystems } from "warframe-public-export-plus";

export const dronesController: RequestHandler = async (req, res) => {
    const accountId = await getAccountIdForRequest(req);
    const inventory = await getInventory(accountId);
    if ("GetActive" in req.query) {
        const activeDrones: IActiveDrone[] = [];
        for (const drone of inventory.Drones) {
            if (drone.DeployTime) {
                activeDrones.push({
                    DeployTime: toMongoDate(drone.DeployTime),
                    System: drone.System!,
                    ItemId: toOid(drone._id),
                    ItemType: drone.ItemType,
                    CurrentHP: drone.CurrentHP,
                    DamageTime: drone.DamageTime ? toMongoDate(drone.DamageTime) : undefined,
                    PendingDamage: drone.PendingDamage,
                    Resources: [
                        {
                            ItemType: drone.ResourceType!,
                            BinTotal: drone.ResourceCount!,
                            StartTime: toMongoDate(drone.DeployTime)
                        }
                    ]
                });
            }
        }
        res.json({
            ActiveDrones: activeDrones
        });
    } else if ("droneId" in req.query && "systemIndex" in req.query) {
        const instantResourceDrones = true;
        const dronesAlwaysTakeDamage = true;
        const drone = inventory.Drones.id(req.query.droneId as string)!;
        const droneMeta = ExportDrones[drone.ItemType];
        drone.DeployTime = instantResourceDrones ? new Date(0) : new Date();
        if (drone.RepairStart) {
            const repairMinutes = (Date.now() - drone.RepairStart.getTime()) / 60_000;
            const hpPerMinute = droneMeta.repairRate / 60;
            drone.CurrentHP = Math.min(drone.CurrentHP + Math.round(repairMinutes * hpPerMinute), droneMeta.durability);
            drone.RepairStart = undefined;
        }
        drone.System = parseInt(req.query.systemIndex as string);
        const system = ExportSystems[drone.System - 1];
        if (dronesAlwaysTakeDamage || Math.random() < system.damageChance) {
            drone.DamageTime = instantResourceDrones
                ? new Date()
                : new Date(Date.now() + getRandomInt(3, 4) * 3600_000);
            drone.PendingDamage = getRandomInt(system.droneDamage.minValue, system.droneDamage.maxValue);
        }
        const resource = getRandomElement(system.resources);
        drone.ResourceType = "/Lotus/" + resource.StoreItem.substring(18);
        const resourceMeta = ExportResources[drone.ResourceType];
        if (resourceMeta.pickupQuantity) {
            const pickupsToCollect = droneMeta.binCapacity * droneMeta.capacityMultipliers[resource.Rarity];
            drone.ResourceCount = 0;
            for (let i = 0; i != pickupsToCollect; ++i) {
                drone.ResourceCount += getRandomInt(
                    resourceMeta.pickupQuantity.minValue,
                    resourceMeta.pickupQuantity.maxValue
                );
            }
        } else {
            drone.ResourceCount = 1;
        }
        await inventory.save();
        res.json({});
    } else if ("collectDroneId" in req.query) {
        const drone = inventory.Drones.id(req.query.collectDroneId as string)!;

        if (drone.DamageTime && new Date() >= drone.DamageTime) {
            drone.CurrentHP -= drone.PendingDamage!;
            drone.RepairStart = new Date();
        }

        const inventoryChanges: IInventoryChanges = {};
        if (drone.CurrentHP <= 0) {
            inventory.RegularCredits += 100;
            inventoryChanges.RegularCredits = 100;
            inventory.Drones.pull({ _id: req.query.collectDroneId as string });
            // TODO: Response format?
        } else {
            const completionTime = drone.DeployTime!.getTime() + ExportDrones[drone.ItemType].fillRate * 3600_000;
            if (Date.now() >= completionTime) {
                const miscItemChanges = [
                    {
                        ItemType: drone.ResourceType!,
                        ItemCount: drone.ResourceCount!
                    }
                ];
                addMiscItems(inventory, miscItemChanges);
                inventoryChanges.MiscItems = miscItemChanges;
            }

            drone.DeployTime = undefined;
            drone.System = undefined;
            drone.DamageTime = undefined;
            drone.PendingDamage = undefined;
            drone.ResourceType = undefined;
            drone.ResourceCount = undefined;
        }

        await inventory.save();
        res.json({
            // TODO: Let the client know the new HP of this drone... somehow
            InventoryChanges: inventoryChanges
        });
    } else {
        throw new Error(`drones.php query not handled`);
    }
};

interface IActiveDrone {
    DeployTime: IMongoDate;
    System: number;
    ItemId: IOid;
    ItemType: string;
    CurrentHP: number;
    DamageTime?: IMongoDate;
    PendingDamage?: number;
    Resources: {
        ItemType: string;
        BinTotal: number;
        StartTime: IMongoDate;
    }[];
}