@rpgjs/action-battle 5.0.0-alpha.33 → 5.0.0-alpha.36

package/dist/client/index5.js

@@ -0,0 +1,292 @@
+import { useProps, useDefineProps, signal, computed, effect, h, DOMContainer, DOMElement, loop, cond, DOMSprite } from "canvasengine";
+import { inject, RpgClientEngine } from "@rpgjs/client";
+import { actionBattleUiOptions, actionBattleTargetingState, stopTargeting, moveTargetingOffset, startTargeting } from "./index7.js";
+if (typeof document !== "undefined" && !document.getElementById("ce-style--home-runner-work-RPG-JS-RPG-JS-packages-action-battle-src-components-action-bar-ce")) {
+  const styleElement = document.createElement("style");
+  styleElement.id = "ce-style--home-runner-work-RPG-JS-RPG-JS-packages-action-battle-src-components-action-bar-ce";
+  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  }";
+  document.head.appendChild(styleElement);
+}
+function component($$props) {
+  useProps($$props);
+  const defineProps = useDefineProps($$props);
+  var __assign = this && this.__assign || function() {
+    __assign = Object.assign || function(t) {
+      for (var s, i = 1, n = arguments.length; i < n; i++) {
+        s = arguments[i];
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+      }
+      return t;
+    };
+    return __assign.apply(this, arguments);
+  };
+  var engine = inject(RpgClientEngine);
+  var keyboardControls = engine.globalConfig.keyboardControls;
+  var _a = defineProps();
+  _a.data;
+  var onInteraction = _a.onInteraction, onBack = _a.onBack;
+  var currentPlayer = engine.getCurrentPlayer();
+  var ACTION_BAR_SIZE = 10;
+  var SLOT_LABELS = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"];
+  var SLOT_CONFIG_KEYS = [
+    "hotbar1",
+    "hotbar2",
+    "hotbar3",
+    "hotbar4",
+    "hotbar5",
+    "hotbar6",
+    "hotbar7",
+    "hotbar8",
+    "hotbar9",
+    "hotbar0"
+  ];
+  var selectedSlotIndex = signal(-1);
+  var uiOptions = computed(function() {
+    return actionBattleUiOptions();
+  });
+  var showItems = computed(function() {
+    var _a2;
+    var mode = ((_a2 = uiOptions().actionBar) === null || _a2 === void 0 ? void 0 : _a2.mode) || "both";
+    return mode === "items" || mode === "both";
+  });
+  var showSkills = computed(function() {
+    var _a2;
+    var mode = ((_a2 = uiOptions().actionBar) === null || _a2 === void 0 ? void 0 : _a2.mode) || "both";
+    return mode === "skills" || mode === "both";
+  });
+  var isTargeting = computed(function() {
+    return actionBattleTargetingState().active;
+  });
+  var iconSheet = function(iconId) {
+    return {
+      definition: engine.getSpriteSheet(iconId),
+      playing: "default"
+    };
+  };
+  var actionBarSlots = computed(function() {
+    var entries = [];
+    if (showSkills()) {
+      currentPlayer.skills().forEach(function(skill, index) {
+        entries.push({
+          type: "skill",
+          skill,
+          item: null,
+          sourceIndex: index
+        });
+      });
+    }
+    if (showItems()) {
+      currentPlayer.items().forEach(function(item, index) {
+        entries.push({
+          type: "item",
+          skill: null,
+          item,
+          sourceIndex: index
+        });
+      });
+    }
+    var slots = entries.slice(0, ACTION_BAR_SIZE).map(function(entry, index) {
+      return __assign(__assign({}, 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;
+  });
+  var hasSlotEntry = function(slot) {
+    return slot.type === "skill" || slot.type === "item";
+  };
+  var isSlotDisabled = function(slot) {
+    if (!hasSlotEntry(slot))
+      return true;
+    var entry = slot.type === "skill" ? slot.skill : slot.item;
+    return !entry || !entry.usable;
+  };
+  var getItemQuantity = function(item) {
+    if (!item)
+      return 0;
+    if (typeof item.quantity === "function")
+      return item.quantity();
+    return item.quantity || 0;
+  };
+  var selectItem = function(item) {
+    if (!item || !item.usable)
+      return;
+    if (onInteraction)
+      onInteraction("useItem", { id: item.id });
+  };
+  var selectSkill = function(skill) {
+    var _a2;
+    if (!skill || !skill.usable)
+      return;
+    var range = (_a2 = skill.range) !== null && _a2 !== void 0 ? _a2 : 0;
+    if (range > 0 || skill.aoeMask) {
+      startTargeting(skill);
+      return;
+    }
+    if (onInteraction)
+      onInteraction("useSkill", { id: skill.id });
+  };
+  var selectSlot = function(index) {
+    var slot = actionBarSlots()[index];
+    if (!slot || !hasSlotEntry(slot))
+      return;
+    if (slot.type === "skill") {
+      selectSkill(slot.skill);
+      return;
+    }
+    selectItem(slot.item);
+  };
+  var onSelectSlot = function(index) {
+    return function() {
+      selectedSlotIndex.set(index);
+      selectSlot(index);
+    };
+  };
+  var getPlayerTile = function() {
+    var _a2;
+    var player = engine.scene.getCurrentPlayer();
+    if (!player)
+      return null;
+    var hitbox = ((_a2 = player.hitbox) === null || _a2 === void 0 ? void 0 : _a2.call(player)) || { w: 32, h: 32 };
+    var tileWidth = hitbox.w || 32;
+    var tileHeight = hitbox.h || 32;
+    var x = Math.floor((player.x() + hitbox.w / 2) / tileWidth);
+    var y = Math.floor((player.y() + hitbox.h / 2) / tileHeight);
+    return { x, y };
+  };
+  var confirmTargeting = function() {
+    var state = actionBattleTargetingState();
+    if (!state.skill)
+      return;
+    var origin = getPlayerTile();
+    if (!origin)
+      return;
+    var target = {
+      x: origin.x + state.offset.x,
+      y: origin.y + state.offset.y
+    };
+    if (onInteraction) {
+      onInteraction("useSkill", {
+        id: state.skill.id,
+        target
+      });
+    }
+    stopTargeting();
+  };
+  var resolveKeyBind = function(key) {
+    if (!key)
+      return null;
+    if (typeof key === "string" && (keyboardControls === null || keyboardControls === void 0 ? void 0 : keyboardControls[key])) {
+      return keyboardControls[key];
+    }
+    return key;
+  };
+  var slotBind = function(index) {
+    return (keyboardControls === null || keyboardControls === void 0 ? void 0 : keyboardControls[SLOT_CONFIG_KEYS[index]]) || SLOT_LABELS[index];
+  };
+  var buildControls = function() {
+    var hotbarControls = {};
+    actionBarSlots().forEach(function(slot, index) {
+      var _a2;
+      if (!hasSlotEntry(slot))
+        return;
+      var bind = slotBind(index);
+      hotbarControls["slot-".concat(index)] = {
+        bind,
+        keyDown: function() {
+          if (isTargeting())
+            return;
+          selectedSlotIndex.set(index);
+          selectSlot(index);
+        }
+      };
+      if (slot.type === "skill") {
+        var skillBind = resolveKeyBind((_a2 = slot.skill) === null || _a2 === void 0 ? void 0 : _a2.key);
+        if (!skillBind || skillBind === bind)
+          return;
+        hotbarControls["skill-".concat(index)] = {
+          bind: skillBind,
+          keyDown: function() {
+            if (isTargeting())
+              return;
+            selectedSlotIndex.set(index);
+            selectSlot(index);
+          }
+        };
+      }
+    });
+    return __assign(__assign({ left: {
+      repeat: true,
+      bind: keyboardControls.left,
+      throttle: 150,
+      keyDown: function() {
+        if (isTargeting()) {
+          moveTargetingOffset(-1, 0);
+        }
+      }
+    }, right: {
+      repeat: true,
+      bind: keyboardControls.right,
+      throttle: 150,
+      keyDown: function() {
+        if (isTargeting()) {
+          moveTargetingOffset(1, 0);
+        }
+      }
+    }, up: {
+      repeat: true,
+      bind: keyboardControls.up,
+      throttle: 150,
+      keyDown: function() {
+        if (isTargeting()) {
+          moveTargetingOffset(0, -1);
+        }
+      }
+    }, down: {
+      repeat: true,
+      bind: keyboardControls.down,
+      throttle: 150,
+      keyDown: function() {
+        if (isTargeting()) {
+          moveTargetingOffset(0, 1);
+        }
+      }
+    }, action: {
+      bind: keyboardControls.action,
+      keyDown: function() {
+        if (isTargeting()) {
+          confirmTargeting();
+        }
+      }
+    }, escape: {
+      bind: keyboardControls.escape,
+      keyDown: function() {
+        if (isTargeting()) {
+          stopTargeting();
+          return;
+        }
+        if (onBack)
+          onBack();
+      }
+    } }, hotbarControls), { gamepad: {
+      enabled: true
+    } });
+  };
+  var controls = signal(buildControls());
+  effect(function() {
+    controls.set(buildControls());
+  });
+  let $this = 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) }))]))))));
+  return $this;
+}
+export {
+  component as default
+};

package/dist/client/index6.js

@@ -0,0 +1,97 @@
+import { useProps, useDefineProps, computed, h, Container, cond, Graphics } from "canvasengine";
+import { inject, RpgClientEngine } from "@rpgjs/client";
+import { actionBattleUiOptions, actionBattleTargetingState } from "./index7.js";
+import { parseAoeMask } from "./index9.js";
+function component($$props) {
+  useProps($$props);
+  const defineProps = useDefineProps($$props);
+  var object = defineProps().object;
+  var engine = inject(RpgClientEngine);
+  var isCurrentPlayer = computed(function() {
+    if (!(object === null || object === void 0 ? void 0 : object.id))
+      return false;
+    var idValue = typeof object.id === "function" ? object.id() : object.id;
+    return idValue === engine.playerId;
+  });
+  var uiOptions = computed(function() {
+    return actionBattleUiOptions();
+  });
+  var targetingState = computed(function() {
+    return actionBattleTargetingState();
+  });
+  var shouldRender = computed(function() {
+    var _a;
+    if (!isCurrentPlayer())
+      return false;
+    if (!((_a = uiOptions().targeting) === null || _a === void 0 ? void 0 : _a.enabled))
+      return false;
+    return targetingState().active;
+  });
+  var getTileSize = function() {
+    var _a, _b;
+    var uiTile = (_a = uiOptions().targeting) === null || _a === void 0 ? void 0 : _a.tileSize;
+    if ((uiTile === null || uiTile === void 0 ? void 0 : uiTile.width) && (uiTile === null || uiTile === void 0 ? void 0 : uiTile.height))
+      return uiTile;
+    var hitbox = ((_b = object.hitbox) === null || _b === void 0 ? void 0 : _b.call(object)) || { w: 32, h: 32 };
+    return { width: hitbox.w || 32, height: hitbox.h || 32 };
+  };
+  var getOriginTile = function() {
+    var _a;
+    var hitbox = ((_a = object.hitbox) === null || _a === void 0 ? void 0 : _a.call(object)) || { w: 32, h: 32 };
+    var tileSize = getTileSize();
+    var x = Math.floor((object.x() + hitbox.w / 2) / tileSize.width);
+    var y = Math.floor((object.y() + hitbox.h / 2) / tileSize.height);
+    return { x, y };
+  };
+  var toColor = function(value, fallback) {
+    if (typeof value === "number")
+      return value;
+    return fallback;
+  };
+  var drawGrid = function(g) {
+    var _a, _b;
+    var state = targetingState();
+    if (!state.active)
+      return;
+    var tileSize = getTileSize();
+    var origin = getOriginTile();
+    var target = {
+      x: origin.x + state.offset.x,
+      y: origin.y + state.offset.y
+    };
+    var mask = parseAoeMask(state.aoeMask);
+    var colors = ((_a = uiOptions().targeting) === null || _a === void 0 ? void 0 : _a.colors) || {};
+    var areaColor = toColor(colors.area, 3120887);
+    var edgeColor = toColor(colors.edge, 1796760);
+    var cursorColor = toColor(colors.cursor, 16765286);
+    var showGrid = ((_b = uiOptions().targeting) === null || _b === void 0 ? void 0 : _b.showGrid) !== false;
+    var playerX = object.x();
+    var playerY = object.y();
+    g.clear();
+    mask.cells.forEach(function(cell) {
+      var tileX = target.x + cell.dx;
+      var tileY = target.y + cell.dy;
+      var worldX = tileX * tileSize.width;
+      var worldY = tileY * tileSize.height;
+      var relX = worldX - playerX;
+      var relY = worldY - playerY;
+      g.rect(relX, relY, tileSize.width, tileSize.height);
+      g.fill({ color: areaColor, alpha: 0.35 });
+      if (showGrid) {
+        g.rect(relX, relY, tileSize.width, tileSize.height);
+        g.stroke({ color: edgeColor, alpha: 0.9, width: 1 });
+      }
+    });
+    var cursorWorldX = target.x * tileSize.width;
+    var cursorWorldY = target.y * tileSize.height;
+    var cursorRelX = cursorWorldX - playerX;
+    var cursorRelY = cursorWorldY - playerY;
+    g.rect(cursorRelX, cursorRelY, tileSize.width, tileSize.height);
+    g.stroke({ color: cursorColor, alpha: 1, width: 2 });
+  };
+  let $this = h(Container, null, cond(shouldRender, () => h(Graphics, { draw: drawGrid })));
+  return $this;
+}
+export {
+  component as default
+};

package/dist/client/index7.js

@@ -0,0 +1,61 @@
+import { signal } from "canvasengine";
+import { normalizeActionBattleOptions, DEFAULT_ACTION_BATTLE_OPTIONS } from "./index8.js";
+const defaultTargetingState = {
+  active: false,
+  skill: null,
+  range: 0,
+  offset: { x: 0, y: 0 },
+  aoeMask: DEFAULT_ACTION_BATTLE_OPTIONS.skills?.defaultAoeMask || ["#"]
+};
+const actionBattleUiOptions = signal(
+  normalizeActionBattleOptions({}).ui || {}
+);
+const actionBattleSkillOptions = signal(
+  normalizeActionBattleOptions({}).skills || {}
+);
+const actionBattleTargetingState = signal({
+  ...defaultTargetingState
+});
+const setActionBattleOptions = (options = {}) => {
+  const normalized = normalizeActionBattleOptions(options);
+  actionBattleUiOptions.set(normalized.ui || {});
+  actionBattleSkillOptions.set(normalized.skills || {});
+};
+const startTargeting = (skill) => {
+  const skillsOptions = actionBattleSkillOptions();
+  const mask = skill.aoeMask || skillsOptions.defaultAoeMask || ["#"];
+  actionBattleTargetingState.set({
+    active: true,
+    skill,
+    range: skill.range ?? 0,
+    offset: { x: 0, y: 0 },
+    aoeMask: mask
+  });
+};
+const stopTargeting = () => {
+  actionBattleTargetingState.set({ ...defaultTargetingState });
+};
+const moveTargetingOffset = (dx, dy) => {
+  const state = actionBattleTargetingState();
+  if (!state.active) return;
+  const next = {
+    x: state.offset.x + dx,
+    y: state.offset.y + dy
+  };
+  if (Math.abs(next.x) + Math.abs(next.y) > state.range) {
+    return;
+  }
+  actionBattleTargetingState.set({
+    ...state,
+    offset: next
+  });
+};
+export {
+  actionBattleSkillOptions,
+  actionBattleTargetingState,
+  actionBattleUiOptions,
+  moveTargetingOffset,
+  setActionBattleOptions,
+  startTargeting,
+  stopTargeting
+};

package/dist/client/index8.js

@@ -0,0 +1,55 @@
+const 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
+  }
+};
+function normalizeActionBattleOptions(options = {}) {
+  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
+    }
+  };
+}
+export {
+  DEFAULT_ACTION_BATTLE_OPTIONS,
+  normalizeActionBattleOptions
+};

package/dist/client/index9.js

@@ -0,0 +1,30 @@
+const normalizeMaskRows = (mask) => {
+  if (!mask) return ["#"];
+  if (Array.isArray(mask)) return mask;
+  return mask.trim().split("\n").map((row) => row.replace(/\r/g, ""));
+};
+const 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 });
+      }
+    }
+  });
+  if (cells.length === 0) {
+    cells.push({ dx: 0, dy: 0 });
+  }
+  return { width, height, centerX, centerY, cells };
+};
+const manhattanDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+export {
+  manhattanDistance,
+  parseAoeMask
+};

package/dist/client.d.ts

@@ -1,2 +1,4 @@
+import { ActionBattleOptions } from './types';
+export declare const createActionBattleClient: (options?: ActionBattleOptions) => any;
 declare const _default: any;
 export default _default;

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+import { ActionBattleOptions } from './types';
+export declare const DEFAULT_ACTION_BATTLE_OPTIONS: ActionBattleOptions;
+export declare function normalizeActionBattleOptions(options?: ActionBattleOptions): ActionBattleOptions;

package/dist/index.d.ts

@@ -1,4 +1,11 @@
+import { ActionBattleOptions } from './types';
 export { BattleAi, AiState, EnemyType, AttackPattern, AiDebug, DEFAULT_KNOCKBACK } from './ai.server';
 export type { HitResult, ApplyHitHooks } from './ai.server';
-export { DEFAULT_PLAYER_ATTACK_HITBOXES, getPlayerWeaponKnockbackForce, applyPlayerHitToEvent } from './server';
-export declare function provideActionBattle(): any;
+export type { ActionBattleOptions, ActionBattleActionBarData, ActionBattleActionBarItem, ActionBattleActionBarSkill, ActionBattleSkillTargeting, ActionBattleSkillTargetingResolver, ActionBattleUiOptions, ActionBattleUiActionBarOptions, ActionBattleUiTargetingOptions, } from './types';
+export { DEFAULT_PLAYER_ATTACK_HITBOXES, getPlayerWeaponKnockbackForce, applyPlayerHitToEvent, ACTION_BATTLE_ACTION_BAR_GUI_ID, openActionBattleActionBar, updateActionBattleActionBar, createActionBattleServer, } from './server';
+export declare function provideActionBattle(options?: ActionBattleOptions): any;
+declare const _default: {
+    server: any;
+    client: any;
+};
+export default _default;

package/dist/server/index.js

@@ -1,17 +1,23 @@
-import server from "./index2.js";
-import { DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, getPlayerWeaponKnockbackForce } from "./index2.js";
+import server, { createActionBattleServer } from "./index2.js";
+import { ACTION_BATTLE_ACTION_BAR_GUI_ID, DEFAULT_PLAYER_ATTACK_HITBOXES, applyPlayerHitToEvent, getPlayerWeaponKnockbackForce, openActionBattleActionBar, updateActionBattleActionBar } from "./index2.js";
 import { createModule } from "@rpgjs/common";
 import { AiDebug, AiState, AttackPattern, BattleAi, DEFAULT_KNOCKBACK, EnemyType } from "./index3.js";
 const client = null;
-function provideActionBattle() {
+const createActionBattleClient = null;
+function provideActionBattle(options = {}) {
   return createModule("ActionBattle", [
     {
-      server,
-      client
+      server: createActionBattleServer?.(options),
+      client: createActionBattleClient?.(options)
     }
   ]);
 }
+const index = {
+  server,
+  client
+};
 export {
+  ACTION_BATTLE_ACTION_BAR_GUI_ID,
   AiDebug,
   AiState,
   AttackPattern,
@@ -20,6 +26,10 @@ export {
   DEFAULT_PLAYER_ATTACK_HITBOXES,
   EnemyType,
   applyPlayerHitToEvent,
+  createActionBattleServer,
+  index as default,
   getPlayerWeaponKnockbackForce,
-  provideActionBattle
+  openActionBattleActionBar,
+  provideActionBattle,
+  updateActionBattleActionBar
 };