@rpgjs/action-battle 5.0.0-alpha.44 → 5.0.0-beta.10

package/dist/client/index4.js

@@ -1,333 +1,108 @@
-import { defineModule, Control } from "@rpgjs/common";
-import { normalizeActionBattleOptions } from "./index8.js";
-import { manhattanDistance, parseAoeMask } from "./index9.js";
-const RpgEvent = null;
-const DEFAULT_KNOCKBACK = null;
-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 }
+import { normalizeActionBattleAttackProfile } from "./index3.js";
+//#region src/config.ts
+var DEFAULT_ACTION_BATTLE_OPTIONS = {
+	ui: {
+		actionBar: {
+			enabled: false,
+			autoOpen: false,
+			mode: "both"
+		},
+		targeting: {
+			enabled: true,
+			showGrid: true,
+			colors: {
+				area: 3120887,
+				edge: 1796760,
+				cursor: 16765286
+			}
+		}
+	},
+	skills: { defaultAoeMask: ["#"] },
+	targeting: {
+		affects: "events",
+		allowEmptyTarget: true
+	},
+	attack: {
+		lockMovement: true,
+		lockDurationMs: 350,
+		showPreview: true,
+		previewDurationMs: 180,
+		previewColor: 16774064,
+		previewAccentColor: 16777215
+	},
+	animations: {}
 };
-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 currentActionBattleOptions = DEFAULT_ACTION_BATTLE_OPTIONS;
+function normalizeActionBattleOptions(options = {}) {
+	const attack = {
+		...DEFAULT_ACTION_BATTLE_OPTIONS.attack,
+		...options.attack
+	};
+	const attackProfile = normalizeActionBattleAttackProfile(attack.profile, {
+		lockMovement: attack.lockMovement,
+		lockDurationMs: attack.lockDurationMs,
+		hitboxes: attack.hitboxes
+	});
+	return {
+		ui: {
+			actionBar: {
+				...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.actionBar,
+				...options.ui?.actionBar
+			},
+			targeting: {
+				...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting,
+				...options.ui?.targeting,
+				colors: {
+					...DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting?.colors,
+					...options.ui?.targeting?.colors
+				}
+			}
+		},
+		skills: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.skills,
+			...options.skills
+		},
+		targeting: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.targeting,
+			...options.targeting
+		},
+		debug: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.debug,
+			...options.debug
+		},
+		attack: {
+			...attack,
+			profile: attackProfile
+		},
+		animations: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.animations,
+			...options.animations
+		},
+		systems: {
+			combat: {
+				...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.combat,
+				...options.systems?.combat,
+				hooks: {
+					...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.combat?.hooks,
+					...options.systems?.combat?.hooks
+				}
+			},
+			ai: {
+				...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai,
+				...options.systems?.ai,
+				behaviors: {
+					...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai?.behaviors,
+					...options.systems?.ai?.behaviors
+				}
+			}
+		}
+	};
 }
-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 setActionBattleOptions(options) {
+	currentActionBattleOptions = options;
 }
-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 map = player.getCurrentMap();
-  if (!map) {
-    player.useSkill(skillId);
-    return;
-  }
-  const targeting = resolveSkillTargeting(player, skillId, options);
-  if (!targeting || !target) {
-    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;
-  }
-  player.useSkill(skillId, targets);
-};
-const createActionBattleServer = (rawOptions = {}) => {
-  const options = normalizeActionBattleOptions(rawOptions);
-  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) {
-          player.setGraphicAnimation("attack", 1);
-          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);
-      }
-    }
-  });
-};
-createActionBattleServer();
-export {
-  ACTION_BATTLE_ACTION_BAR_GUI_ID,
-  DEFAULT_PLAYER_ATTACK_HITBOXES,
-  applyPlayerHitToEvent,
-  createActionBattleServer,
-  getPlayerWeaponKnockbackForce,
-  openActionBattleActionBar,
-  updateActionBattleActionBar
-};
+function getActionBattleOptions() {
+	return currentActionBattleOptions;
+}
+//#endregion
+export { DEFAULT_ACTION_BATTLE_OPTIONS, getActionBattleOptions, normalizeActionBattleOptions, setActionBattleOptions };