fleethub-core 0.4.4 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/node/fh_core.js CHANGED
@@ -1,11 +1,15 @@
1
1
  let imports = {};
2
2
  imports['__wbindgen_placeholder__'] = module.exports;
3
3
  let wasm;
4
- const { TextDecoder, TextEncoder } = require(`util`);
4
+ const { TextEncoder, TextDecoder } = require(`util`);
5
5
 
6
- let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
6
+ const heap = new Array(32).fill(undefined);
7
7
 
8
- cachedTextDecoder.decode();
8
+ heap.push(undefined, null, true, false);
9
+
10
+ function getObject(idx) { return heap[idx]; }
11
+
12
+ let WASM_VECTOR_LEN = 0;
9
13
 
10
14
  let cachegetUint8Memory0 = null;
11
15
  function getUint8Memory0() {
@@ -15,29 +19,6 @@ function getUint8Memory0() {
15
19
  return cachegetUint8Memory0;
16
20
  }
17
21
 
18
- function getStringFromWasm0(ptr, len) {
19
- return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
20
- }
21
-
22
- const heap = new Array(32).fill(undefined);
23
-
24
- heap.push(undefined, null, true, false);
25
-
26
- let heap_next = heap.length;
27
-
28
- function addHeapObject(obj) {
29
- if (heap_next === heap.length) heap.push(heap.length + 1);
30
- const idx = heap_next;
31
- heap_next = heap[idx];
32
-
33
- heap[idx] = obj;
34
- return idx;
35
- }
36
-
37
- function getObject(idx) { return heap[idx]; }
38
-
39
- let WASM_VECTOR_LEN = 0;
40
-
41
22
  let cachedTextEncoder = new TextEncoder('utf-8');
42
23
 
43
24
  const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
@@ -99,6 +80,8 @@ function getInt32Memory0() {
99
80
  return cachegetInt32Memory0;
100
81
  }
101
82
 
83
+ let heap_next = heap.length;
84
+
102
85
  function dropObject(idx) {
103
86
  if (idx < 36) return;
104
87
  heap[idx] = heap_next;
@@ -111,6 +94,23 @@ function takeObject(idx) {
111
94
  return ret;
112
95
  }
113
96
 
97
+ let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
98
+
99
+ cachedTextDecoder.decode();
100
+
101
+ function getStringFromWasm0(ptr, len) {
102
+ return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
103
+ }
104
+
105
+ function addHeapObject(obj) {
106
+ if (heap_next === heap.length) heap.push(heap.length + 1);
107
+ const idx = heap_next;
108
+ heap_next = heap[idx];
109
+
110
+ heap[idx] = obj;
111
+ return idx;
112
+ }
113
+
114
114
  function debugString(val) {
115
115
  // primitive types
116
116
  const type = typeof val;
@@ -175,6 +175,11 @@ function debugString(val) {
175
175
  // TODO we could test for more things here, like `Set`s and `Map`s.
176
176
  return className;
177
177
  }
178
+ /**
179
+ */
180
+ module.exports.set_panic_hook = function() {
181
+ wasm.set_panic_hook();
182
+ };
178
183
 
179
184
  function _assertClass(instance, klass) {
180
185
  if (!(instance instanceof klass)) {
@@ -182,10 +187,6 @@ function _assertClass(instance, klass) {
182
187
  }
183
188
  return instance.ptr;
184
189
  }
185
-
186
- function isLikeNone(x) {
187
- return x === undefined || x === null;
188
- }
189
190
  /**
190
191
  * @param {Gear} gear
191
192
  * @returns {boolean}
@@ -196,6 +197,18 @@ module.exports.air_squadron_can_equip = function(gear) {
196
197
  return ret !== 0;
197
198
  };
198
199
 
200
+ function isLikeNone(x) {
201
+ return x === undefined || x === null;
202
+ }
203
+
204
+ let cachegetFloat64Memory0 = null;
205
+ function getFloat64Memory0() {
206
+ if (cachegetFloat64Memory0 === null || cachegetFloat64Memory0.buffer !== wasm.memory.buffer) {
207
+ cachegetFloat64Memory0 = new Float64Array(wasm.memory.buffer);
208
+ }
209
+ return cachegetFloat64Memory0;
210
+ }
211
+
199
212
  let cachegetUint32Memory0 = null;
200
213
  function getUint32Memory0() {
201
214
  if (cachegetUint32Memory0 === null || cachegetUint32Memory0.buffer !== wasm.memory.buffer) {
@@ -214,14 +227,6 @@ function getArrayJsValueFromWasm0(ptr, len) {
214
227
  return result;
215
228
  }
216
229
 
217
- let cachegetFloat64Memory0 = null;
218
- function getFloat64Memory0() {
219
- if (cachegetFloat64Memory0 === null || cachegetFloat64Memory0.buffer !== wasm.memory.buffer) {
220
- cachegetFloat64Memory0 = new Float64Array(wasm.memory.buffer);
221
- }
222
- return cachegetFloat64Memory0;
223
- }
224
-
225
230
  let cachegetUint16Memory0 = null;
226
231
  function getUint16Memory0() {
227
232
  if (cachegetUint16Memory0 === null || cachegetUint16Memory0.buffer !== wasm.memory.buffer) {
@@ -230,15 +235,12 @@ function getUint16Memory0() {
230
235
  return cachegetUint16Memory0;
231
236
  }
232
237
 
233
- function getArrayU16FromWasm0(ptr, len) {
234
- return getUint16Memory0().subarray(ptr / 2, ptr / 2 + len);
238
+ function passArray16ToWasm0(arg, malloc) {
239
+ const ptr = malloc(arg.length * 2);
240
+ getUint16Memory0().set(arg, ptr / 2);
241
+ WASM_VECTOR_LEN = arg.length;
242
+ return ptr;
235
243
  }
236
- /**
237
- */
238
- module.exports.set_panic_hook = function() {
239
- wasm.set_panic_hook();
240
- };
241
-
242
244
  /**
243
245
  * @param {bindings.OrgType} org_type
244
246
  * @returns {boolean}
@@ -275,6 +277,10 @@ module.exports.org_type_side = function(org_type) {
275
277
  return takeObject(ret);
276
278
  };
277
279
 
280
+ function getArrayU16FromWasm0(ptr, len) {
281
+ return getUint16Memory0().subarray(ptr / 2, ptr / 2 + len);
282
+ }
283
+
278
284
  function getArrayU8FromWasm0(ptr, len) {
279
285
  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
280
286
  }
@@ -311,7 +317,6 @@ class AirSquadron {
311
317
  wasm.__wbg_airsquadron_free(ptr);
312
318
  }
313
319
  /**
314
- * @returns {string}
315
320
  */
316
321
  get id() {
317
322
  try {
@@ -334,13 +339,18 @@ class AirSquadron {
334
339
  wasm.__wbg_set_airsquadron_id(this.ptr, ptr0, len0);
335
340
  }
336
341
  /**
337
- * @returns {bindings.AirSquadronMode}
338
342
  */
339
343
  get mode() {
340
344
  var ret = wasm.__wbg_get_airsquadron_mode(this.ptr);
341
345
  return takeObject(ret);
342
346
  }
343
347
  /**
348
+ * @param {bindings.AirSquadronMode} arg0
349
+ */
350
+ set mode(arg0) {
351
+ wasm.__wbg_set_airsquadron_mode(this.ptr, addHeapObject(arg0));
352
+ }
353
+ /**
344
354
  * @returns {string}
345
355
  */
346
356
  get xxh3() {
@@ -415,6 +425,96 @@ class AirSquadron {
415
425
  }
416
426
  module.exports.AirSquadron = AirSquadron;
417
427
 
428
+ const AnalyzerFinalization = new FinalizationRegistry(ptr => wasm.__wbg_analyzer_free(ptr));
429
+ /**
430
+ */
431
+ class Analyzer {
432
+
433
+ static __wrap(ptr) {
434
+ const obj = Object.create(Analyzer.prototype);
435
+ obj.ptr = ptr;
436
+ AnalyzerFinalization.register(obj, obj.ptr, obj);
437
+ return obj;
438
+ }
439
+
440
+ __destroy_into_raw() {
441
+ const ptr = this.ptr;
442
+ this.ptr = 0;
443
+ AnalyzerFinalization.unregister(this);
444
+ return ptr;
445
+ }
446
+
447
+ free() {
448
+ const ptr = this.__destroy_into_raw();
449
+ wasm.__wbg_analyzer_free(ptr);
450
+ }
451
+ /**
452
+ * @param {Comp} comp
453
+ * @param {bindings.Formation} formation
454
+ * @param {number | undefined} adjusted_anti_air_resist
455
+ * @param {number | undefined} fleet_anti_air_resist
456
+ * @param {number | undefined} aaci
457
+ * @returns {bindings.CompAntiAirInfo}
458
+ */
459
+ analyze_anti_air(comp, formation, adjusted_anti_air_resist, fleet_anti_air_resist, aaci) {
460
+ _assertClass(comp, Comp);
461
+ var ret = wasm.analyzer_analyze_anti_air(this.ptr, comp.ptr, addHeapObject(formation), !isLikeNone(adjusted_anti_air_resist), isLikeNone(adjusted_anti_air_resist) ? 0 : adjusted_anti_air_resist, !isLikeNone(fleet_anti_air_resist), isLikeNone(fleet_anti_air_resist) ? 0 : fleet_anti_air_resist, isLikeNone(aaci) ? 0xFFFFFF : aaci);
462
+ return takeObject(ret);
463
+ }
464
+ /**
465
+ * @param {Comp} comp
466
+ * @returns {bindings.CompDayCutinRateInfo}
467
+ */
468
+ analyze_day_cutin(comp) {
469
+ _assertClass(comp, Comp);
470
+ var ret = wasm.analyzer_analyze_day_cutin(this.ptr, comp.ptr);
471
+ return takeObject(ret);
472
+ }
473
+ /**
474
+ * @param {Comp} comp
475
+ * @param {bindings.NightSituation} attacker_situation
476
+ * @param {bindings.NightSituation} target_situation
477
+ * @returns {bindings.FleetNightCutinRateInfo}
478
+ */
479
+ analyze_night_cutin(comp, attacker_situation, target_situation) {
480
+ _assertClass(comp, Comp);
481
+ var ret = wasm.analyzer_analyze_night_cutin(this.ptr, comp.ptr, addHeapObject(attacker_situation), addHeapObject(target_situation));
482
+ return takeObject(ret);
483
+ }
484
+ /**
485
+ * @param {Comp} comp
486
+ * @returns {bindings.CompContactChanceInfo}
487
+ */
488
+ analyze_contact_chance(comp) {
489
+ _assertClass(comp, Comp);
490
+ var ret = wasm.analyzer_analyze_contact_chance(this.ptr, comp.ptr);
491
+ return takeObject(ret);
492
+ }
493
+ /**
494
+ * @param {bindings.WarfareAnalyzerContext} params
495
+ * @param {Ship} attacker
496
+ * @param {Ship} target
497
+ * @returns {bindings.WarfareInfo}
498
+ */
499
+ analyze_warfare(params, attacker, target) {
500
+ _assertClass(attacker, Ship);
501
+ _assertClass(target, Ship);
502
+ var ret = wasm.analyzer_analyze_warfare(this.ptr, addHeapObject(params), attacker.ptr, target.ptr);
503
+ return takeObject(ret);
504
+ }
505
+ /**
506
+ * @param {Comp} comp
507
+ * @param {bindings.Engagement} engagement
508
+ * @returns {bindings.FleetCutinAnalysis}
509
+ */
510
+ analyze_fleet_cutin(comp, engagement) {
511
+ _assertClass(comp, Comp);
512
+ var ret = wasm.analyzer_analyze_fleet_cutin(this.ptr, comp.ptr, addHeapObject(engagement));
513
+ return takeObject(ret);
514
+ }
515
+ }
516
+ module.exports.Analyzer = Analyzer;
517
+
418
518
  const CompFinalization = new FinalizationRegistry(ptr => wasm.__wbg_comp_free(ptr));
419
519
  /**
420
520
  */
@@ -439,7 +539,6 @@ class Comp {
439
539
  wasm.__wbg_comp_free(ptr);
440
540
  }
441
541
  /**
442
- * @returns {bindings.OrgType}
443
542
  */
444
543
  get org_type() {
445
544
  var ret = wasm.__wbg_get_comp_org_type(this.ptr);
@@ -452,7 +551,18 @@ class Comp {
452
551
  wasm.__wbg_set_comp_org_type(this.ptr, addHeapObject(arg0));
453
552
  }
454
553
  /**
455
- * @returns {Fleet}
554
+ */
555
+ get hq_level() {
556
+ var ret = wasm.__wbg_get_comp_hq_level(this.ptr);
557
+ return ret;
558
+ }
559
+ /**
560
+ * @param {number} arg0
561
+ */
562
+ set hq_level(arg0) {
563
+ wasm.__wbg_set_comp_hq_level(this.ptr, arg0);
564
+ }
565
+ /**
456
566
  */
457
567
  get main() {
458
568
  var ret = wasm.__wbg_get_comp_main(this.ptr);
@@ -468,7 +578,6 @@ class Comp {
468
578
  wasm.__wbg_set_comp_main(this.ptr, ptr0);
469
579
  }
470
580
  /**
471
- * @returns {Fleet | undefined}
472
581
  */
473
582
  get escort() {
474
583
  var ret = wasm.__wbg_get_comp_escort(this.ptr);
@@ -487,7 +596,6 @@ class Comp {
487
596
  wasm.__wbg_set_comp_escort(this.ptr, ptr0);
488
597
  }
489
598
  /**
490
- * @returns {Fleet | undefined}
491
599
  */
492
600
  get route_sup() {
493
601
  var ret = wasm.__wbg_get_comp_route_sup(this.ptr);
@@ -506,7 +614,6 @@ class Comp {
506
614
  wasm.__wbg_set_comp_route_sup(this.ptr, ptr0);
507
615
  }
508
616
  /**
509
- * @returns {Fleet | undefined}
510
617
  */
511
618
  get boss_sup() {
512
619
  var ret = wasm.__wbg_get_comp_boss_sup(this.ptr);
@@ -525,6 +632,13 @@ class Comp {
525
632
  wasm.__wbg_set_comp_boss_sup(this.ptr, ptr0);
526
633
  }
527
634
  /**
635
+ * @returns {bindings.Side}
636
+ */
637
+ side() {
638
+ var ret = wasm.comp_side(this.ptr);
639
+ return takeObject(ret);
640
+ }
641
+ /**
528
642
  * @returns {boolean}
529
643
  */
530
644
  is_combined() {
@@ -609,6 +723,63 @@ class Comp {
609
723
  var ret = wasm.comp_get_ship_by_eid_with_clone(this.ptr, ptr0, len0);
610
724
  return ret === 0 ? undefined : Ship.__wrap(ret);
611
725
  }
726
+ /**
727
+ * @returns {bindings.Formation}
728
+ */
729
+ default_formation() {
730
+ var ret = wasm.comp_default_formation(this.ptr);
731
+ return takeObject(ret);
732
+ }
733
+ /**
734
+ * 艦隊対空値
735
+ * @param {number} formation_mod
736
+ * @returns {number}
737
+ */
738
+ fleet_anti_air(formation_mod) {
739
+ var ret = wasm.comp_fleet_anti_air(this.ptr, formation_mod);
740
+ return ret;
741
+ }
742
+ /**
743
+ * 制空値
744
+ * @param {boolean} anti_combined
745
+ * @param {boolean} anti_lbas
746
+ * @returns {number | undefined}
747
+ */
748
+ fighter_power(anti_combined, anti_lbas) {
749
+ try {
750
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
751
+ wasm.comp_fighter_power(retptr, this.ptr, anti_combined, anti_lbas);
752
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
753
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
754
+ return r0 === 0 ? undefined : r1;
755
+ } finally {
756
+ wasm.__wbindgen_add_to_stack_pointer(16);
757
+ }
758
+ }
759
+ /**
760
+ * マップ索敵
761
+ * @param {number} node_divaricated_factor
762
+ * @returns {number | undefined}
763
+ */
764
+ elos(node_divaricated_factor) {
765
+ try {
766
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
767
+ wasm.comp_elos(retptr, this.ptr, node_divaricated_factor);
768
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
769
+ var r1 = getFloat64Memory0()[retptr / 8 + 1];
770
+ return r0 === 0 ? undefined : r1;
771
+ } finally {
772
+ wasm.__wbindgen_add_to_stack_pointer(16);
773
+ }
774
+ }
775
+ /**
776
+ * 輸送物資量(TP)
777
+ * @returns {number}
778
+ */
779
+ transport_point() {
780
+ var ret = wasm.comp_transport_point(this.ptr);
781
+ return ret;
782
+ }
612
783
  }
613
784
  module.exports.Comp = Comp;
614
785
 
@@ -692,105 +863,31 @@ class FhCore {
692
863
  return ret === 0 ? undefined : Ship.__wrap(ret);
693
864
  }
694
865
  /**
695
- * @returns {Ship}
696
- */
697
- create_default_ship() {
698
- var ret = wasm.fhcore_create_default_ship(this.ptr);
699
- return Ship.__wrap(ret);
700
- }
701
- /**
702
- * @returns {Uint16Array}
703
- */
704
- get_gear_ids() {
705
- try {
706
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
707
- wasm.fhcore_get_gear_ids(retptr, this.ptr);
708
- var r0 = getInt32Memory0()[retptr / 4 + 0];
709
- var r1 = getInt32Memory0()[retptr / 4 + 1];
710
- var v0 = getArrayU16FromWasm0(r0, r1).slice();
711
- wasm.__wbindgen_free(r0, r1 * 2);
712
- return v0;
713
- } finally {
714
- wasm.__wbindgen_add_to_stack_pointer(16);
715
- }
716
- }
717
- /**
718
- * @param {Org} org
719
- * @param {string} key
720
- * @param {bindings.Formation} formation
721
- * @param {number | undefined} adjusted_anti_air_resist
722
- * @param {number | undefined} fleet_anti_air_resist
723
- * @returns {any}
724
- */
725
- analyze_anti_air(org, key, formation, adjusted_anti_air_resist, fleet_anti_air_resist) {
726
- _assertClass(org, Org);
727
- var ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
728
- var len0 = WASM_VECTOR_LEN;
729
- var ret = wasm.fhcore_analyze_anti_air(this.ptr, org.ptr, ptr0, len0, addHeapObject(formation), !isLikeNone(adjusted_anti_air_resist), isLikeNone(adjusted_anti_air_resist) ? 0 : adjusted_anti_air_resist, !isLikeNone(fleet_anti_air_resist), isLikeNone(fleet_anti_air_resist) ? 0 : fleet_anti_air_resist);
730
- return takeObject(ret);
731
- }
732
- /**
733
- * @param {Org} org
734
- * @param {string} key
735
- * @returns {any}
736
- */
737
- analyze_day_cutin(org, key) {
738
- _assertClass(org, Org);
739
- var ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
740
- var len0 = WASM_VECTOR_LEN;
741
- var ret = wasm.fhcore_analyze_day_cutin(this.ptr, org.ptr, ptr0, len0);
742
- return takeObject(ret);
743
- }
744
- /**
745
- * @param {Org} org
746
- * @param {string} key
747
- * @param {bindings.NightSituation} attacker_situation
748
- * @param {bindings.NightSituation} defender_situation
749
- * @returns {any}
866
+ * @param {Uint16Array} main
867
+ * @param {Uint16Array | undefined} escort
868
+ * @returns {Comp}
750
869
  */
751
- analyze_night_cutin(org, key, attacker_situation, defender_situation) {
752
- _assertClass(org, Org);
753
- var ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
870
+ create_comp_by_map_enemy(main, escort) {
871
+ var ptr0 = passArray16ToWasm0(main, wasm.__wbindgen_malloc);
754
872
  var len0 = WASM_VECTOR_LEN;
755
- var ret = wasm.fhcore_analyze_night_cutin(this.ptr, org.ptr, ptr0, len0, addHeapObject(attacker_situation), addHeapObject(defender_situation));
756
- return takeObject(ret);
873
+ var ptr1 = isLikeNone(escort) ? 0 : passArray16ToWasm0(escort, wasm.__wbindgen_malloc);
874
+ var len1 = WASM_VECTOR_LEN;
875
+ var ret = wasm.fhcore_create_comp_by_map_enemy(this.ptr, ptr0, len0, ptr1, len1);
876
+ return Comp.__wrap(ret);
757
877
  }
758
878
  /**
759
- * @param {Org} org
760
- * @param {string} key
761
- * @returns {any}
879
+ * @returns {Ship}
762
880
  */
763
- analyze_contact_chance(org, key) {
764
- _assertClass(org, Org);
765
- var ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
766
- var len0 = WASM_VECTOR_LEN;
767
- var ret = wasm.fhcore_analyze_contact_chance(this.ptr, org.ptr, ptr0, len0);
768
- return takeObject(ret);
881
+ create_default_ship() {
882
+ var ret = wasm.fhcore_create_default_ship(this.ptr);
883
+ return Ship.__wrap(ret);
769
884
  }
770
885
  /**
771
- * @param {bindings.WarfareAnalyzerContext} params
772
- * @param {Ship} attacker
773
- * @param {Ship} target
774
- * @returns {bindings.WarfareInfo}
886
+ * @returns {Analyzer}
775
887
  */
776
- analyze_warfare(params, attacker, target) {
777
- _assertClass(attacker, Ship);
778
- _assertClass(target, Ship);
779
- var ret = wasm.fhcore_analyze_warfare(this.ptr, addHeapObject(params), attacker.ptr, target.ptr);
780
- return takeObject(ret);
781
- }
782
- /**
783
- * @param {Org} org
784
- * @param {string} key
785
- * @param {bindings.Engagement} engagement
786
- * @returns {bindings.FleetCutinAnalysis}
787
- */
788
- analyze_fleet_cutin(org, key, engagement) {
789
- _assertClass(org, Org);
790
- var ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
791
- var len0 = WASM_VECTOR_LEN;
792
- var ret = wasm.fhcore_analyze_fleet_cutin(this.ptr, org.ptr, ptr0, len0, addHeapObject(engagement));
793
- return takeObject(ret);
888
+ create_analyzer() {
889
+ var ret = wasm.fhcore_create_analyzer(this.ptr);
890
+ return Analyzer.__wrap(ret);
794
891
  }
795
892
  /**
796
893
  * @param {Comp} player
@@ -832,7 +929,6 @@ class Fleet {
832
929
  wasm.__wbg_fleet_free(ptr);
833
930
  }
834
931
  /**
835
- * @returns {string}
836
932
  */
837
933
  get id() {
838
934
  try {
@@ -855,13 +951,18 @@ class Fleet {
855
951
  wasm.__wbg_set_fleet_id(this.ptr, ptr0, len0);
856
952
  }
857
953
  /**
858
- * @returns {number}
859
954
  */
860
955
  get len() {
861
956
  var ret = wasm.__wbg_get_fleet_len(this.ptr);
862
957
  return ret >>> 0;
863
958
  }
864
959
  /**
960
+ * @param {number} arg0
961
+ */
962
+ set len(arg0) {
963
+ wasm.__wbg_set_fleet_len(this.ptr, arg0);
964
+ }
965
+ /**
865
966
  * @returns {string}
866
967
  */
867
968
  get xxh3() {
@@ -1117,7 +1218,6 @@ class Gear {
1117
1218
  wasm.__wbg_gear_free(ptr);
1118
1219
  }
1119
1220
  /**
1120
- * @returns {string}
1121
1221
  */
1122
1222
  get id() {
1123
1223
  try {
@@ -1140,35 +1240,54 @@ class Gear {
1140
1240
  wasm.__wbg_set_gear_id(this.ptr, ptr0, len0);
1141
1241
  }
1142
1242
  /**
1143
- * @returns {number}
1144
1243
  */
1145
1244
  get gear_id() {
1146
1245
  var ret = wasm.__wbg_get_gear_gear_id(this.ptr);
1147
1246
  return ret;
1148
1247
  }
1149
1248
  /**
1150
- * @returns {number}
1249
+ * @param {number} arg0
1250
+ */
1251
+ set gear_id(arg0) {
1252
+ wasm.__wbg_set_gear_gear_id(this.ptr, arg0);
1253
+ }
1254
+ /**
1151
1255
  */
1152
1256
  get stars() {
1153
1257
  var ret = wasm.__wbg_get_gear_stars(this.ptr);
1154
1258
  return ret;
1155
1259
  }
1156
1260
  /**
1157
- * @returns {number}
1261
+ * @param {number} arg0
1262
+ */
1263
+ set stars(arg0) {
1264
+ wasm.__wbg_set_gear_stars(this.ptr, arg0);
1265
+ }
1266
+ /**
1158
1267
  */
1159
1268
  get exp() {
1160
1269
  var ret = wasm.__wbg_get_gear_exp(this.ptr);
1161
1270
  return ret;
1162
1271
  }
1163
1272
  /**
1164
- * @returns {number}
1273
+ * @param {number} arg0
1274
+ */
1275
+ set exp(arg0) {
1276
+ wasm.__wbg_set_gear_exp(this.ptr, arg0);
1277
+ }
1278
+ /**
1165
1279
  */
1166
1280
  get default_exp() {
1167
1281
  var ret = wasm.__wbg_get_gear_default_exp(this.ptr);
1168
1282
  return ret;
1169
1283
  }
1170
1284
  /**
1171
- * @returns {string}
1285
+ * @param {number} arg0
1286
+ */
1287
+ set default_exp(arg0) {
1288
+ wasm.__wbg_set_gear_default_exp(this.ptr, arg0);
1289
+ }
1290
+ /**
1172
1291
  */
1173
1292
  get name() {
1174
1293
  try {
@@ -1191,139 +1310,234 @@ class Gear {
1191
1310
  wasm.__wbg_set_gear_name(this.ptr, ptr0, len0);
1192
1311
  }
1193
1312
  /**
1194
- * @returns {bindings.GearType}
1195
1313
  */
1196
1314
  get gear_type() {
1197
1315
  var ret = wasm.__wbg_get_gear_gear_type(this.ptr);
1198
1316
  return takeObject(ret);
1199
1317
  }
1200
1318
  /**
1201
- * @returns {number}
1319
+ * @param {bindings.GearType} arg0
1320
+ */
1321
+ set gear_type(arg0) {
1322
+ wasm.__wbg_set_gear_gear_type(this.ptr, addHeapObject(arg0));
1323
+ }
1324
+ /**
1202
1325
  */
1203
1326
  get max_hp() {
1204
1327
  var ret = wasm.__wbg_get_gear_max_hp(this.ptr);
1205
1328
  return ret;
1206
1329
  }
1207
1330
  /**
1208
- * @returns {number}
1331
+ * @param {number} arg0
1332
+ */
1333
+ set max_hp(arg0) {
1334
+ wasm.__wbg_set_gear_max_hp(this.ptr, arg0);
1335
+ }
1336
+ /**
1209
1337
  */
1210
1338
  get firepower() {
1211
1339
  var ret = wasm.__wbg_get_gear_firepower(this.ptr);
1212
1340
  return ret;
1213
1341
  }
1214
1342
  /**
1215
- * @returns {number}
1343
+ * @param {number} arg0
1344
+ */
1345
+ set firepower(arg0) {
1346
+ wasm.__wbg_set_gear_firepower(this.ptr, arg0);
1347
+ }
1348
+ /**
1216
1349
  */
1217
1350
  get armor() {
1218
1351
  var ret = wasm.__wbg_get_gear_armor(this.ptr);
1219
1352
  return ret;
1220
1353
  }
1221
1354
  /**
1222
- * @returns {number}
1355
+ * @param {number} arg0
1356
+ */
1357
+ set armor(arg0) {
1358
+ wasm.__wbg_set_gear_armor(this.ptr, arg0);
1359
+ }
1360
+ /**
1223
1361
  */
1224
1362
  get torpedo() {
1225
1363
  var ret = wasm.__wbg_get_gear_torpedo(this.ptr);
1226
1364
  return ret;
1227
1365
  }
1228
1366
  /**
1229
- * @returns {number}
1367
+ * @param {number} arg0
1368
+ */
1369
+ set torpedo(arg0) {
1370
+ wasm.__wbg_set_gear_torpedo(this.ptr, arg0);
1371
+ }
1372
+ /**
1230
1373
  */
1231
1374
  get anti_air() {
1232
1375
  var ret = wasm.__wbg_get_gear_anti_air(this.ptr);
1233
1376
  return ret;
1234
1377
  }
1235
1378
  /**
1236
- * @returns {number}
1379
+ * @param {number} arg0
1380
+ */
1381
+ set anti_air(arg0) {
1382
+ wasm.__wbg_set_gear_anti_air(this.ptr, arg0);
1383
+ }
1384
+ /**
1237
1385
  */
1238
1386
  get speed() {
1239
1387
  var ret = wasm.__wbg_get_gear_speed(this.ptr);
1240
1388
  return ret;
1241
1389
  }
1242
1390
  /**
1243
- * @returns {number}
1391
+ * @param {number} arg0
1392
+ */
1393
+ set speed(arg0) {
1394
+ wasm.__wbg_set_gear_speed(this.ptr, arg0);
1395
+ }
1396
+ /**
1244
1397
  */
1245
1398
  get bombing() {
1246
1399
  var ret = wasm.__wbg_get_gear_bombing(this.ptr);
1247
1400
  return ret;
1248
1401
  }
1249
1402
  /**
1250
- * @returns {number}
1403
+ * @param {number} arg0
1404
+ */
1405
+ set bombing(arg0) {
1406
+ wasm.__wbg_set_gear_bombing(this.ptr, arg0);
1407
+ }
1408
+ /**
1251
1409
  */
1252
1410
  get asw() {
1253
1411
  var ret = wasm.__wbg_get_gear_asw(this.ptr);
1254
1412
  return ret;
1255
1413
  }
1256
1414
  /**
1257
- * @returns {number}
1415
+ * @param {number} arg0
1416
+ */
1417
+ set asw(arg0) {
1418
+ wasm.__wbg_set_gear_asw(this.ptr, arg0);
1419
+ }
1420
+ /**
1258
1421
  */
1259
1422
  get los() {
1260
1423
  var ret = wasm.__wbg_get_gear_los(this.ptr);
1261
1424
  return ret;
1262
1425
  }
1263
1426
  /**
1264
- * @returns {number}
1427
+ * @param {number} arg0
1428
+ */
1429
+ set los(arg0) {
1430
+ wasm.__wbg_set_gear_los(this.ptr, arg0);
1431
+ }
1432
+ /**
1265
1433
  */
1266
1434
  get luck() {
1267
1435
  var ret = wasm.__wbg_get_gear_luck(this.ptr);
1268
1436
  return ret;
1269
1437
  }
1270
1438
  /**
1271
- * @returns {number}
1439
+ * @param {number} arg0
1440
+ */
1441
+ set luck(arg0) {
1442
+ wasm.__wbg_set_gear_luck(this.ptr, arg0);
1443
+ }
1444
+ /**
1272
1445
  */
1273
1446
  get accuracy() {
1274
1447
  var ret = wasm.__wbg_get_gear_accuracy(this.ptr);
1275
1448
  return ret;
1276
1449
  }
1277
1450
  /**
1278
- * @returns {number}
1451
+ * @param {number} arg0
1452
+ */
1453
+ set accuracy(arg0) {
1454
+ wasm.__wbg_set_gear_accuracy(this.ptr, arg0);
1455
+ }
1456
+ /**
1279
1457
  */
1280
1458
  get evasion() {
1281
1459
  var ret = wasm.__wbg_get_gear_evasion(this.ptr);
1282
1460
  return ret;
1283
1461
  }
1284
1462
  /**
1285
- * @returns {number}
1463
+ * @param {number} arg0
1464
+ */
1465
+ set evasion(arg0) {
1466
+ wasm.__wbg_set_gear_evasion(this.ptr, arg0);
1467
+ }
1468
+ /**
1286
1469
  */
1287
1470
  get range() {
1288
1471
  var ret = wasm.__wbg_get_gear_range(this.ptr);
1289
1472
  return ret;
1290
1473
  }
1291
1474
  /**
1292
- * @returns {number}
1475
+ * @param {number} arg0
1476
+ */
1477
+ set range(arg0) {
1478
+ wasm.__wbg_set_gear_range(this.ptr, arg0);
1479
+ }
1480
+ /**
1293
1481
  */
1294
1482
  get radius() {
1295
1483
  var ret = wasm.__wbg_get_gear_radius(this.ptr);
1296
1484
  return ret;
1297
1485
  }
1298
1486
  /**
1299
- * @returns {number}
1487
+ * @param {number} arg0
1488
+ */
1489
+ set radius(arg0) {
1490
+ wasm.__wbg_set_gear_radius(this.ptr, arg0);
1491
+ }
1492
+ /**
1300
1493
  */
1301
1494
  get cost() {
1302
1495
  var ret = wasm.__wbg_get_gear_cost(this.ptr);
1303
1496
  return ret;
1304
1497
  }
1305
1498
  /**
1306
- * @returns {boolean}
1499
+ * @param {number} arg0
1500
+ */
1501
+ set cost(arg0) {
1502
+ wasm.__wbg_set_gear_cost(this.ptr, arg0);
1503
+ }
1504
+ /**
1307
1505
  */
1308
1506
  get improvable() {
1309
1507
  var ret = wasm.__wbg_get_gear_improvable(this.ptr);
1310
1508
  return ret !== 0;
1311
1509
  }
1312
1510
  /**
1313
- * @returns {number}
1511
+ * @param {boolean} arg0
1512
+ */
1513
+ set improvable(arg0) {
1514
+ wasm.__wbg_set_gear_improvable(this.ptr, arg0);
1515
+ }
1516
+ /**
1314
1517
  */
1315
1518
  get adjusted_anti_air_resistance() {
1316
1519
  var ret = wasm.__wbg_get_gear_adjusted_anti_air_resistance(this.ptr);
1317
1520
  return ret;
1318
1521
  }
1319
1522
  /**
1320
- * @returns {number}
1523
+ * @param {number} arg0
1524
+ */
1525
+ set adjusted_anti_air_resistance(arg0) {
1526
+ wasm.__wbg_set_gear_adjusted_anti_air_resistance(this.ptr, arg0);
1527
+ }
1528
+ /**
1321
1529
  */
1322
1530
  get fleet_anti_air_resistance() {
1323
1531
  var ret = wasm.__wbg_get_gear_fleet_anti_air_resistance(this.ptr);
1324
1532
  return ret;
1325
1533
  }
1326
1534
  /**
1535
+ * @param {number} arg0
1536
+ */
1537
+ set fleet_anti_air_resistance(arg0) {
1538
+ wasm.__wbg_set_gear_fleet_anti_air_resistance(this.ptr, arg0);
1539
+ }
1540
+ /**
1327
1541
  * @returns {Gear}
1328
1542
  */
1329
1543
  static default() {
@@ -1483,11 +1697,11 @@ class Gear {
1483
1697
  return ret !== 0;
1484
1698
  }
1485
1699
  /**
1486
- * @param {number} air_state_modifier
1700
+ * @param {bindings.AirStateRank} rank
1487
1701
  * @returns {number}
1488
1702
  */
1489
- contact_selection_rate(air_state_modifier) {
1490
- var ret = wasm.gear_contact_selection_rate(this.ptr, air_state_modifier);
1703
+ contact_selection_rate(rank) {
1704
+ var ret = wasm.gear_contact_selection_rate(this.ptr, addHeapObject(rank));
1491
1705
  return ret;
1492
1706
  }
1493
1707
  /**
@@ -1524,6 +1738,13 @@ class Gear {
1524
1738
  /**
1525
1739
  * @returns {boolean}
1526
1740
  */
1741
+ is_abyssal() {
1742
+ var ret = wasm.gear_is_abyssal(this.ptr);
1743
+ return ret !== 0;
1744
+ }
1745
+ /**
1746
+ * @returns {boolean}
1747
+ */
1527
1748
  is_abyssal_cuttlefish_torpedo() {
1528
1749
  var ret = wasm.gear_is_abyssal_cuttlefish_torpedo(this.ptr);
1529
1750
  return ret !== 0;
@@ -1562,7 +1783,6 @@ class IBonuses {
1562
1783
  wasm.__wbg_ibonuses_free(ptr);
1563
1784
  }
1564
1785
  /**
1565
- * @returns {number}
1566
1786
  */
1567
1787
  get shelling_power() {
1568
1788
  var ret = wasm.__wbg_get_ibonuses_shelling_power(this.ptr);
@@ -1575,7 +1795,6 @@ class IBonuses {
1575
1795
  wasm.__wbg_set_ibonuses_shelling_power(this.ptr, arg0);
1576
1796
  }
1577
1797
  /**
1578
- * @returns {number}
1579
1798
  */
1580
1799
  get carrier_shelling_power() {
1581
1800
  var ret = wasm.__wbg_get_ibonuses_carrier_shelling_power(this.ptr);
@@ -1588,7 +1807,6 @@ class IBonuses {
1588
1807
  wasm.__wbg_set_ibonuses_carrier_shelling_power(this.ptr, arg0);
1589
1808
  }
1590
1809
  /**
1591
- * @returns {number}
1592
1810
  */
1593
1811
  get shelling_accuracy() {
1594
1812
  var ret = wasm.__wbg_get_ibonuses_shelling_accuracy(this.ptr);
@@ -1601,7 +1819,6 @@ class IBonuses {
1601
1819
  wasm.__wbg_set_ibonuses_shelling_accuracy(this.ptr, arg0);
1602
1820
  }
1603
1821
  /**
1604
- * @returns {number}
1605
1822
  */
1606
1823
  get torpedo_power() {
1607
1824
  var ret = wasm.__wbg_get_ibonuses_torpedo_power(this.ptr);
@@ -1614,7 +1831,6 @@ class IBonuses {
1614
1831
  wasm.__wbg_set_ibonuses_torpedo_power(this.ptr, arg0);
1615
1832
  }
1616
1833
  /**
1617
- * @returns {number}
1618
1834
  */
1619
1835
  get torpedo_accuracy() {
1620
1836
  var ret = wasm.__wbg_get_ibonuses_torpedo_accuracy(this.ptr);
@@ -1627,7 +1843,6 @@ class IBonuses {
1627
1843
  wasm.__wbg_set_ibonuses_torpedo_accuracy(this.ptr, arg0);
1628
1844
  }
1629
1845
  /**
1630
- * @returns {number}
1631
1846
  */
1632
1847
  get torpedo_evasion() {
1633
1848
  var ret = wasm.__wbg_get_ibonuses_torpedo_evasion(this.ptr);
@@ -1640,7 +1855,6 @@ class IBonuses {
1640
1855
  wasm.__wbg_set_ibonuses_torpedo_evasion(this.ptr, arg0);
1641
1856
  }
1642
1857
  /**
1643
- * @returns {number}
1644
1858
  */
1645
1859
  get asw_power() {
1646
1860
  var ret = wasm.__wbg_get_ibonuses_asw_power(this.ptr);
@@ -1653,7 +1867,6 @@ class IBonuses {
1653
1867
  wasm.__wbg_set_ibonuses_asw_power(this.ptr, arg0);
1654
1868
  }
1655
1869
  /**
1656
- * @returns {number}
1657
1870
  */
1658
1871
  get asw_accuracy() {
1659
1872
  var ret = wasm.__wbg_get_ibonuses_asw_accuracy(this.ptr);
@@ -1666,7 +1879,6 @@ class IBonuses {
1666
1879
  wasm.__wbg_set_ibonuses_asw_accuracy(this.ptr, arg0);
1667
1880
  }
1668
1881
  /**
1669
- * @returns {number}
1670
1882
  */
1671
1883
  get night_power() {
1672
1884
  var ret = wasm.__wbg_get_ibonuses_night_power(this.ptr);
@@ -1679,7 +1891,6 @@ class IBonuses {
1679
1891
  wasm.__wbg_set_ibonuses_night_power(this.ptr, arg0);
1680
1892
  }
1681
1893
  /**
1682
- * @returns {number}
1683
1894
  */
1684
1895
  get night_accuracy() {
1685
1896
  var ret = wasm.__wbg_get_ibonuses_night_accuracy(this.ptr);
@@ -1692,7 +1903,6 @@ class IBonuses {
1692
1903
  wasm.__wbg_set_ibonuses_night_accuracy(this.ptr, arg0);
1693
1904
  }
1694
1905
  /**
1695
- * @returns {number}
1696
1906
  */
1697
1907
  get defense_power() {
1698
1908
  var ret = wasm.__wbg_get_ibonuses_defense_power(this.ptr);
@@ -1705,7 +1915,6 @@ class IBonuses {
1705
1915
  wasm.__wbg_set_ibonuses_defense_power(this.ptr, arg0);
1706
1916
  }
1707
1917
  /**
1708
- * @returns {number}
1709
1918
  */
1710
1919
  get contact_selection() {
1711
1920
  var ret = wasm.__wbg_get_ibonuses_contact_selection(this.ptr);
@@ -1718,7 +1927,6 @@ class IBonuses {
1718
1927
  wasm.__wbg_set_ibonuses_contact_selection(this.ptr, arg0);
1719
1928
  }
1720
1929
  /**
1721
- * @returns {number}
1722
1930
  */
1723
1931
  get fighter_power() {
1724
1932
  var ret = wasm.__wbg_get_ibonuses_fighter_power(this.ptr);
@@ -1731,7 +1939,6 @@ class IBonuses {
1731
1939
  wasm.__wbg_set_ibonuses_fighter_power(this.ptr, arg0);
1732
1940
  }
1733
1941
  /**
1734
- * @returns {number}
1735
1942
  */
1736
1943
  get adjusted_anti_air() {
1737
1944
  var ret = wasm.__wbg_get_ibonuses_adjusted_anti_air(this.ptr);
@@ -1744,7 +1951,6 @@ class IBonuses {
1744
1951
  wasm.__wbg_set_ibonuses_adjusted_anti_air(this.ptr, arg0);
1745
1952
  }
1746
1953
  /**
1747
- * @returns {number}
1748
1954
  */
1749
1955
  get fleet_anti_air() {
1750
1956
  var ret = wasm.__wbg_get_ibonuses_fleet_anti_air(this.ptr);
@@ -1757,7 +1963,6 @@ class IBonuses {
1757
1963
  wasm.__wbg_set_ibonuses_fleet_anti_air(this.ptr, arg0);
1758
1964
  }
1759
1965
  /**
1760
- * @returns {number}
1761
1966
  */
1762
1967
  get elos() {
1763
1968
  var ret = wasm.__wbg_get_ibonuses_elos(this.ptr);
@@ -1796,7 +2001,6 @@ class Org {
1796
2001
  wasm.__wbg_org_free(ptr);
1797
2002
  }
1798
2003
  /**
1799
- * @returns {string}
1800
2004
  */
1801
2005
  get id() {
1802
2006
  try {
@@ -1819,26 +2023,35 @@ class Org {
1819
2023
  wasm.__wbg_set_org_id(this.ptr, ptr0, len0);
1820
2024
  }
1821
2025
  /**
1822
- * @returns {number}
1823
2026
  */
1824
2027
  get hq_level() {
1825
2028
  var ret = wasm.__wbg_get_org_hq_level(this.ptr);
1826
2029
  return ret;
1827
2030
  }
1828
2031
  /**
1829
- * @returns {bindings.OrgType}
2032
+ * @param {number} arg0
2033
+ */
2034
+ set hq_level(arg0) {
2035
+ wasm.__wbg_set_org_hq_level(this.ptr, arg0);
2036
+ }
2037
+ /**
1830
2038
  */
1831
2039
  get org_type() {
1832
2040
  var ret = wasm.__wbg_get_org_org_type(this.ptr);
1833
2041
  return takeObject(ret);
1834
2042
  }
1835
2043
  /**
1836
- * @returns {string}
2044
+ * @param {bindings.OrgType} arg0
1837
2045
  */
1838
- get route_sup() {
2046
+ set org_type(arg0) {
2047
+ wasm.__wbg_set_org_org_type(this.ptr, addHeapObject(arg0));
2048
+ }
2049
+ /**
2050
+ */
2051
+ get sortie() {
1839
2052
  try {
1840
2053
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1841
- wasm.__wbg_get_org_route_sup(retptr, this.ptr);
2054
+ wasm.__wbg_get_org_sortie(retptr, this.ptr);
1842
2055
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1843
2056
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1844
2057
  return getStringFromWasm0(r0, r1);
@@ -1850,13 +2063,38 @@ class Org {
1850
2063
  /**
1851
2064
  * @param {string} arg0
1852
2065
  */
1853
- set route_sup(arg0) {
2066
+ set sortie(arg0) {
1854
2067
  var ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1855
2068
  var len0 = WASM_VECTOR_LEN;
2069
+ wasm.__wbg_set_org_sortie(this.ptr, ptr0, len0);
2070
+ }
2071
+ /**
2072
+ */
2073
+ get route_sup() {
2074
+ try {
2075
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2076
+ wasm.__wbg_get_org_route_sup(retptr, this.ptr);
2077
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
2078
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
2079
+ let v0;
2080
+ if (r0 !== 0) {
2081
+ v0 = getStringFromWasm0(r0, r1).slice();
2082
+ wasm.__wbindgen_free(r0, r1 * 1);
2083
+ }
2084
+ return v0;
2085
+ } finally {
2086
+ wasm.__wbindgen_add_to_stack_pointer(16);
2087
+ }
2088
+ }
2089
+ /**
2090
+ * @param {string | undefined} arg0
2091
+ */
2092
+ set route_sup(arg0) {
2093
+ var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2094
+ var len0 = WASM_VECTOR_LEN;
1856
2095
  wasm.__wbg_set_org_route_sup(this.ptr, ptr0, len0);
1857
2096
  }
1858
2097
  /**
1859
- * @returns {string}
1860
2098
  */
1861
2099
  get boss_sup() {
1862
2100
  try {
@@ -1864,17 +2102,21 @@ class Org {
1864
2102
  wasm.__wbg_get_org_boss_sup(retptr, this.ptr);
1865
2103
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1866
2104
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1867
- return getStringFromWasm0(r0, r1);
2105
+ let v0;
2106
+ if (r0 !== 0) {
2107
+ v0 = getStringFromWasm0(r0, r1).slice();
2108
+ wasm.__wbindgen_free(r0, r1 * 1);
2109
+ }
2110
+ return v0;
1868
2111
  } finally {
1869
2112
  wasm.__wbindgen_add_to_stack_pointer(16);
1870
- wasm.__wbindgen_free(r0, r1);
1871
2113
  }
1872
2114
  }
1873
2115
  /**
1874
- * @param {string} arg0
2116
+ * @param {string | undefined} arg0
1875
2117
  */
1876
2118
  set boss_sup(arg0) {
1877
- var ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2119
+ var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1878
2120
  var len0 = WASM_VECTOR_LEN;
1879
2121
  wasm.__wbg_set_org_boss_sup(this.ptr, ptr0, len0);
1880
2122
  }
@@ -1942,43 +2184,6 @@ class Org {
1942
2184
  }
1943
2185
  /**
1944
2186
  * @param {bindings.Role} role
1945
- * @returns {(string)[]}
1946
- */
1947
- ship_keys(role) {
1948
- try {
1949
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1950
- wasm.org_ship_keys(retptr, this.ptr, addHeapObject(role));
1951
- var r0 = getInt32Memory0()[retptr / 4 + 0];
1952
- var r1 = getInt32Memory0()[retptr / 4 + 1];
1953
- var v0 = getArrayJsValueFromWasm0(r0, r1).slice();
1954
- wasm.__wbindgen_free(r0, r1 * 4);
1955
- return v0;
1956
- } finally {
1957
- wasm.__wbindgen_add_to_stack_pointer(16);
1958
- }
1959
- }
1960
- /**
1961
- * @param {bindings.Role} role
1962
- * @returns {(string)[] | undefined}
1963
- */
1964
- sortie_ship_keys(role) {
1965
- try {
1966
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1967
- wasm.org_sortie_ship_keys(retptr, this.ptr, addHeapObject(role));
1968
- var r0 = getInt32Memory0()[retptr / 4 + 0];
1969
- var r1 = getInt32Memory0()[retptr / 4 + 1];
1970
- let v0;
1971
- if (r0 !== 0) {
1972
- v0 = getArrayJsValueFromWasm0(r0, r1).slice();
1973
- wasm.__wbindgen_free(r0, r1 * 4);
1974
- }
1975
- return v0;
1976
- } finally {
1977
- wasm.__wbindgen_add_to_stack_pointer(16);
1978
- }
1979
- }
1980
- /**
1981
- * @param {bindings.Role} role
1982
2187
  * @returns {number | undefined}
1983
2188
  */
1984
2189
  fleet_los_mod(role) {
@@ -2072,6 +2277,13 @@ class Org {
2072
2277
  }
2073
2278
  }
2074
2279
  /**
2280
+ * @returns {Comp}
2281
+ */
2282
+ create_comp() {
2283
+ var ret = wasm.org_create_comp(this.ptr);
2284
+ return Comp.__wrap(ret);
2285
+ }
2286
+ /**
2075
2287
  * @param {string} key
2076
2288
  * @returns {Comp}
2077
2289
  */
@@ -2152,55 +2364,6 @@ class Org {
2152
2364
  return ret !== 0;
2153
2365
  }
2154
2366
  /**
2155
- * @returns {bindings.Formation}
2156
- */
2157
- default_formation() {
2158
- var ret = wasm.org_default_formation(this.ptr);
2159
- return takeObject(ret);
2160
- }
2161
- /**
2162
- * 艦隊対空値
2163
- * @param {number} formation_mod
2164
- * @returns {number}
2165
- */
2166
- fleet_anti_air(formation_mod) {
2167
- var ret = wasm.org_fleet_anti_air(this.ptr, formation_mod);
2168
- return ret;
2169
- }
2170
- /**
2171
- * 制空値
2172
- * @param {boolean} anti_combined
2173
- * @param {boolean} anti_lbas
2174
- * @returns {number | undefined}
2175
- */
2176
- fighter_power(anti_combined, anti_lbas) {
2177
- try {
2178
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2179
- wasm.org_fighter_power(retptr, this.ptr, anti_combined, anti_lbas);
2180
- var r0 = getInt32Memory0()[retptr / 4 + 0];
2181
- var r1 = getInt32Memory0()[retptr / 4 + 1];
2182
- return r0 === 0 ? undefined : r1;
2183
- } finally {
2184
- wasm.__wbindgen_add_to_stack_pointer(16);
2185
- }
2186
- }
2187
- /**
2188
- * マップ索敵
2189
- * @param {number} node_divaricated_factor
2190
- * @returns {number | undefined}
2191
- */
2192
- elos(node_divaricated_factor) {
2193
- try {
2194
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2195
- wasm.org_elos(retptr, this.ptr, node_divaricated_factor);
2196
- var r0 = getInt32Memory0()[retptr / 4 + 0];
2197
- var r1 = getFloat64Memory0()[retptr / 8 + 1];
2198
- return r0 === 0 ? undefined : r1;
2199
- } finally {
2200
- wasm.__wbindgen_add_to_stack_pointer(16);
2201
- }
2202
- }
2203
- /**
2204
2367
  * 防空時の基地制空値
2205
2368
  * @returns {number}
2206
2369
  */
@@ -2217,17 +2380,6 @@ class Org {
2217
2380
  return ret;
2218
2381
  }
2219
2382
  /**
2220
- * 輸送物資量(TP)
2221
- * @param {string} key
2222
- * @returns {number}
2223
- */
2224
- transport_point(key) {
2225
- var ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2226
- var len0 = WASM_VECTOR_LEN;
2227
- var ret = wasm.org_transport_point(this.ptr, ptr0, len0);
2228
- return ret;
2229
- }
2230
- /**
2231
2383
  * @param {Ship} ship
2232
2384
  * @param {bindings.Formation} formation
2233
2385
  * @returns {bindings.WarfareShipEnvironment}
@@ -2271,7 +2423,6 @@ class Ship {
2271
2423
  wasm.__wbg_ship_free(ptr);
2272
2424
  }
2273
2425
  /**
2274
- * @returns {string}
2275
2426
  */
2276
2427
  get id() {
2277
2428
  try {
@@ -2294,62 +2445,102 @@ class Ship {
2294
2445
  wasm.__wbg_set_ship_id(this.ptr, ptr0, len0);
2295
2446
  }
2296
2447
  /**
2297
- * @returns {number}
2298
2448
  */
2299
2449
  get ship_id() {
2300
2450
  var ret = wasm.__wbg_get_ship_ship_id(this.ptr);
2301
2451
  return ret;
2302
2452
  }
2303
2453
  /**
2304
- * @returns {number}
2454
+ * @param {number} arg0
2455
+ */
2456
+ set ship_id(arg0) {
2457
+ wasm.__wbg_set_ship_ship_id(this.ptr, arg0);
2458
+ }
2459
+ /**
2305
2460
  */
2306
2461
  get level() {
2307
2462
  var ret = wasm.__wbg_get_ship_level(this.ptr);
2308
2463
  return ret;
2309
2464
  }
2310
2465
  /**
2311
- * @returns {number}
2466
+ * @param {number} arg0
2467
+ */
2468
+ set level(arg0) {
2469
+ wasm.__wbg_set_ship_level(this.ptr, arg0);
2470
+ }
2471
+ /**
2312
2472
  */
2313
2473
  get current_hp() {
2314
2474
  var ret = wasm.__wbg_get_ship_current_hp(this.ptr);
2315
2475
  return ret;
2316
2476
  }
2317
2477
  /**
2318
- * @returns {number}
2478
+ * @param {number} arg0
2479
+ */
2480
+ set current_hp(arg0) {
2481
+ wasm.__wbg_set_ship_current_hp(this.ptr, arg0);
2482
+ }
2483
+ /**
2319
2484
  */
2320
2485
  get morale() {
2321
2486
  var ret = wasm.__wbg_get_ship_morale(this.ptr);
2322
2487
  return ret;
2323
2488
  }
2324
2489
  /**
2325
- * @returns {number}
2490
+ * @param {number} arg0
2491
+ */
2492
+ set morale(arg0) {
2493
+ wasm.__wbg_set_ship_morale(this.ptr, arg0);
2494
+ }
2495
+ /**
2326
2496
  */
2327
2497
  get ammo() {
2328
2498
  var ret = wasm.__wbg_get_ship_ammo(this.ptr);
2329
2499
  return ret;
2330
2500
  }
2331
2501
  /**
2332
- * @returns {number}
2502
+ * @param {number} arg0
2503
+ */
2504
+ set ammo(arg0) {
2505
+ wasm.__wbg_set_ship_ammo(this.ptr, arg0);
2506
+ }
2507
+ /**
2333
2508
  */
2334
2509
  get fuel() {
2335
2510
  var ret = wasm.__wbg_get_ship_fuel(this.ptr);
2336
2511
  return ret;
2337
2512
  }
2338
2513
  /**
2339
- * @returns {bindings.ShipType}
2514
+ * @param {number} arg0
2515
+ */
2516
+ set fuel(arg0) {
2517
+ wasm.__wbg_set_ship_fuel(this.ptr, arg0);
2518
+ }
2519
+ /**
2340
2520
  */
2341
2521
  get ship_type() {
2342
2522
  var ret = wasm.__wbg_get_ship_ship_type(this.ptr);
2343
2523
  return takeObject(ret);
2344
2524
  }
2345
2525
  /**
2346
- * @returns {bindings.ShipClass}
2526
+ * @param {bindings.ShipType} arg0
2527
+ */
2528
+ set ship_type(arg0) {
2529
+ wasm.__wbg_set_ship_ship_type(this.ptr, addHeapObject(arg0));
2530
+ }
2531
+ /**
2347
2532
  */
2348
2533
  get ship_class() {
2349
2534
  var ret = wasm.__wbg_get_ship_ship_class(this.ptr);
2350
2535
  return takeObject(ret);
2351
2536
  }
2352
2537
  /**
2538
+ * @param {bindings.ShipClass} arg0
2539
+ */
2540
+ set ship_class(arg0) {
2541
+ wasm.__wbg_set_ship_ship_class(this.ptr, addHeapObject(arg0));
2542
+ }
2543
+ /**
2353
2544
  * @returns {number | undefined}
2354
2545
  */
2355
2546
  get naked_firepower() {
@@ -2470,7 +2661,7 @@ class Ship {
2470
2661
  get xxh3() {
2471
2662
  try {
2472
2663
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2473
- wasm.ship_xxh3(retptr, this.ptr);
2664
+ wasm.org_xxh3(retptr, this.ptr);
2474
2665
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2475
2666
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2476
2667
  return getStringFromWasm0(r0, r1);
@@ -2990,11 +3181,6 @@ class Ship {
2990
3181
  }
2991
3182
  module.exports.Ship = Ship;
2992
3183
 
2993
- module.exports.__wbindgen_json_parse = function(arg0, arg1) {
2994
- var ret = JSON.parse(getStringFromWasm0(arg0, arg1));
2995
- return addHeapObject(ret);
2996
- };
2997
-
2998
3184
  module.exports.__wbindgen_json_serialize = function(arg0, arg1) {
2999
3185
  const obj = getObject(arg1);
3000
3186
  var ret = JSON.stringify(obj === undefined ? null : obj);
@@ -3013,6 +3199,15 @@ module.exports.__wbindgen_string_new = function(arg0, arg1) {
3013
3199
  return addHeapObject(ret);
3014
3200
  };
3015
3201
 
3202
+ module.exports.__wbindgen_json_parse = function(arg0, arg1) {
3203
+ var ret = JSON.parse(getStringFromWasm0(arg0, arg1));
3204
+ return addHeapObject(ret);
3205
+ };
3206
+
3207
+ module.exports.__wbg_error_cc38ce2b4b661e1d = function(arg0) {
3208
+ console.error(getObject(arg0));
3209
+ };
3210
+
3016
3211
  module.exports.__wbg_new_693216e109162396 = function() {
3017
3212
  var ret = new Error();
3018
3213
  return addHeapObject(ret);
@@ -3034,19 +3229,15 @@ module.exports.__wbg_error_09919627ac0992f5 = function(arg0, arg1) {
3034
3229
  }
3035
3230
  };
3036
3231
 
3037
- module.exports.__wbg_error_009e67eab9c16665 = function(arg0) {
3038
- console.error(getObject(arg0));
3039
- };
3040
-
3041
- module.exports.__wbg_getRandomValues_98117e9a7e993920 = function() { return handleError(function (arg0, arg1) {
3042
- getObject(arg0).getRandomValues(getObject(arg1));
3232
+ module.exports.__wbg_randomFillSync_59fcc2add91fe7b3 = function() { return handleError(function (arg0, arg1, arg2) {
3233
+ getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
3043
3234
  }, arguments) };
3044
3235
 
3045
- module.exports.__wbg_randomFillSync_64cc7d048f228ca8 = function() { return handleError(function (arg0, arg1, arg2) {
3046
- getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
3236
+ module.exports.__wbg_getRandomValues_3e46aa268da0fed1 = function() { return handleError(function (arg0, arg1) {
3237
+ getObject(arg0).getRandomValues(getObject(arg1));
3047
3238
  }, arguments) };
3048
3239
 
3049
- module.exports.__wbg_process_2f24d6544ea7b200 = function(arg0) {
3240
+ module.exports.__wbg_process_f2b73829dbd321da = function(arg0) {
3050
3241
  var ret = getObject(arg0).process;
3051
3242
  return addHeapObject(ret);
3052
3243
  };
@@ -3057,37 +3248,42 @@ module.exports.__wbindgen_is_object = function(arg0) {
3057
3248
  return ret;
3058
3249
  };
3059
3250
 
3060
- module.exports.__wbg_versions_6164651e75405d4a = function(arg0) {
3251
+ module.exports.__wbg_versions_cd82f79c98672a9f = function(arg0) {
3061
3252
  var ret = getObject(arg0).versions;
3062
3253
  return addHeapObject(ret);
3063
3254
  };
3064
3255
 
3065
- module.exports.__wbg_node_4b517d861cbcb3bc = function(arg0) {
3256
+ module.exports.__wbg_node_ee3f6da4130bd35f = function(arg0) {
3066
3257
  var ret = getObject(arg0).node;
3067
3258
  return addHeapObject(ret);
3068
3259
  };
3069
3260
 
3070
- module.exports.__wbg_modulerequire_3440a4bcf44437db = function() { return handleError(function (arg0, arg1) {
3261
+ module.exports.__wbindgen_is_string = function(arg0) {
3262
+ var ret = typeof(getObject(arg0)) === 'string';
3263
+ return ret;
3264
+ };
3265
+
3266
+ module.exports.__wbg_modulerequire_0a83c0c31d12d2c7 = function() { return handleError(function (arg0, arg1) {
3071
3267
  var ret = module.require(getStringFromWasm0(arg0, arg1));
3072
3268
  return addHeapObject(ret);
3073
3269
  }, arguments) };
3074
3270
 
3075
- module.exports.__wbg_crypto_98fc271021c7d2ad = function(arg0) {
3271
+ module.exports.__wbg_crypto_9e3521ed42436d35 = function(arg0) {
3076
3272
  var ret = getObject(arg0).crypto;
3077
3273
  return addHeapObject(ret);
3078
3274
  };
3079
3275
 
3080
- module.exports.__wbg_msCrypto_a2cdb043d2bfe57f = function(arg0) {
3276
+ module.exports.__wbg_msCrypto_c429c3f8f7a70bb5 = function(arg0) {
3081
3277
  var ret = getObject(arg0).msCrypto;
3082
3278
  return addHeapObject(ret);
3083
3279
  };
3084
3280
 
3085
- module.exports.__wbg_newnoargs_1a11e7e8c906996c = function(arg0, arg1) {
3281
+ module.exports.__wbg_newnoargs_be86524d73f67598 = function(arg0, arg1) {
3086
3282
  var ret = new Function(getStringFromWasm0(arg0, arg1));
3087
3283
  return addHeapObject(ret);
3088
3284
  };
3089
3285
 
3090
- module.exports.__wbg_call_e91f71ddf1f45cff = function() { return handleError(function (arg0, arg1) {
3286
+ module.exports.__wbg_call_888d259a5fefc347 = function() { return handleError(function (arg0, arg1) {
3091
3287
  var ret = getObject(arg0).call(getObject(arg1));
3092
3288
  return addHeapObject(ret);
3093
3289
  }, arguments) };
@@ -3097,27 +3293,27 @@ module.exports.__wbindgen_object_clone_ref = function(arg0) {
3097
3293
  return addHeapObject(ret);
3098
3294
  };
3099
3295
 
3100
- module.exports.__wbg_call_c143b19d87139944 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
3296
+ module.exports.__wbg_call_8a893cac80deeb51 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
3101
3297
  var ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
3102
3298
  return addHeapObject(ret);
3103
3299
  }, arguments) };
3104
3300
 
3105
- module.exports.__wbg_self_b4546ea7b590539e = function() { return handleError(function () {
3301
+ module.exports.__wbg_self_c6fbdfc2918d5e58 = function() { return handleError(function () {
3106
3302
  var ret = self.self;
3107
3303
  return addHeapObject(ret);
3108
3304
  }, arguments) };
3109
3305
 
3110
- module.exports.__wbg_window_c279fea81f426a68 = function() { return handleError(function () {
3306
+ module.exports.__wbg_window_baec038b5ab35c54 = function() { return handleError(function () {
3111
3307
  var ret = window.window;
3112
3308
  return addHeapObject(ret);
3113
3309
  }, arguments) };
3114
3310
 
3115
- module.exports.__wbg_globalThis_038a6ea0ff17789f = function() { return handleError(function () {
3311
+ module.exports.__wbg_globalThis_3f735a5746d41fbd = function() { return handleError(function () {
3116
3312
  var ret = globalThis.globalThis;
3117
3313
  return addHeapObject(ret);
3118
3314
  }, arguments) };
3119
3315
 
3120
- module.exports.__wbg_global_4f93ce884bcee597 = function() { return handleError(function () {
3316
+ module.exports.__wbg_global_1bc0b39582740e95 = function() { return handleError(function () {
3121
3317
  var ret = global.global;
3122
3318
  return addHeapObject(ret);
3123
3319
  }, arguments) };
@@ -3127,40 +3323,35 @@ module.exports.__wbindgen_is_undefined = function(arg0) {
3127
3323
  return ret;
3128
3324
  };
3129
3325
 
3130
- module.exports.__wbg_buffer_79a3294266d4e783 = function(arg0) {
3326
+ module.exports.__wbg_buffer_397eaa4d72ee94dd = function(arg0) {
3131
3327
  var ret = getObject(arg0).buffer;
3132
3328
  return addHeapObject(ret);
3133
3329
  };
3134
3330
 
3135
- module.exports.__wbg_new_945397fb09fec0b8 = function(arg0) {
3331
+ module.exports.__wbg_new_a7ce447f15ff496f = function(arg0) {
3136
3332
  var ret = new Uint8Array(getObject(arg0));
3137
3333
  return addHeapObject(ret);
3138
3334
  };
3139
3335
 
3140
- module.exports.__wbg_set_223873223acf6d07 = function(arg0, arg1, arg2) {
3336
+ module.exports.__wbg_set_969ad0a60e51d320 = function(arg0, arg1, arg2) {
3141
3337
  getObject(arg0).set(getObject(arg1), arg2 >>> 0);
3142
3338
  };
3143
3339
 
3144
- module.exports.__wbg_length_68e13e7bbd918464 = function(arg0) {
3340
+ module.exports.__wbg_length_1eb8fc608a0d4cdb = function(arg0) {
3145
3341
  var ret = getObject(arg0).length;
3146
3342
  return ret;
3147
3343
  };
3148
3344
 
3149
- module.exports.__wbg_newwithlength_b7722b5594f1dc21 = function(arg0) {
3345
+ module.exports.__wbg_newwithlength_929232475839a482 = function(arg0) {
3150
3346
  var ret = new Uint8Array(arg0 >>> 0);
3151
3347
  return addHeapObject(ret);
3152
3348
  };
3153
3349
 
3154
- module.exports.__wbg_subarray_466613921b2fc6db = function(arg0, arg1, arg2) {
3350
+ module.exports.__wbg_subarray_8b658422a224f479 = function(arg0, arg1, arg2) {
3155
3351
  var ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
3156
3352
  return addHeapObject(ret);
3157
3353
  };
3158
3354
 
3159
- module.exports.__wbindgen_is_string = function(arg0) {
3160
- var ret = typeof(getObject(arg0)) === 'string';
3161
- return ret;
3162
- };
3163
-
3164
3355
  module.exports.__wbindgen_debug_string = function(arg0, arg1) {
3165
3356
  var ret = debugString(getObject(arg1));
3166
3357
  var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);