fleethub-core 0.3.3 → 0.4.3

package/bindings.d.ts

@@ -461,6 +461,8 @@ export interface FleetState {
   s7?: ShipState;
 }
 
+export type FleetType = "Main" | "Escort" | "RouteSup" | "BossSup";
+
 export interface AirSquadronState {
   id?: string;
   mode?: AirSquadronMode;
@@ -488,6 +490,8 @@ export interface OrgState {
   a3?: AirSquadronState;
   hq_level?: number;
   org_type?: OrgType;
+  route_sup?: string;
+  boss_sup?: string;
 }
 
 export type SpeedGroup = "A" | "B1" | "B2" | "C";
@@ -501,6 +505,21 @@ export interface BattleConfig {
   night_cutin: Array<NightCutinDef>;
 }
 
+export interface ShipMeta {
+  id: string;
+  ship_id: number;
+}
+
+export interface FleetMeta {
+  id: string;
+  len: number;
+  ships: Array<[string, ShipMeta | null]>;
+}
+
+export interface CompMeta {
+  fleets: Record<FleetType, FleetMeta>;
+}
+
 export interface MasterGear {
   gear_id: number;
   name: string;
@@ -620,7 +639,6 @@ export interface MasterData {
   gear_attrs: Array<MasterAttrRule>;
   ships: Array<MasterShip>;
   ship_attrs: Array<MasterAttrRule>;
-  ship_banners: Record<string, string>;
   equippable: MasterEquippable;
   ibonuses: MasterIBonuses;
   config: BattleConfig;

package/node/fh_core.d.ts

@@ -85,6 +85,65 @@ export class AirSquadron {
 }
 /**
 */
+export class Comp {
+  free(): void;
+/**
+* @returns {boolean}
+*/
+  is_combined(): boolean;
+/**
+* @returns {boolean}
+*/
+  is_enemy(): boolean;
+/**
+* @returns {bindings.CompMeta}
+*/
+  meta(): bindings.CompMeta;
+/**
+* @param {bindings.FleetType} ft
+* @returns {string | undefined}
+*/
+  get_fleet_id(ft: bindings.FleetType): string | undefined;
+/**
+* @param {bindings.FleetType} ft
+* @param {string} key
+* @returns {Ship | undefined}
+*/
+  get_ship_with_clone(ft: bindings.FleetType, key: string): Ship | undefined;
+/**
+* @param {bindings.FleetType} ft
+* @param {string} key
+* @returns {string | undefined}
+*/
+  get_ship_entity_id(ft: bindings.FleetType, key: string): string | undefined;
+/**
+* @param {string} id
+* @returns {Ship | undefined}
+*/
+  get_ship_by_eid_with_clone(id: string): Ship | undefined;
+/**
+* @returns {Fleet | undefined}
+*/
+  boss_sup?: Fleet;
+/**
+* @returns {Fleet | undefined}
+*/
+  escort?: Fleet;
+/**
+* @returns {Fleet}
+*/
+  main: Fleet;
+/**
+* @returns {bindings.OrgType}
+*/
+  org_type: bindings.OrgType;
+/**
+* @returns {Fleet | undefined}
+*/
+  route_sup?: Fleet;
+}
+/**
+*/
 export class FhCore {
   free(): void;
 /**
@@ -174,19 +233,23 @@ export class FhCore {
 */
   analyze_fleet_cutin(org: Org, key: string, engagement: bindings.Engagement): bindings.FleetCutinAnalysis;
 /**
-* @param {Fleet} player
-* @param {Org} enemy
+* @param {Comp} player
+* @param {Comp} enemy
 * @param {bindings.ShellingSupportSimulatorParams} params
 * @param {number} times
 * @returns {bindings.SimulatorResult}
 */
-  simulate_shelling_support(player: Fleet, enemy: Org, params: bindings.ShellingSupportSimulatorParams, times: number): bindings.SimulatorResult;
+  simulate_shelling_support(player: Comp, enemy: Comp, params: bindings.ShellingSupportSimulatorParams, times: number): bindings.SimulatorResult;
 }
 /**
 */
 export class Fleet {
   free(): void;
 /**
+* @returns {bindings.FleetMeta}
+*/
+  meta(): bindings.FleetMeta;
+/**
 * @returns {(string)[]}
 */
   ship_keys(): (string)[];
@@ -641,6 +704,11 @@ export class Org {
   get_fleet_id_by_role(role: bindings.Role): string;
 /**
 * @param {string} key
+* @returns {Comp}
+*/
+  create_comp_by_key(key: string): Comp;
+/**
+* @param {string} key
 * @returns {AirSquadron}
 */
   get_air_squadron(key: string): AirSquadron;
@@ -718,6 +786,10 @@ export class Org {
 */
   static default(): Org;
 /**
+* @returns {string}
+*/
+  boss_sup: string;
+/**
 * @returns {number}
 */
   readonly hq_level: number;
@@ -731,6 +803,10 @@ export class Org {
   readonly org_type: bindings.OrgType;
 /**
 * @returns {string}
+*/
+  route_sup: string;
+/**
+* @returns {string}
 */
   readonly xxh3: string;
 }
@@ -752,6 +828,10 @@ export class Ship {
 */
   state(): bindings.ShipState;
 /**
+* @returns {bindings.ShipMeta}
+*/
+  meta(): bindings.ShipMeta;
+/**
 * @returns {number}
 */
   remodel_rank(): number;

package/node/fh_core.js

@@ -36,18 +36,6 @@ function addHeapObject(obj) {
 
 function getObject(idx) { return heap[idx]; }
 
-function dropObject(idx) {
-    if (idx < 36) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
 let WASM_VECTOR_LEN = 0;
 
 let cachedTextEncoder = new TextEncoder('utf-8');
@@ -111,6 +99,18 @@ function getInt32Memory0() {
     return cachegetInt32Memory0;
 }
 
+function dropObject(idx) {
+    if (idx < 36) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -182,6 +182,10 @@ function _assertClass(instance, klass) {
     }
     return instance.ptr;
 }
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
 /**
 * @param {Gear} gear
 * @returns {boolean}
@@ -217,15 +221,6 @@ function getFloat64Memory0() {
     }
     return cachegetFloat64Memory0;
 }
-/**
-*/
-module.exports.set_panic_hook = function() {
-    wasm.set_panic_hook();
-};
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
 
 let cachegetUint16Memory0 = null;
 function getUint16Memory0() {
@@ -238,6 +233,12 @@ function getUint16Memory0() {
 function getArrayU16FromWasm0(ptr, len) {
     return getUint16Memory0().subarray(ptr / 2, ptr / 2 + len);
 }
+/**
+*/
+module.exports.set_panic_hook = function() {
+    wasm.set_panic_hook();
+};
+
 /**
 * @param {bindings.OrgType} org_type
 * @returns {boolean}
@@ -414,6 +415,203 @@ class AirSquadron {
 }
 module.exports.AirSquadron = AirSquadron;
 
+const CompFinalization = new FinalizationRegistry(ptr => wasm.__wbg_comp_free(ptr));
+/**
+*/
+class Comp {
+
+    static __wrap(ptr) {
+        const obj = Object.create(Comp.prototype);
+        obj.ptr = ptr;
+        CompFinalization.register(obj, obj.ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+        CompFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_comp_free(ptr);
+    }
+    /**
+    * @returns {bindings.OrgType}
+    */
+    get org_type() {
+        var ret = wasm.__wbg_get_comp_org_type(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @param {bindings.OrgType} arg0
+    */
+    set org_type(arg0) {
+        wasm.__wbg_set_comp_org_type(this.ptr, addHeapObject(arg0));
+    }
+    /**
+    * @returns {Fleet}
+    */
+    get main() {
+        var ret = wasm.__wbg_get_comp_main(this.ptr);
+        return Fleet.__wrap(ret);
+    }
+    /**
+    * @param {Fleet} arg0
+    */
+    set main(arg0) {
+        _assertClass(arg0, Fleet);
+        var ptr0 = arg0.ptr;
+        arg0.ptr = 0;
+        wasm.__wbg_set_comp_main(this.ptr, ptr0);
+    }
+    /**
+    * @returns {Fleet | undefined}
+    */
+    get escort() {
+        var ret = wasm.__wbg_get_comp_escort(this.ptr);
+        return ret === 0 ? undefined : Fleet.__wrap(ret);
+    }
+    /**
+    * @param {Fleet | undefined} arg0
+    */
+    set escort(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Fleet);
+            ptr0 = arg0.ptr;
+            arg0.ptr = 0;
+        }
+        wasm.__wbg_set_comp_escort(this.ptr, ptr0);
+    }
+    /**
+    * @returns {Fleet | undefined}
+    */
+    get route_sup() {
+        var ret = wasm.__wbg_get_comp_route_sup(this.ptr);
+        return ret === 0 ? undefined : Fleet.__wrap(ret);
+    }
+    /**
+    * @param {Fleet | undefined} arg0
+    */
+    set route_sup(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Fleet);
+            ptr0 = arg0.ptr;
+            arg0.ptr = 0;
+        }
+        wasm.__wbg_set_comp_route_sup(this.ptr, ptr0);
+    }
+    /**
+    * @returns {Fleet | undefined}
+    */
+    get boss_sup() {
+        var ret = wasm.__wbg_get_comp_boss_sup(this.ptr);
+        return ret === 0 ? undefined : Fleet.__wrap(ret);
+    }
+    /**
+    * @param {Fleet | undefined} arg0
+    */
+    set boss_sup(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Fleet);
+            ptr0 = arg0.ptr;
+            arg0.ptr = 0;
+        }
+        wasm.__wbg_set_comp_boss_sup(this.ptr, ptr0);
+    }
+    /**
+    * @returns {boolean}
+    */
+    is_combined() {
+        var ret = wasm.comp_is_combined(this.ptr);
+        return ret !== 0;
+    }
+    /**
+    * @returns {boolean}
+    */
+    is_enemy() {
+        var ret = wasm.comp_is_enemy(this.ptr);
+        return ret !== 0;
+    }
+    /**
+    * @returns {bindings.CompMeta}
+    */
+    meta() {
+        var ret = wasm.comp_meta(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @param {bindings.FleetType} ft
+    * @returns {string | undefined}
+    */
+    get_fleet_id(ft) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.comp_get_fleet_id(retptr, this.ptr, addHeapObject(ft));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            let v0;
+            if (r0 !== 0) {
+                v0 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_free(r0, r1 * 1);
+            }
+            return v0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {bindings.FleetType} ft
+    * @param {string} key
+    * @returns {Ship | undefined}
+    */
+    get_ship_with_clone(ft, key) {
+        var ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ret = wasm.comp_get_ship_with_clone(this.ptr, addHeapObject(ft), ptr0, len0);
+        return ret === 0 ? undefined : Ship.__wrap(ret);
+    }
+    /**
+    * @param {bindings.FleetType} ft
+    * @param {string} key
+    * @returns {string | undefined}
+    */
+    get_ship_entity_id(ft, key) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            var ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.comp_get_ship_entity_id(retptr, this.ptr, addHeapObject(ft), ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_free(r0, r1 * 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {string} id
+    * @returns {Ship | undefined}
+    */
+    get_ship_by_eid_with_clone(id) {
+        var ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ret = wasm.comp_get_ship_by_eid_with_clone(this.ptr, ptr0, len0);
+        return ret === 0 ? undefined : Ship.__wrap(ret);
+    }
+}
+module.exports.Comp = Comp;
+
 const FhCoreFinalization = new FinalizationRegistry(ptr => wasm.__wbg_fhcore_free(ptr));
 /**
 */
@@ -595,15 +793,15 @@ class FhCore {
         return takeObject(ret);
     }
     /**
-    * @param {Fleet} player
-    * @param {Org} enemy
+    * @param {Comp} player
+    * @param {Comp} enemy
     * @param {bindings.ShellingSupportSimulatorParams} params
     * @param {number} times
     * @returns {bindings.SimulatorResult}
     */
     simulate_shelling_support(player, enemy, params, times) {
-        _assertClass(player, Fleet);
-        _assertClass(enemy, Org);
+        _assertClass(player, Comp);
+        _assertClass(enemy, Comp);
         var ret = wasm.fhcore_simulate_shelling_support(this.ptr, player.ptr, enemy.ptr, addHeapObject(params), times);
         return takeObject(ret);
     }
@@ -679,6 +877,13 @@ class Fleet {
         }
     }
     /**
+    * @returns {bindings.FleetMeta}
+    */
+    meta() {
+        var ret = wasm.fleet_meta(this.ptr);
+        return takeObject(ret);
+    }
+    /**
     * @returns {(string)[]}
     */
     ship_keys() {
@@ -1630,6 +1835,52 @@ class Org {
     /**
     * @returns {string}
     */
+    get route_sup() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_org_route_sup(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(r0, r1);
+        }
+    }
+    /**
+    * @param {string} arg0
+    */
+    set route_sup(arg0) {
+        var ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_org_route_sup(this.ptr, ptr0, len0);
+    }
+    /**
+    * @returns {string}
+    */
+    get boss_sup() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_org_boss_sup(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(r0, r1);
+        }
+    }
+    /**
+    * @param {string} arg0
+    */
+    set boss_sup(arg0) {
+        var ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_org_boss_sup(this.ptr, ptr0, len0);
+    }
+    /**
+    * @returns {string}
+    */
     get xxh3() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
@@ -1822,6 +2073,16 @@ class Org {
     }
     /**
     * @param {string} key
+    * @returns {Comp}
+    */
+    create_comp_by_key(key) {
+        var ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        var ret = wasm.org_create_comp_by_key(this.ptr, ptr0, len0);
+        return Comp.__wrap(ret);
+    }
+    /**
+    * @param {string} key
     * @returns {AirSquadron}
     */
     get_air_squadron(key) {
@@ -2226,6 +2487,13 @@ class Ship {
         return takeObject(ret);
     }
     /**
+    * @returns {bindings.ShipMeta}
+    */
+    meta() {
+        var ret = wasm.ship_meta(this.ptr);
+        return takeObject(ret);
+    }
+    /**
     * @returns {string}
     */
     get name() {
@@ -2722,15 +2990,11 @@ class Ship {
 }
 module.exports.Ship = Ship;
 
-module.exports.__wbindgen_string_new = function(arg0, arg1) {
-    var ret = getStringFromWasm0(arg0, arg1);
+module.exports.__wbindgen_json_parse = function(arg0, arg1) {
+    var ret = JSON.parse(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_object_drop_ref = function(arg0) {
-    takeObject(arg0);
-};
-
 module.exports.__wbindgen_json_serialize = function(arg0, arg1) {
     const obj = getObject(arg1);
     var ret = JSON.stringify(obj === undefined ? null : obj);
@@ -2740,8 +3004,12 @@ module.exports.__wbindgen_json_serialize = function(arg0, arg1) {
     getInt32Memory0()[arg0 / 4 + 0] = ptr0;
 };
 
-module.exports.__wbindgen_json_parse = function(arg0, arg1) {
-    var ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+module.exports.__wbindgen_object_drop_ref = function(arg0) {
+    takeObject(arg0);
+};
+
+module.exports.__wbindgen_string_new = function(arg0, arg1) {
+    var ret = getStringFromWasm0(arg0, arg1);
     return addHeapObject(ret);
 };
 
@@ -2770,14 +3038,14 @@ module.exports.__wbg_error_009e67eab9c16665 = function(arg0) {
     console.error(getObject(arg0));
 };
 
-module.exports.__wbg_randomFillSync_64cc7d048f228ca8 = function() { return handleError(function (arg0, arg1, arg2) {
-    getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
-}, arguments) };
-
 module.exports.__wbg_getRandomValues_98117e9a7e993920 = function() { return handleError(function (arg0, arg1) {
     getObject(arg0).getRandomValues(getObject(arg1));
 }, arguments) };
 
+module.exports.__wbg_randomFillSync_64cc7d048f228ca8 = function() { return handleError(function (arg0, arg1, arg2) {
+    getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
+}, arguments) };
+
 module.exports.__wbg_process_2f24d6544ea7b200 = function(arg0) {
     var ret = getObject(arg0).process;
     return addHeapObject(ret);