@rpgjs/action-battle 5.0.0-beta.2 → 5.0.0-beta.4

package/dist/server/index2.js

@@ -1,347 +1,61 @@
-import { RpgEvent } from "@rpgjs/server";
-import { defineModule, Control } from "@rpgjs/common";
-import { DEFAULT_KNOCKBACK } from "./index3.js";
-import { normalizeActionBattleOptions, setActionBattleOptions } from "./index4.js";
-import { manhattanDistance, parseAoeMask } from "./index5.js";
-import { playActionBattleAnimation } from "./index6.js";
-const ACTION_BATTLE_ACTION_BAR_GUI_ID = "action-battle-action-bar";
-const DEFAULT_PLAYER_ATTACK_HITBOXES = {
-  up: { offsetX: -16, offsetY: -48, width: 32, height: 32 },
-  down: { offsetX: -16, offsetY: 16, width: 32, height: 32 },
-  left: { offsetX: -48, offsetY: -16, width: 32, height: 32 },
-  right: { offsetX: 16, offsetY: -16, width: 32, height: 32 },
-  default: { offsetX: 0, offsetY: -32, width: 32, height: 32 }
-};
-function getPlayerWeaponKnockbackForce(player) {
-  try {
-    const equipments = player.equipments?.() || [];
-    for (const item of equipments) {
-      const itemData = player.databaseById?.(item.id());
-      if (itemData?._type === "weapon" && itemData.knockbackForce !== void 0) {
-        return itemData.knockbackForce;
-      }
-    }
-  } catch {
-  }
-  return DEFAULT_KNOCKBACK.force;
+var DEFAULT_ANIMATION_BY_KEY = {
+	attack: "attack",
+	hurt: "hurt",
+	die: "die",
+	castSkill: "skill",
+	castSpell: "skill"
+};
+var getConfiguredAnimation = (key, animations) => {
+	if (!animations) return {
+		hasConfiguredAnimation: false,
+		configured: void 0
+	};
+	const hasConfiguredAnimation = Object.prototype.hasOwnProperty.call(animations, key);
+	if (hasConfiguredAnimation) return {
+		hasConfiguredAnimation,
+		configured: animations[key]
+	};
+	if (key === "castSkill") return {
+		hasConfiguredAnimation: Object.prototype.hasOwnProperty.call(animations, "castSpell"),
+		configured: animations.castSpell
+	};
+	return {
+		hasConfiguredAnimation: false,
+		configured: void 0
+	};
+};
+function resolveActionBattleAnimation(key, entity, animations, context, defaults = {}) {
+	const defaultAnimationName = defaults.animationName ?? DEFAULT_ANIMATION_BY_KEY[key];
+	const defaultRepeat = defaults.repeat ?? 1;
+	const { hasConfiguredAnimation, configured: configuredAnimation } = getConfiguredAnimation(key, animations);
+	if (!hasConfiguredAnimation && key !== "attack") return null;
+	const configured = hasConfiguredAnimation ? configuredAnimation : defaultAnimationName;
+	const result = typeof configured === "function" ? configured(entity, context) : configured;
+	if (result == null) return null;
+	if (typeof result === "string") return {
+		animationName: result,
+		repeat: defaultRepeat,
+		waitEnd: false
+	};
+	return {
+		animationName: result.animationName ?? defaultAnimationName,
+		graphic: result.graphic,
+		repeat: result.repeat ?? defaultRepeat,
+		waitEnd: result.waitEnd ?? false,
+		delayMs: result.delayMs
+	};
 }
-function applyPlayerHitToEvent(player, target, hooks) {
-  const ai = target.battleAi;
-  if (!ai) return void 0;
-  const knockbackForce = getPlayerWeaponKnockbackForce(player);
-  const defeated = ai.takeDamage(player);
-  const dx = target.x() - player.x();
-  const dy = target.y() - player.y();
-  const distance = Math.sqrt(dx * dx + dy * dy);
-  let hitResult = {
-    damage: 0,
-    // Will be set by takeDamage internally
-    knockbackForce,
-    knockbackDuration: DEFAULT_KNOCKBACK.duration,
-    defeated,
-    attacker: player,
-    target
-  };
-  if (hooks?.onBeforeHit) {
-    const modified = hooks.onBeforeHit(hitResult);
-    if (modified) {
-      hitResult = modified;
-    }
-  }
-  if (!hitResult.defeated && hitResult.knockbackForce > 0 && distance > 0) {
-    const knockbackDirection = {
-      x: dx / distance,
-      y: dy / distance
-    };
-    target.knockback(knockbackDirection, hitResult.knockbackForce, hitResult.knockbackDuration);
-  }
-  if (hooks?.onAfterHit) {
-    hooks.onAfterHit(hitResult);
-  }
-  return hitResult;
+function playActionBattleAnimation(key, entity, animations, context, defaults = {}) {
+	const animation = resolveActionBattleAnimation(key, entity, animations, context, defaults);
+	if (!animation) return null;
+	if (animation.graphic !== void 0) entity.setGraphicAnimation(animation.animationName, animation.graphic, animation.repeat);
+	else entity.setGraphicAnimation(animation.animationName, animation.repeat);
+	return animation;
 }
-const resolveSignal = (value) => typeof value === "function" ? value() : value;
-const resolveItemData = (player, itemId) => {
-  try {
-    return player.databaseById?.(itemId);
-  } catch {
-    return null;
-  }
-};
-const resolveSkillData = (player, skillId) => {
-  try {
-    return player.databaseById?.(skillId);
-  } catch {
-    return null;
-  }
-};
-const resolveSkillTargeting = (player, skillId, options) => {
-  const skillsOptions = options.skills;
-  const skillData = resolveSkillData(player, skillId);
-  if (skillsOptions?.getTargeting) {
-    return skillsOptions.getTargeting(skillData);
-  }
-  const range = skillData?.range ?? skillData?.targeting?.range ?? skillData?.targeting?.distance;
-  const aoeMask = skillData?.aoeMask ?? skillData?.targeting?.aoeMask ?? skillData?.targeting?.mask;
-  if (range === void 0 && aoeMask === void 0) {
-    return null;
-  }
-  return {
-    range: range ?? 0,
-    aoeMask
-  };
-};
-const normalizeMaskRows = (mask) => {
-  if (!mask) return [];
-  if (Array.isArray(mask)) return mask;
-  return mask.trim().split("\n").map((row) => row.replace(/\r/g, ""));
-};
-const buildActionBarData = (player, options) => {
-  const items = (player.items?.() || []).map((item) => {
-    const id = item.id?.() ?? item.id;
-    const data = resolveItemData(player, id);
-    const name = resolveSignal(data?.name) ?? resolveSignal(item.name) ?? id;
-    const description = resolveSignal(data?.description) ?? resolveSignal(item.description) ?? "";
-    const icon = resolveSignal(data?.icon) ?? resolveSignal(item.icon);
-    const quantity = resolveSignal(item.quantity) ?? 1;
-    const consumable = resolveSignal(data?.consumable);
-    const itemType = resolveSignal(data?._type);
-    const usable = quantity > 0 && consumable !== false && (itemType ? itemType === "item" : true);
-    return {
-      id,
-      name,
-      description,
-      icon,
-      quantity,
-      usable
-    };
-  });
-  const skills = (player.skills?.() || []).map((skill) => {
-    const id = skill.id?.() ?? skill.id;
-    const data = resolveSkillData(player, id) || skill;
-    const name = resolveSignal(data?.name) ?? resolveSignal(skill.name) ?? id;
-    const description = resolveSignal(data?.description) ?? resolveSignal(skill.description) ?? "";
-    const icon = resolveSignal(data?.icon) ?? resolveSignal(skill.icon);
-    const spCost = resolveSignal(data?.spCost) ?? resolveSignal(skill.spCost) ?? 0;
-    const usable = spCost <= player.sp;
-    const targeting = resolveSkillTargeting(player, id, options);
-    const skillEntry = {
-      id,
-      name,
-      description,
-      icon,
-      spCost,
-      usable,
-      range: targeting?.range ?? 0
-    };
-    if (targeting) {
-      const mask = targeting.aoeMask ?? options.skills?.defaultAoeMask;
-      if (mask) {
-        skillEntry.aoeMask = normalizeMaskRows(mask);
-      }
-    }
-    return skillEntry;
-  });
-  return { items, skills };
-};
-const ensureActionBarGui = (player, options) => {
-  const existing = player.getGui?.(ACTION_BATTLE_ACTION_BAR_GUI_ID);
-  const gui = existing || player.gui(ACTION_BATTLE_ACTION_BAR_GUI_ID);
-  if (!gui.__actionBattleReady) {
-    gui.__actionBattleReady = true;
-    gui.on("useItem", ({ id }) => {
-      try {
-        player.useItem(id);
-      } catch {
-      }
-      gui.update(buildActionBarData(player, options));
-    });
-    gui.on("useSkill", ({ id, target }) => {
-      handleActionBattleSkillUse(player, id, target, options);
-      gui.update(buildActionBarData(player, options));
-    });
-    gui.on("refresh", () => {
-      gui.update(buildActionBarData(player, options));
-    });
-  }
-  return gui;
-};
-const openActionBattleActionBar = (player, rawOptions = {}) => {
-  const options = normalizeActionBattleOptions(rawOptions);
-  const gui = ensureActionBarGui(player, options);
-  gui.open(buildActionBarData(player, options));
-};
-const updateActionBattleActionBar = (player, rawOptions = {}) => {
-  const options = normalizeActionBattleOptions(rawOptions);
-  const gui = player.getGui?.(ACTION_BATTLE_ACTION_BAR_GUI_ID);
-  if (gui) {
-    gui.update(buildActionBarData(player, options));
-  }
-};
-const getTileSize = (map) => ({
-  width: map?.tileWidth ?? 32,
-  height: map?.tileHeight ?? 32
-});
-const getEntityTile = (entity, tileSize) => {
-  const hitbox = entity.hitbox?.() || { w: tileSize.width, h: tileSize.height };
-  const x = Math.floor((entity.x() + hitbox.w / 2) / tileSize.width);
-  const y = Math.floor((entity.y() + hitbox.h / 2) / tileSize.height);
-  return { x, y };
-};
-const handleActionBattleSkillUse = (player, skillId, target, options) => {
-  const skillData = resolveSkillData(player, skillId);
-  const map = player.getCurrentMap();
-  if (!map) {
-    playActionBattleAnimation("castSkill", player, options.animations, {
-      skill: skillData
-    });
-    player.useSkill(skillId);
-    return;
-  }
-  const targeting = resolveSkillTargeting(player, skillId, options);
-  if (!targeting || !target) {
-    playActionBattleAnimation("castSkill", player, options.animations, {
-      skill: skillData
-    });
-    player.useSkill(skillId);
-    return;
-  }
-  const tileSize = getTileSize(map);
-  const origin = getEntityTile(player, tileSize);
-  const targetTile = { x: target.x, y: target.y };
-  if (manhattanDistance(origin, targetTile) > targeting.range) {
-    return;
-  }
-  const mask = parseAoeMask(
-    targeting.aoeMask || options.skills?.defaultAoeMask
-  );
-  const affected = /* @__PURE__ */ new Set();
-  mask.cells.forEach((cell) => {
-    const x = targetTile.x + cell.dx;
-    const y = targetTile.y + cell.dy;
-    affected.add(`${x},${y}`);
-  });
-  const targets = [];
-  const affects = options.targeting?.affects || "events";
-  if (affects === "events" || affects === "both") {
-    map.getEvents().forEach((event) => {
-      const tile = getEntityTile(event, tileSize);
-      if (affected.has(`${tile.x},${tile.y}`)) {
-        targets.push(event);
-      }
-    });
-  }
-  if (affects === "players" || affects === "both") {
-    map.getPlayers().forEach((other) => {
-      if (other.id === player.id) return;
-      const tile = getEntityTile(other, tileSize);
-      if (affected.has(`${tile.x},${tile.y}`)) {
-        targets.push(other);
-      }
-    });
-  }
-  if (!options.targeting?.allowEmptyTarget && targets.length === 0) {
-    return;
-  }
-  playActionBattleAnimation("castSkill", player, options.animations, {
-    skill: skillData,
-    target: targets[0]
-  });
-  player.useSkill(skillId, targets);
-};
-const createActionBattleServer = (rawOptions = {}) => {
-  const options = normalizeActionBattleOptions(rawOptions);
-  setActionBattleOptions(options);
-  return defineModule({
-    player: {
-      /**
-       * Handle player input for combat actions
-       *
-       * When a player presses the action key, create an attack hitbox
-       * that can damage AI enemies within range and knockback the event.
-       * Knockback force is based on the player's equipped weapon.
-       * Triggers attack animation and visual effects.
-       *
-       * @param player - The player performing the action
-       * @param input - Input data containing pressed keys
-       */
-      onInput(player, input) {
-        if (input.action == Control.Action) {
-          playActionBattleAnimation("attack", player, options.animations);
-          const playerX = player.x();
-          const playerY = player.y();
-          const direction = player.getDirection();
-          const directionKey = direction;
-          const hitboxConfig = DEFAULT_PLAYER_ATTACK_HITBOXES[directionKey] || DEFAULT_PLAYER_ATTACK_HITBOXES.default;
-          const hitboxes = [
-            {
-              x: playerX + hitboxConfig.offsetX,
-              y: playerY + hitboxConfig.offsetY,
-              width: hitboxConfig.width,
-              height: hitboxConfig.height
-            }
-          ];
-          const map = player.getCurrentMap();
-          map?.createMovingHitbox(hitboxes, { speed: 3 }).subscribe({
-            next(hits) {
-              hits.forEach((hit) => {
-                if (hit instanceof RpgEvent) {
-                  const result = applyPlayerHitToEvent(player, hit);
-                  if (result?.defeated) {
-                    console.log(`Player ${player.id} defeated AI ${hit.id}`);
-                  }
-                }
-              });
-            }
-          });
-        }
-      },
-      onConnected(player) {
-        if (options.ui?.actionBar?.enabled && options.ui?.actionBar?.autoOpen) {
-          openActionBattleActionBar(player, options);
-        }
-      }
-    },
-    event: {
-      /**
-       * Handle player detection when entering AI vision
-       *
-       * Called when a player enters an AI event's vision range.
-       * The AI will start pursuing and attacking the player.
-       *
-       * @param event - The AI event
-       * @param player - The player entering vision
-       * @param shape - The vision shape
-       */
-      onDetectInShape(event, player, shape) {
-        const ai = event.battleAi;
-        ai?.onDetectInShape(player, shape);
-      },
-      /**
-       * Handle player leaving AI vision
-       *
-       * Called when a player leaves an AI event's vision range.
-       * The AI will stop pursuing the player.
-       *
-       * @param event - The AI event
-       * @param player - The player leaving vision
-       * @param shape - The vision shape
-       */
-      onDetectOutShape(event, player, shape) {
-        const ai = event.battleAi;
-        ai?.onDetectOutShape(player, shape);
-      }
-    }
-  });
-};
-const server = createActionBattleServer();
-export {
-  ACTION_BATTLE_ACTION_BAR_GUI_ID,
-  DEFAULT_PLAYER_ATTACK_HITBOXES,
-  applyPlayerHitToEvent,
-  createActionBattleServer,
-  server as default,
-  getPlayerWeaponKnockbackForce,
-  openActionBattleActionBar,
-  updateActionBattleActionBar
-};
+function getActionBattleAnimationRemovalDelay(animation) {
+	if (!animation) return 0;
+	if (animation.delayMs !== void 0) return animation.delayMs;
+	return animation.waitEnd ? 500 : 0;
+}
+//#endregion
+export { getActionBattleAnimationRemovalDelay, playActionBattleAnimation };