Poc von einem Kampfsystem mit items

src/commands/fight.ts

@@ -0,0 +1,228 @@
+import type { ApplicationCommand } from "@/commands/command.js";
+import {
+    type APIEmbed,
+    APIEmbedField,
+    type BooleanCache,
+    type CacheType,
+    type CommandInteraction,
+    type InteractionResponse,
+    SlashCommandBuilder,
+    type User,
+} from "discord.js";
+import type { BotContext } from "@/context.js";
+import type { JSONEncodable } from "@discordjs/util";
+import {
+    type BaseEntity,
+    baseStats,
+    bossMap,
+    Entity,
+    type EquipableArmor,
+    type EquipableItem,
+    type EquipableWeapon,
+    type FightScene,
+} from "@/service/fightData.js";
+import { setTimeout } from "node:timers/promises";
+import { getFightInventoryEnriched, removeItemsAfterFight } from "@/storage/fightInventory.js";
+import { getLastFight, insertResult } from "@/storage/fightHistory.js";
+
+async function getFighter(user: User): Promise<BaseEntity> {
+    const userInventory = await getFightInventoryEnriched(user.id);
+
+    return {
+        ...baseStats,
+        name: user.displayName,
+        weapon: {
+            name: userInventory.weapon?.itemInfo?.displayName ?? "Nichts",
+            ...(userInventory.weapon?.gameTemplate as EquipableWeapon),
+        },
+        armor: {
+            name: userInventory.armor?.itemInfo?.displayName ?? "Nichts",
+            ...(userInventory.armor?.gameTemplate as EquipableArmor),
+        },
+        items: userInventory.items.map(value => {
+            return {
+                name: value.itemInfo?.displayName ?? "Error",
+                ...(value.gameTemplate as EquipableItem),
+            };
+        }),
+    };
+}
+
+export default class FightCommand implements ApplicationCommand {
+    readonly description = "TBD";
+    readonly name = "fight";
+    readonly applicationCommand = new SlashCommandBuilder()
+        .setName(this.name)
+        .setDescription(this.description)
+        .addStringOption(builder =>
+            builder
+                .setRequired(true)
+                .setName("boss")
+                .setDescription("Boss")
+                //switch to autocomplete when we reach 25
+                .addChoices(
+                    Object.entries(bossMap)
+                        .filter(boss => boss[1].enabled)
+                        .map(boss => {
+                            return {
+                                name: boss[1].name,
+                                value: boss[0],
+                            };
+                        }),
+                ),
+        );
+
+    async handleInteraction(command: CommandInteraction, context: BotContext) {
+        const boss = command.options.get("boss", true).value as string;
+
+        const lastFight = await getLastFight(command.user.id);
+
+        //   if (lastFight !== undefined && (new Date(lastFight?.createdAt).getTime() > new Date().getTime() - 1000 * 60 * 60 * 24 * 5)) {
+        //       await command.reply({
+        //               embeds:
+        //                   [{
+        //                       title: "Du bist noch nicht bereit",
+        //                       color: 0xe74c3c,
+        //                       description: `Dein Letzter Kampf gegen ${bossMap[lastFight.bossName]?.name} ist noch keine 5 Tage her. Gegen ${bossMap[boss].name} hast du sowieso Chance, aber noch weniger, wenn nicht die vorgeschriebenen Pausenzeiten einhältst `
+        //                   }
+        //                   ]
+        //               ,
+        //               ephemeral: true
+        //           }
+        //       );
+
+        //       return;
+        //   }
+
+        const interactionResponse = await command.deferReply();
+
+        const playerstats = await getFighter(command.user);
+
+        await fight(command.user, playerstats, boss, { ...bossMap[boss] }, interactionResponse);
+    }
+}
+
+type result = "PLAYER" | "ENEMY" | undefined;
+
+function checkWin(fightscene: FightScene): result {
+    if (fightscene.player.stats.health < 0) {
+        return "ENEMY";
+    }
+    if (fightscene.enemy.stats.health < 0) {
+        return "PLAYER";
+    }
+}
+
+function renderEndScreen(fightscene: FightScene): APIEmbed | JSONEncodable<APIEmbed> {
+    const result = checkWin(fightscene);
+    const fields = [
+        renderStats(fightscene.player),
+        renderStats(fightscene.enemy),
+        {
+            name: "Verlauf",
+            value: " ",
+        },
+        {
+            name: " Die Items sind dir leider beim Kampf kaputt gegangen: ",
+            value: fightscene.player.stats.items.map(value => value.name).join(" \n"),
+        },
+    ];
+    if (result === "PLAYER") {
+        return {
+            title: `Mit viel Glück konnte ${fightscene.player.stats.name} ${fightscene.enemy.stats.name} besiegen `,
+            color: 0x57f287,
+            description: fightscene.enemy.stats.description,
+            fields: fields,
+        };
+    }
+    if (result === "ENEMY") {
+        return {
+            title: `${fightscene.enemy.stats.name} hat ${fightscene.player.stats.name} gnadenlos vernichtet`,
+            color: 0xed4245,
+            description: fightscene.enemy.stats.description,
+            fields: fields,
+        };
+    }
+    return {
+        title: `Kampf zwischen ${fightscene.player.stats.name} und ${fightscene.enemy.stats.name}`,
+        description: fightscene.enemy.stats.description,
+        fields: fields,
+    };
+}
+
+export async function fight(
+    user: User,
+    playerstats: BaseEntity,
+    boss: string,
+    enemystats: BaseEntity,
+    interactionResponse: InteractionResponse<BooleanCache<CacheType>>,
+) {
+    const enemy = new Entity(enemystats);
+    const player = new Entity(playerstats);
+
+    const scene: FightScene = {
+        player: player,
+        enemy: enemy,
+    };
+    while (checkWin(scene) === undefined) {
+        player.itemText = [];
+        enemy.itemText = [];
+        //playerhit first
+        player.attack(enemy);
+        // then enemny hit
+        enemy.attack(player);
+        //special effects from items
+        for (const value of player.stats.items) {
+            if (!value.afterFight) {
+                continue;
+            }
+            value.afterFight(scene);
+        }
+        for (const value of enemy.stats.items) {
+            if (!value.afterFight) {
+                continue;
+            }
+            value.afterFight({ player: enemy, enemy: player });
+        }
+        await interactionResponse.edit({ embeds: [renderFightEmbedded(scene)] });
+        await setTimeout(200);
+    }
+
+    await interactionResponse.edit({ embeds: [renderEndScreen(scene)] });
+    //delete items
+    await removeItemsAfterFight(user.id);
+    //
+    await insertResult(user.id, boss, checkWin(scene) === "PLAYER");
+}
+
+function renderStats(player: Entity) {
+    while (player.itemText.length < 5) {
+        player.itemText.push("-");
+    }
+    return {
+        name: player.stats.name,
+        value: `❤️ HP${player.stats.health}/${player.maxHealth}
+            ❤️ ${"=".repeat(Math.max(0, (player.stats.health / player.maxHealth) * 10))}
+            ⚔️ Waffe: ${player.stats.weapon?.name ?? "Schwengel"} ${player.lastAttack}
+            🛡️ Rüstung: ${player.stats.armor?.name ?? "Nackt"} ${player.lastDefense}
+            📚 Items:
+            ${player.itemText.join("\n")}
+        `,
+        inline: true,
+    };
+}
+
+function renderFightEmbedded(fightscene: FightScene): JSONEncodable<APIEmbed> | APIEmbed {
+    return {
+        title: `Kampf zwischen ${fightscene.player.stats.name} und ${fightscene.enemy.stats.name}`,
+        description: fightscene.enemy.stats.description,
+        fields: [
+            renderStats(fightscene.player),
+            renderStats(fightscene.enemy),
+            {
+                name: "Verlauf",
+                value: " ",
+            },
+        ],
+    };
+}

src/commands/gegenstand.ts

@@ -24,6 +24,7 @@ import * as lootDataService from "@/service/lootData.js";
 import { LootAttributeClassId, LootAttributeKindId, LootKindId } from "@/service/lootData.js";
 
 import log from "@log";
+import { equipItembyLoot, getFightInventoryUnsorted } from "@/storage/fightInventory.js";
 
 export default class GegenstandCommand implements ApplicationCommand {
     name = "gegenstand";
@@ -60,6 +61,18 @@ export default class GegenstandCommand implements ApplicationCommand {
                         .setDescription("Die Sau, die du benutzen möchtest")
                         .setAutocomplete(true),
                 ),
+        )
+        .addSubcommand(
+            new SlashCommandSubcommandBuilder()
+                .setName("ausrüsten")
+                .setDescription("Rüste  einen gegenstand aus")
+                .addStringOption(
+                    new SlashCommandStringOption()
+                        .setRequired(true)
+                        .setName("item")
+                        .setDescription("Rüste dich für deinen nächsten Kampf")
+                        .setAutocomplete(true),
+                ),
         );
 
     async handleInteraction(interaction: CommandInteraction, context: BotContext) {
@@ -75,6 +88,9 @@ export default class GegenstandCommand implements ApplicationCommand {
             case "benutzen":
                 await this.#useItem(interaction, context);
                 break;
+            case "ausrüsten":
+                await this.#equipItem(interaction, context);
+                break;
             default:
                 throw new Error(`Unknown subcommand: "${subCommand}"`);
         }
@@ -309,7 +325,7 @@ export default class GegenstandCommand implements ApplicationCommand {
 
     async autocomplete(interaction: AutocompleteInteraction) {
         const subCommand = interaction.options.getSubcommand(true);
-        if (subCommand !== "info" && subCommand !== "benutzen") {
+        if (subCommand !== "info" && subCommand !== "benutzen" && subCommand !== "ausrüsten") {
             return;
         }
 
@@ -337,6 +353,9 @@ export default class GegenstandCommand implements ApplicationCommand {
             if (subCommand === "benutzen" && template.onUse === undefined) {
                 continue;
             }
+            if (subCommand === "ausrüsten" && template.gameEquip === undefined) {
+                continue;
+            }
 
             const emote = lootDataService.getEmote(interaction.guild, item);
             completions.push({
@@ -351,4 +370,41 @@ export default class GegenstandCommand implements ApplicationCommand {
 
         await interaction.respond(completions);
     }
+
+    async #equipItem(interaction: CommandInteraction, context: BotContext) {
+        if (!interaction.isChatInputCommand()) {
+            throw new Error("Interaction is not a chat input command");
+        }
+        if (!interaction.guild || !interaction.channel) {
+            return;
+        }
+
+        const info = await this.#fetchItem(interaction);
+        if (!info) {
+            return;
+        }
+        const { item, template } = info;
+        log.info(item);
+        if (template.gameEquip === undefined) {
+            await interaction.reply({
+                content: ` ${item.displayName}  kann nicht ausgerüstet werden.`,
+                ephemeral: true,
+            });
+            return;
+        }
+        const items = await getFightInventoryUnsorted(interaction.user.id);
+        if (items.filter(i => i.id === item.id).length !== 0) {
+            await interaction.reply({
+                content: `Du hast ${item.displayName} schon ausgerüstet`,
+                ephemeral: true,
+            });
+            return;
+        }
+        const result = await equipItembyLoot(interaction.user.id, item, template.gameEquip.type);
+        const message =
+            result.unequipped.length === 0
+                ? `Du hast ${result.equipped?.displayName} ausgerüstet`
+                : `Du hast ${result.unequipped.join(", ")} abgelegt und dafür ${result.equipped?.displayName} ausgerüstet`;
+        await interaction.reply(message);
+    }
 }