@rpgjs/action-battle 5.0.0-beta.11 → 5.0.0-beta.13

package/dist/client/index4.js

@@ -34,67 +34,108 @@ var DEFAULT_ACTION_BATTLE_OPTIONS = {
 };
 var currentActionBattleOptions = DEFAULT_ACTION_BATTLE_OPTIONS;
 function normalizeActionBattleOptions(options = {}) {
+	const combat = {
+		...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.combat,
+		...options.systems?.combat,
+		...options.combat,
+		hooks: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.combat?.hooks,
+			...options.systems?.combat?.hooks,
+			...options.combat?.hooks
+		}
+	};
 	const attack = {
 		...DEFAULT_ACTION_BATTLE_OPTIONS.attack,
-		...options.attack
+		...options.attack,
+		...combat.attack
 	};
 	const attackProfile = normalizeActionBattleAttackProfile(attack.profile, {
 		lockMovement: attack.lockMovement,
 		lockDurationMs: attack.lockDurationMs,
 		hitboxes: attack.hitboxes
 	});
+	const normalizedAttack = {
+		...attack,
+		profile: attackProfile
+	};
+	const skills = {
+		...DEFAULT_ACTION_BATTLE_OPTIONS.skills,
+		...options.skills
+	};
+	skills.targeting = skills.targeting ?? skills.getTargeting;
+	skills.getTargeting = skills.getTargeting ?? skills.targeting;
+	const defaultActionBar = DEFAULT_ACTION_BATTLE_OPTIONS.ui?.actionBar;
+	const defaultTargeting = DEFAULT_ACTION_BATTLE_OPTIONS.ui?.targeting;
+	const optionActionBar = options.ui?.actionBar;
+	const optionTargeting = options.ui?.targeting;
+	const optionAttackPreview = options.ui?.attackPreview;
+	const actionBar = options.ui?.actionBar === false ? {
+		...defaultActionBar,
+		enabled: false
+	} : {
+		...defaultActionBar,
+		...options.ui?.actionBar === true ? { enabled: true } : optionActionBar
+	};
+	const legacyPreviewEnabled = normalizedAttack.showPreview !== false;
+	const attackPreview = options.ui?.attackPreview === false ? { enabled: false } : {
+		enabled: options.ui?.attackPreview === true ? true : legacyPreviewEnabled,
+		...options.ui?.attackPreview === true ? {} : optionAttackPreview
+	};
+	const targeting = options.ui?.targeting === false ? {
+		...defaultTargeting,
+		enabled: false
+	} : {
+		...defaultTargeting,
+		...options.ui?.targeting === true ? { enabled: true } : optionTargeting,
+		colors: {
+			...defaultTargeting?.colors,
+			...typeof options.ui?.targeting === "object" ? optionTargeting?.colors : void 0
+		}
+	};
+	const ai = {
+		...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai,
+		...options.systems?.ai,
+		...options.ai,
+		behaviors: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai?.behaviors,
+			...options.systems?.ai?.behaviors,
+			...options.ai?.behaviors
+		},
+		presets: {
+			...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai?.presets,
+			...options.systems?.ai?.presets,
+			...options.ai?.presets
+		}
+	};
 	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
+			...options.ui,
+			actionBar,
+			targeting,
+			attackPreview
 		},
+		skills,
 		targeting: {
 			...DEFAULT_ACTION_BATTLE_OPTIONS.targeting,
 			...options.targeting
 		},
-		debug: {
-			...DEFAULT_ACTION_BATTLE_OPTIONS.debug,
-			...options.debug
-		},
-		attack: {
-			...attack,
-			profile: attackProfile
+		attack: normalizedAttack,
+		combat: {
+			...combat,
+			attack: normalizedAttack
 		},
+		ai,
+		visual: options.visual,
 		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
-				}
+				...combat,
+				attack: normalizedAttack
 			},
-			ai: {
-				...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai,
-				...options.systems?.ai,
-				behaviors: {
-					...DEFAULT_ACTION_BATTLE_OPTIONS.systems?.ai?.behaviors,
-					...options.systems?.ai?.behaviors
-				}
-			}
+			ai
 		}
 	};
 }

package/dist/client/index6.js

@@ -1,311 +1,70 @@
-import { actionBattleTargetingState, actionBattleUiOptions, moveTargetingOffset, startTargeting, stopTargeting } from "./index5.js";
-import { RpgClientEngine, getKeyboardControlBind, inject } from "@rpgjs/client";
-import { DOMContainer, DOMElement, DOMSprite, computed, cond, effect, h, loop, signal, useDefineProps, useProps } from "canvasengine";
-//#region src/components/action-bar.ce
-if (typeof document !== "undefined") {
-	let styleElement = document.getElementById("ce-style--home-runner-work-RPG-JS-RPG-JS-packages-action-battle-src-components-action-bar-ce");
-	if (!styleElement) {
-		styleElement = document.createElement("style");
-		styleElement.id = "ce-style--home-runner-work-RPG-JS-RPG-JS-packages-action-battle-src-components-action-bar-ce";
-		document.head.appendChild(styleElement);
+import { normalizeActionBattleAttackProfile } from "./index3.js";
+//#region src/core/attack-runtime.ts
+var ACTION_BATTLE_HITBOX_FRAME_MS = 16;
+function getNormalizedActionBattleAttackProfile(options = {}) {
+	const attack = options.attack ?? {};
+	return normalizeActionBattleAttackProfile(attack.profile, {
+		lockMovement: attack.lockMovement,
+		lockDurationMs: attack.lockDurationMs,
+		hitboxes: attack.hitboxes
+	});
+}
+function resolveActionBattleHitboxSpeed(profile, hitboxCount) {
+	const positions = Math.max(1, Math.floor(hitboxCount));
+	const activeFrames = Math.max(1, Math.ceil(profile.activeMs / 16));
+	return Math.max(1, Math.ceil(activeFrames / positions));
+}
+function scheduleActionBattleStartup(profile, callback, scheduler = setTimeout) {
+	if (profile.startupMs <= 0) {
+		callback();
+		return null;
 	}
-	styleElement.textContent = ".action-battle-actionbar-root {\n    pointer-events: none;\n  }\n\n  .action-battle-actionbar {\n    position: absolute;\n    left: 12px;\n    right: 12px;\n    bottom: 12px;\n    pointer-events: auto;\n    display: flex;\n    justify-content: center;\n  }\n\n  .action-battle-actionbar-plate {\n    width: min(760px, 100%);\n    --rpg-ui-hotbar-size: clamp(38px, 8vw, 52px);\n  }\n\n  .action-battle-actionbar-track {\n    --rpg-ui-hotbar-slots: 10;\n  }";
+	return scheduler(callback, profile.startupMs);
 }
-function component($$props) {
-	useProps($$props);
-	const defineProps = useDefineProps($$props);
-	const engine = inject(RpgClientEngine);
-	const keyboardControls = engine.globalConfig.keyboardControls;
-	const { data, onInteraction, onBack } = defineProps();
-	const ACTION_BAR_SIZE = 10;
-	const SLOT_LABELS = [
-		"1",
-		"2",
-		"3",
-		"4",
-		"5",
-		"6",
-		"7",
-		"8",
-		"9",
-		"0"
-	];
-	const SLOT_CONFIG_KEYS = [
-		"hotbar1",
-		"hotbar2",
-		"hotbar3",
-		"hotbar4",
-		"hotbar5",
-		"hotbar6",
-		"hotbar7",
-		"hotbar8",
-		"hotbar9",
-		"hotbar0"
-	];
-	const selectedSlotIndex = signal(-1);
-	const uiOptions = computed(() => actionBattleUiOptions());
-	const showItems = computed(() => {
-		const mode = uiOptions().actionBar?.mode || "both";
-		return mode === "items" || mode === "both";
-	});
-	const showSkills = computed(() => {
-		const mode = uiOptions().actionBar?.mode || "both";
-		return mode === "skills" || mode === "both";
-	});
-	const isTargeting = computed(() => actionBattleTargetingState().active);
-	const iconSheet = (iconId) => ({
-		definition: engine.getSpriteSheet(iconId),
-		playing: "default"
-	});
-	const resolveProp = (value) => typeof value === "function" ? value() : value;
-	const actionBarData = computed(() => resolveProp(data) || {
-		items: [],
-		skills: []
-	});
-	const actionBarSlots = computed(() => {
-		const entries = [];
-		if (showSkills()) (actionBarData().skills || []).forEach((skill, index) => {
-			entries.push({
-				type: "skill",
-				skill,
-				item: null,
-				sourceIndex: index
-			});
-		});
-		if (showItems()) (actionBarData().items || []).forEach((item, index) => {
-			entries.push({
-				type: "item",
-				skill: null,
-				item,
-				sourceIndex: index
-			});
-		});
-		const slots = entries.slice(0, ACTION_BAR_SIZE).map((entry, index) => ({
-			...entry,
-			label: SLOT_LABELS[index]
-		}));
-		while (slots.length < ACTION_BAR_SIZE) slots.push({
-			type: "empty",
-			skill: null,
-			item: null,
-			sourceIndex: -1,
-			label: SLOT_LABELS[slots.length]
-		});
-		return slots;
-	});
-	const hasSlotEntry = (slot) => slot.type === "skill" || slot.type === "item";
-	const isSlotDisabled = (slot) => {
-		if (!hasSlotEntry(slot)) return true;
-		const entry = slot.type === "skill" ? slot.skill : slot.item;
-		return !entry || !entry.usable;
-	};
-	const getItemQuantity = (item) => {
-		if (!item) return 0;
-		if (typeof item.quantity === "function") return item.quantity();
-		return item.quantity || 0;
-	};
-	const selectItem = (item) => {
-		if (!item || !item.usable) return;
-		if (onInteraction) onInteraction("useItem", { id: item.id });
-	};
-	const selectSkill = (skill) => {
-		if (!skill || !skill.usable) return;
-		if ((skill.range ?? 0) > 0 || skill.aoeMask) {
-			startTargeting(skill);
-			return;
-		}
-		if (onInteraction) onInteraction("useSkill", { id: skill.id });
-	};
-	const selectSlot = (index) => {
-		const slot = actionBarSlots()[index];
-		if (!slot || !hasSlotEntry(slot)) return;
-		if (slot.type === "skill") {
-			selectSkill(slot.skill);
-			return;
-		}
-		selectItem(slot.item);
+function runActionBattleActiveHitbox(profile, resolveHitboxes, onHitboxes, scheduler = setTimeout) {
+	const frames = Math.max(1, Math.ceil(profile.activeMs / 16));
+	let frame = 0;
+	const step = () => {
+		const hitboxes = resolveHitboxes();
+		if (hitboxes.length > 0) onHitboxes(hitboxes);
+		frame++;
+		if (frame < frames) scheduler(step, 16);
 	};
-	const onSelectSlot = (index) => () => {
-		selectedSlotIndex.set(index);
-		selectSlot(index);
-	};
-	const getPlayerTile = () => {
-		const player = engine.scene.getCurrentPlayer();
-		if (!player) return null;
-		const hitbox = player.hitbox?.() || {
-			w: 32,
-			h: 32
-		};
-		const tileWidth = hitbox.w || 32;
-		const tileHeight = hitbox.h || 32;
-		return {
-			x: Math.floor((player.x() + hitbox.w / 2) / tileWidth),
-			y: Math.floor((player.y() + hitbox.h / 2) / tileHeight)
-		};
-	};
-	const confirmTargeting = () => {
-		const state = actionBattleTargetingState();
-		if (!state.skill) return;
-		const origin = getPlayerTile();
-		if (!origin) return;
-		const target = {
-			x: origin.x + state.offset.x,
-			y: origin.y + state.offset.y
-		};
-		if (onInteraction) onInteraction("useSkill", {
-			id: state.skill.id,
-			target
-		});
-		stopTargeting();
-	};
-	const resolveKeyBind = (key) => {
-		if (!key) return null;
-		if (typeof key === "string" && keyboardControls?.[key]) return keyboardControls[key];
-		return key;
-	};
-	const slotBind = (index) => keyboardControls?.[SLOT_CONFIG_KEYS[index]] || SLOT_LABELS[index];
-	const buildControls = () => {
-		const hotbarControls = {};
-		actionBarSlots().forEach((slot, index) => {
-			if (!hasSlotEntry(slot)) return;
-			const bind = slotBind(index);
-			hotbarControls[`slot-${index}`] = {
-				bind,
-				keyDown() {
-					if (isTargeting()) return;
-					selectedSlotIndex.set(index);
-					selectSlot(index);
-				}
-			};
-			if (slot.type === "skill") {
-				const skillBind = resolveKeyBind(slot.skill?.key);
-				if (!skillBind || skillBind === bind) return;
-				hotbarControls[`skill-${index}`] = {
-					bind: skillBind,
-					keyDown() {
-						if (isTargeting()) return;
-						selectedSlotIndex.set(index);
-						selectSlot(index);
-					}
-				};
-			}
-		});
-		return {
-			left: {
-				repeat: true,
-				bind: keyboardControls.left,
-				throttle: 150,
-				keyDown() {
-					if (isTargeting()) moveTargetingOffset(-1, 0);
-				}
-			},
-			right: {
-				repeat: true,
-				bind: keyboardControls.right,
-				throttle: 150,
-				keyDown() {
-					if (isTargeting()) moveTargetingOffset(1, 0);
-				}
-			},
-			up: {
-				repeat: true,
-				bind: keyboardControls.up,
-				throttle: 150,
-				keyDown() {
-					if (isTargeting()) moveTargetingOffset(0, -1);
-				}
-			},
-			down: {
-				repeat: true,
-				bind: keyboardControls.down,
-				throttle: 150,
-				keyDown() {
-					if (isTargeting()) moveTargetingOffset(0, 1);
-				}
-			},
-			action: {
-				bind: getKeyboardControlBind(keyboardControls.action),
-				keyDown() {
-					if (isTargeting()) confirmTargeting();
-				}
-			},
-			escape: {
-				bind: keyboardControls.escape,
-				keyDown() {
-					if (isTargeting()) {
-						stopTargeting();
-						return;
-					}
-					if (onBack) onBack();
-				}
-			},
-			...hotbarControls,
-			gamepad: { enabled: true }
-		};
-	};
-	const controls = signal(buildControls());
-	effect(() => {
-		controls.set(buildControls());
-	});
-	return h(DOMContainer, {
-		width: "100%",
-		height: "100%",
-		attrs: { class: "action-battle-actionbar-root" },
-		controls
-	}, h(DOMElement, {
-		element: "div",
-		attrs: { class: "action-battle-actionbar" }
-	}, h(DOMElement, {
-		element: "div",
-		attrs: { class: "rpg-ui-hotbar action-battle-actionbar-plate" }
-	}, h(DOMElement, {
-		element: "div",
-		attrs: { class: "rpg-ui-hotbar-track action-battle-actionbar-track" }
-	}, loop(actionBarSlots, (slot, index) => h(DOMElement, {
-		element: "div",
-		attrs: {
-			class: "rpg-ui-hotbar-slot action-battle-actionbar-slot",
-			"data-selected": computed(() => selectedSlotIndex() === index ? "true" : "false"),
-			"data-disabled": computed(() => isSlotDisabled(slot) ? "true" : "false"),
-			"data-empty": computed(() => hasSlotEntry(slot) ? "false" : "true"),
-			"data-type": slot.type,
-			tabindex: computed(() => hasSlotEntry(slot) ? index : -1),
-			click: hasSlotEntry(slot) ? onSelectSlot(index) : void 0
-		}
-	}, [
-		h(DOMElement, {
-			element: "span",
-			attrs: { class: "rpg-ui-hotbar-key action-battle-actionbar-key" },
-			textContent: slot.label
-		}),
-		cond(computed(() => slot.type === "skill" && slot.skill?.icon), () => h(DOMSprite, {
-			sheet: computed(() => iconSheet(slot.skill.icon)),
-			width: "60px",
-			height: "60px",
-			scale: 2,
-			objectFit: "contain"
-		}), [computed(() => slot.type === "item" && slot.item?.icon), () => h(DOMSprite, {
-			sheet: computed(() => iconSheet(slot.item.icon)),
-			width: "60px",
-			height: "60px",
-			scale: 2,
-			objectFit: "contain"
-		})], [computed(() => slot.type === "skill" && slot.skill), () => h(DOMElement, {
-			element: "span",
-			attrs: { class: "rpg-ui-hotbar-text action-battle-actionbar-text" },
-			textContent: slot.skill.name
-		})], [computed(() => slot.type === "item" && slot.item), () => h(DOMElement, {
-			element: "span",
-			attrs: { class: "rpg-ui-hotbar-text action-battle-actionbar-text" },
-			textContent: slot.item.name
-		})]),
-		cond(computed(() => slot.type === "item" && slot.item), () => h(DOMElement, {
-			element: "span",
-			attrs: { class: "rpg-ui-hotbar-count action-battle-actionbar-count" },
-			textContent: "x" + getItemQuantity(slot.item)
-		}))
-	]))))));
+	if (profile.startupMs <= 0) {
+		step();
+		return null;
+	}
+	return scheduler(step, profile.startupMs);
+}
+var attackIdCounter = 0;
+function createActionBattleAttackId(attackerId, profileId) {
+	attackIdCounter++;
+	return `${attackerId ?? "unknown"}:${profileId}:${Date.now()}:${attackIdCounter}`;
 }
-var __ce_component = component;
+var getTargetKey = (target) => {
+	if (!target || target.id === void 0 || target.id === null) return null;
+	return String(target.id);
+};
+var ActionBattleHitTracker = class {
+	hitPolicy;
+	hitTargets = /* @__PURE__ */ new Set();
+	constructor(hitPolicy) {
+		this.hitPolicy = hitPolicy;
+	}
+	canHit(target) {
+		if (this.hitPolicy === "allowRepeatHits") return true;
+		const key = getTargetKey(target);
+		return !key || !this.hitTargets.has(key);
+	}
+	recordHit(target) {
+		const key = getTargetKey(target);
+		if (key) this.hitTargets.add(key);
+	}
+	tryHit(target) {
+		if (!this.canHit(target)) return false;
+		this.recordHit(target);
+		return true;
+	}
+};
 //#endregion
-export { __ce_component as default };
+export { ACTION_BATTLE_HITBOX_FRAME_MS, ActionBattleHitTracker, createActionBattleAttackId, getNormalizedActionBattleAttackProfile, resolveActionBattleHitboxSpeed, runActionBattleActiveHitbox, scheduleActionBattleStartup };

package/dist/client/index7.js

@@ -1,37 +1,37 @@
-//#region src/targeting.ts
-var normalizeMaskRows = (mask) => {
-	if (!mask) return ["#"];
-	if (Array.isArray(mask)) return mask;
-	return mask.trim().split("\n").map((row) => row.replace(/\r/g, ""));
+//#region src/attack-input.ts
+var ACTION_BATTLE_DIRECTIONS = new Set([
+	"up",
+	"down",
+	"left",
+	"right"
+]);
+var normalizeDirection = (value) => {
+	if (typeof value !== "string") return void 0;
+	return ACTION_BATTLE_DIRECTIONS.has(value) ? value : void 0;
 };
-var parseAoeMask = (mask) => {
-	const rows = normalizeMaskRows(mask);
-	const height = rows.length;
-	const width = rows.reduce((max, row) => Math.max(max, row.length), 0);
-	const centerX = Math.floor(width / 2);
-	const centerY = Math.floor(height / 2);
-	const cells = [];
-	rows.forEach((row, y) => {
-		for (let x = 0; x < row.length; x++) {
-			const char = row[x];
-			if (char && char !== "." && char !== " ") cells.push({
-				dx: x - centerX,
-				dy: y - centerY
-			});
+var resolveActionBattleAttackDirection = (entity, input) => {
+	const payloadDirection = normalizeDirection(input?.data?.direction) ?? normalizeDirection(input?.data?.attackDirection) ?? normalizeDirection(input?.direction);
+	if (payloadDirection) return payloadDirection;
+	if (typeof entity?.getDirection === "function") {
+		const direction = normalizeDirection(entity.getDirection());
+		if (direction) return direction;
+	}
+	if (typeof entity?.direction === "function") {
+		const direction = normalizeDirection(entity.direction());
+		if (direction) return direction;
+	}
+	return normalizeDirection(entity?.direction) ?? "down";
+};
+var applyActionBattleAttackDirection = (entity, direction) => {
+	if (typeof entity?.changeDirection === "function") {
+		const previousDirectionFixed = entity.directionFixed;
+		if (previousDirectionFixed === true) entity.directionFixed = false;
+		try {
+			entity.changeDirection(direction);
+		} finally {
+			if (previousDirectionFixed === true) entity.directionFixed = previousDirectionFixed;
 		}
-	});
-	if (cells.length === 0) cells.push({
-		dx: 0,
-		dy: 0
-	});
-	return {
-		width,
-		height,
-		centerX,
-		centerY,
-		cells
-	};
+	}
 };
-var manhattanDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
 //#endregion
-export { manhattanDistance, parseAoeMask };
+export { applyActionBattleAttackDirection, resolveActionBattleAttackDirection };