feat: implementar sistema de efectos de estado con persistencia en la base de datos

2025-10-09 01:01:12 -05:00
parent 2befd4a278
commit b5701df7ae
6 changed files with 381 additions and 207 deletions
--- a/src/game/combat/equipmentService.ts
+++ b/src/game/combat/equipmentService.ts
@@ -1,4 +1,8 @@
 import { prisma } from "../../core/database/prisma";
+import {
+  getActiveStatusEffects,
+  computeDerivedModifiers,
+} from "./statusEffectsService";
 import type { ItemProps } from "../economy/types";
 import { ensureUserAndGuildExist } from "../core/userService";

@@ -130,6 +134,24 @@ export async function getEffectiveStats(
  } catch {
    // silencioso: si falla stats no bloquea
  }
+  // Aplicar efectos de estado activos (FATIGUE etc.)
+  try {
+    const effects = await getActiveStatusEffects(userId, guildId);
+    if (effects.length) {
+      const { damageMultiplier, defenseMultiplier } = computeDerivedModifiers(
+        effects.map((e) => ({ type: e.type, magnitude: e.magnitude }))
+      );
+      damage = Math.max(0, Math.round(damage * damageMultiplier));
+      // defensa se recalcula localmente (no mutamos const original para claridad)
+      const adjustedDefense = Math.max(
+        0,
+        Math.round(defense * defenseMultiplier)
+      );
+      return { damage, defense: adjustedDefense, maxHp, hp };
+    }
+  } catch {
+    // silencioso
+  }
  return { damage, defense, maxHp, hp };
 }

--- a/src/game/combat/statusEffectsService.ts
+++ b/src/game/combat/statusEffectsService.ts
@@ -0,0 +1,77 @@
+import { prisma } from "../../core/database/prisma";
+
+export type StatusEffectType = "FATIGUE" | string;
+
+export interface StatusEffectOptions {
+  magnitude?: number; // porcentaje o valor genérico según tipo
+  durationMs?: number; // duración; si no se pasa => permanente
+  data?: Record<string, any>;
+}
+
+export async function applyStatusEffect(
+  userId: string,
+  guildId: string,
+  type: StatusEffectType,
+  opts?: StatusEffectOptions
+) {
+  const now = Date.now();
+  const expiresAt = opts?.durationMs ? new Date(now + opts.durationMs) : null;
+  return prisma.playerStatusEffect.upsert({
+    where: { userId_guildId_type: { userId, guildId, type } },
+    update: {
+      magnitude: opts?.magnitude ?? 0,
+      expiresAt,
+      data: opts?.data ?? {},
+    },
+    create: {
+      userId,
+      guildId,
+      type,
+      magnitude: opts?.magnitude ?? 0,
+      expiresAt,
+      data: opts?.data ?? {},
+    },
+  });
+}
+
+export async function getActiveStatusEffects(userId: string, guildId: string) {
+  // Limpieza perezosa de expirados
+  await prisma.playerStatusEffect.deleteMany({
+    where: { userId, guildId, expiresAt: { lt: new Date() } },
+  });
+  return prisma.playerStatusEffect.findMany({
+    where: { userId, guildId },
+  });
+}
+
+export function computeDerivedModifiers(
+  effects: { type: string; magnitude: number }[]
+) {
+  let damageMultiplier = 1;
+  let defenseMultiplier = 1;
+  for (const e of effects) {
+    switch (e.type) {
+      case "FATIGUE":
+        // Reducción lineal: magnitude = 0.15 => -15% daño y -10% defensa, configurable
+        damageMultiplier *= 1 - Math.min(0.9, e.magnitude); // cap 90% reducción
+        defenseMultiplier *= 1 - Math.min(0.9, e.magnitude * 0.66);
+        break;
+      default:
+        break; // otros efectos futuros
+    }
+  }
+  return { damageMultiplier, defenseMultiplier };
+}
+
+export async function applyDeathFatigue(
+  userId: string,
+  guildId: string,
+  magnitude = 0.15,
+  minutes = 5
+) {
+  return applyStatusEffect(userId, guildId, "FATIGUE", {
+    magnitude,
+    durationMs: minutes * 60 * 1000,
+    data: { reason: "death" },
+  });
+}
--- a/src/game/lib/rpgFormat.ts
+++ b/src/game/lib/rpgFormat.ts
@@ -82,12 +82,18 @@ export function combatSummaryRPG(c: {
  playerEndHp?: number | null;
  outcome?: "victory" | "defeat";
  maxRefHp?: number; // para cálculo visual si difiere
+  autoDefeatNoWeapon?: boolean;
 }) {
  const header = `**Combate (${outcomeLabel(c.outcome)})**`;
  const lines = [
    `• Mobs: ${c.mobs} | Derrotados: ${c.mobsDefeated}/${c.mobs}`,
    `• Daño hecho: ${c.totalDamageDealt} | Daño recibido: ${c.totalDamageTaken}`,
  ];
+  if (c.autoDefeatNoWeapon) {
+    lines.push(
+      `• Derrota automática: no tenías arma equipada o válida (daño 0). Equipa un arma para poder atacar.`
+    );
+  }
  if (c.playerStartHp != null && c.playerEndHp != null) {
    const maxHp = c.maxRefHp || Math.max(c.playerStartHp, c.playerEndHp);
    lines.push(
--- a/src/game/minigames/service.ts
+++ b/src/game/minigames/service.ts
@@ -387,130 +387,167 @@ export async function runMinigame(
    const eff = await getEffectiveStats(userId, guildId);
    const playerState = await ensurePlayerState(userId, guildId);
    const startHp = eff.hp; // HP actual persistente
-    let currentHp = startHp;
-    const mobLogs: CombatSummary["mobs"] = [];
-    let totalDealt = 0;
-    let totalTaken = 0;
-    let totalMobsDefeated = 0;
-    // Variación de ±20%
-    const variance = (base: number) => {
-      const factor = 0.8 + Math.random() * 0.4; // 0.8 - 1.2
-      return base * factor;
-    };
-    for (const mobKey of mobsSpawned) {
-      if (currentHp <= 0) break; // jugador derrotado antes de iniciar este mob
-      // Stats simples del mob (placeholder mejorable con tabla real)
-      const mobBaseHp = 10 + Math.floor(Math.random() * 6); // 10-15
-      let mobHp = mobBaseHp;
-      const rounds: any[] = [];
-      let round = 1;
-      let mobDamageDealt = 0; // daño que jugador hace a este mob
-      let mobDamageTakenFromMob = 0; // daño que jugador recibe de este mob
-      while (mobHp > 0 && currentHp > 0 && round <= 12) {
-        // Daño jugador -> mob
-        const playerRaw = variance(eff.damage || 1) + 1; // asegurar >=1
-        const playerDamage = Math.max(1, Math.round(playerRaw));
-        mobHp -= playerDamage;
-        mobDamageDealt += playerDamage;
-        totalDealt += playerDamage;
-        let playerTaken = 0;
-        if (mobHp > 0) {
-          const mobAtkBase = 3 + Math.random() * 4; // 3-7
-          const mobAtk = variance(mobAtkBase);
-          // Mitigación por defensa => defensa reduce linealmente hasta 60% cap
-          const mitigationRatio = Math.min(0.6, (eff.defense || 0) * 0.05); // 5% por punto defensa hasta 60%
-          const mitigated = mobAtk * (1 - mitigationRatio);
-          playerTaken = Math.max(0, Math.round(mitigated));
-          if (playerTaken > 0) {
-            currentHp = Math.max(0, currentHp - playerTaken);
-            mobDamageTakenFromMob += playerTaken;
-            totalTaken += playerTaken;
-          }
-        }
-        rounds.push({
-          mobKey,
-          round,
-          playerDamageDealt: playerDamage,
-          playerDamageTaken: playerTaken,
-          mobRemainingHp: Math.max(0, mobHp),
-          mobDefeated: mobHp <= 0,
-        });
-        if (mobHp <= 0) {
-          totalMobsDefeated++;
-          break;
-        }
-        if (currentHp <= 0) break;
-        round++;
-      }
-      mobLogs.push({
-        mobKey,
-        maxHp: mobBaseHp,
-        defeated: mobHp <= 0,
-        totalDamageDealt: mobDamageDealt,
-        totalDamageTakenFromMob: mobDamageTakenFromMob,
-        rounds,
-      });
-      if (currentHp <= 0) break; // fin combate global
-    }
-    const victory = currentHp > 0 && totalMobsDefeated === mobsSpawned.length;
-    // Persistir HP (si derrota -> regenerar al 50% del maxHp, regla confirmada por usuario)
-    let endHp = currentHp;
-    let defeatedNow = false;
-    if (currentHp <= 0) {
-      defeatedNow = true;
-      const regen = Math.max(1, Math.floor(eff.maxHp * 0.5));
-      endHp = regen;
-      await adjustHP(userId, guildId, regen - playerState.hp); // set a 50% (delta relativo)
-    } else {
-      // almacenar HP restante real
-      await adjustHP(userId, guildId, currentHp - playerState.hp);
-    }
-    // Actualizar estadísticas
-    const statUpdates: Record<string, number> = {};
-    if (area.key.startsWith("mine")) statUpdates.minesCompleted = 1;
-    if (area.key.startsWith("lagoon")) statUpdates.fishingCompleted = 1;
-    if (
-      area.key.startsWith("arena") ||
-      area.key.startsWith("battle") ||
-      area.key.includes("fight")
-    )
-      statUpdates.fightsCompleted = 1;
-    if (totalMobsDefeated > 0) statUpdates.mobsDefeated = totalMobsDefeated;
-    if (totalDealt > 0) statUpdates.damageDealt = totalDealt;
-    if (totalTaken > 0) statUpdates.damageTaken = totalTaken;
-    if (defeatedNow) statUpdates.timesDefeated = 1;
-    // Rachas de victoria
-    if (victory) {
-      statUpdates.currentWinStreak = 1; // increment
-    } else if (defeatedNow) {
-      // reset current streak
-      // No podemos hacer decrement directo, así que setearemos manual luego
-    }
-    await updateStats(userId, guildId, statUpdates as any);
-    if (defeatedNow) {
-      // reset de racha: update directo
+    // Regla: si el jugador no tiene arma (damage <=0) no puede infligir daño real y perderá automáticamente contra cualquier mob.
+    // En lugar de simular rondas irreales con daño mínimo artificial, forzamos derrota directa manteniendo coherencia.
+    if (!eff.damage || eff.damage <= 0) {
+      // Registrar derrota simple contra la lista de mobs (no se derrotan mobs).
+      const mobLogs: CombatSummary["mobs"] = mobsSpawned.map((mk) => ({
+        mobKey: mk,
+        maxHp: 0,
+        defeated: false,
+        totalDamageDealt: 0,
+        totalDamageTakenFromMob: 0,
+        rounds: [],
+      }));
+      // Aplicar daño simulado: mobs atacan una vez (opcional). Aquí asumimos que el jugador cae a 0 directamente para simplificar.
+      const endHp = Math.max(1, Math.floor(eff.maxHp * 0.5));
+      await adjustHP(userId, guildId, endHp - playerState.hp); // regen al 50%
+      await updateStats(userId, guildId, {
+        damageTaken: 0, // opcional: podría ponerse un valor fijo si quieres penalizar
+        timesDefeated: 1,
+      } as any);
+      // Reset de racha si existía
      await prisma.playerStats.update({
        where: { userId_guildId: { userId, guildId } },
        data: { currentWinStreak: 0 },
      });
-    } else if (victory) {
-      // posible actualización de longestWinStreak si superada ya la maneja updateStats parcialmente; reforzar
-      await prisma.$executeRawUnsafe(
-        `UPDATE "PlayerStats" SET "longestWinStreak" = GREATEST("longestWinStreak", "currentWinStreak") WHERE "userId" = $1 AND "guildId" = $2`,
-        userId,
-        guildId
-      );
+      combatSummary = {
+        mobs: mobLogs,
+        totalDamageDealt: 0,
+        totalDamageTaken: 0,
+        mobsDefeated: 0,
+        victory: false,
+        playerStartHp: startHp,
+        playerEndHp: endHp,
+        outcome: "defeat",
+        autoDefeatNoWeapon: true,
+      };
+    } else {
+      let currentHp = startHp;
+      const mobLogs: CombatSummary["mobs"] = [];
+      let totalDealt = 0;
+      let totalTaken = 0;
+      let totalMobsDefeated = 0;
+      // Variación de ±20%
+      const variance = (base: number) => {
+        const factor = 0.8 + Math.random() * 0.4; // 0.8 - 1.2
+        return base * factor;
+      };
+      for (const mobKey of mobsSpawned) {
+        if (currentHp <= 0) break; // jugador derrotado antes de iniciar este mob
+        // Stats simples del mob (placeholder mejorable con tabla real)
+        const mobBaseHp = 10 + Math.floor(Math.random() * 6); // 10-15
+        let mobHp = mobBaseHp;
+        const rounds: any[] = [];
+        let round = 1;
+        let mobDamageDealt = 0; // daño que jugador hace a este mob
+        let mobDamageTakenFromMob = 0; // daño que jugador recibe de este mob
+        while (mobHp > 0 && currentHp > 0 && round <= 12) {
+          // Daño jugador -> mob
+          const playerRaw = variance(eff.damage || 1) + 1; // asegurar >=1
+          const playerDamage = Math.max(1, Math.round(playerRaw));
+          mobHp -= playerDamage;
+          mobDamageDealt += playerDamage;
+          totalDealt += playerDamage;
+          let playerTaken = 0;
+          if (mobHp > 0) {
+            const mobAtkBase = 3 + Math.random() * 4; // 3-7
+            const mobAtk = variance(mobAtkBase);
+            // Mitigación por defensa => defensa reduce linealmente hasta 60% cap
+            const mitigationRatio = Math.min(0.6, (eff.defense || 0) * 0.05); // 5% por punto defensa hasta 60%
+            const mitigated = mobAtk * (1 - mitigationRatio);
+            playerTaken = Math.max(0, Math.round(mitigated));
+            if (playerTaken > 0) {
+              currentHp = Math.max(0, currentHp - playerTaken);
+              mobDamageTakenFromMob += playerTaken;
+              totalTaken += playerTaken;
+            }
+          }
+          rounds.push({
+            mobKey,
+            round,
+            playerDamageDealt: playerDamage,
+            playerDamageTaken: playerTaken,
+            mobRemainingHp: Math.max(0, mobHp),
+            mobDefeated: mobHp <= 0,
+          });
+          if (mobHp <= 0) {
+            totalMobsDefeated++;
+            break;
+          }
+          if (currentHp <= 0) break;
+          round++;
+        }
+        mobLogs.push({
+          mobKey,
+          maxHp: mobBaseHp,
+          defeated: mobHp <= 0,
+          totalDamageDealt: mobDamageDealt,
+          totalDamageTakenFromMob: mobDamageTakenFromMob,
+          rounds,
+        });
+        if (currentHp <= 0) break; // fin combate global
+      }
+      const victory = currentHp > 0 && totalMobsDefeated === mobsSpawned.length;
+      // Persistir HP (si derrota -> regenerar al 50% del maxHp, regla confirmada por usuario)
+      let endHp = currentHp;
+      let defeatedNow = false;
+      if (currentHp <= 0) {
+        defeatedNow = true;
+        const regen = Math.max(1, Math.floor(eff.maxHp * 0.5));
+        endHp = regen;
+        await adjustHP(userId, guildId, regen - playerState.hp); // set a 50% (delta relativo)
+      } else {
+        // almacenar HP restante real
+        await adjustHP(userId, guildId, currentHp - playerState.hp);
+      }
+      // Actualizar estadísticas
+      const statUpdates: Record<string, number> = {};
+      if (area.key.startsWith("mine")) statUpdates.minesCompleted = 1;
+      if (area.key.startsWith("lagoon")) statUpdates.fishingCompleted = 1;
+      if (
+        area.key.startsWith("arena") ||
+        area.key.startsWith("battle") ||
+        area.key.includes("fight")
+      )
+        statUpdates.fightsCompleted = 1;
+      if (totalMobsDefeated > 0) statUpdates.mobsDefeated = totalMobsDefeated;
+      if (totalDealt > 0) statUpdates.damageDealt = totalDealt;
+      if (totalTaken > 0) statUpdates.damageTaken = totalTaken;
+      if (defeatedNow) statUpdates.timesDefeated = 1;
+      // Rachas de victoria
+      if (victory) {
+        statUpdates.currentWinStreak = 1; // increment
+      } else if (defeatedNow) {
+        // reset current streak
+        // No podemos hacer decrement directo, así que setearemos manual luego
+      }
+      await updateStats(userId, guildId, statUpdates as any);
+      if (defeatedNow) {
+        // reset de racha: update directo
+        await prisma.playerStats.update({
+          where: { userId_guildId: { userId, guildId } },
+          data: { currentWinStreak: 0 },
+        });
+      } else if (victory) {
+        // posible actualización de longestWinStreak si superada ya la maneja updateStats parcialmente; reforzar
+        await prisma.$executeRawUnsafe(
+          `UPDATE "PlayerStats" SET "longestWinStreak" = GREATEST("longestWinStreak", "currentWinStreak") WHERE "userId" = $1 AND "guildId" = $2`,
+          userId,
+          guildId
+        );
+      }
+      combatSummary = {
+        mobs: mobLogs,
+        totalDamageDealt: totalDealt,
+        totalDamageTaken: totalTaken,
+        mobsDefeated: totalMobsDefeated,
+        victory,
+        playerStartHp: startHp,
+        playerEndHp: endHp,
+        outcome: victory ? "victory" : "defeat",
+      };
    }
-    combatSummary = {
-      mobs: mobLogs,
-      totalDamageDealt: totalDealt,
-      totalDamageTaken: totalTaken,
-      mobsDefeated: totalMobsDefeated,
-      victory,
-      playerStartHp: startHp,
-      playerEndHp: endHp,
-      outcome: victory ? "victory" : "defeat",
-    };
  }

  // Registrar la ejecución
--- a/src/game/minigames/types.ts
+++ b/src/game/minigames/types.ts
@@ -92,4 +92,5 @@ export type CombatSummary = {
  playerStartHp?: number;
  playerEndHp?: number;
  outcome?: "victory" | "defeat";
+  autoDefeatNoWeapon?: boolean; // true si la derrota fue inmediata por no tener arma (damage <= 0)
 };