fleethub-core 1.12.11 → 1.12.12

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.
@@ -112,15 +112,10 @@ function isLikeNone(x) {
112
112
  return x === undefined || x === null;
113
113
  }
114
114
 
115
- function getArrayJsValueFromWasm0(ptr, len) {
116
- ptr = ptr >>> 0;
117
- const mem = getDataViewMemory0();
118
- const result = [];
119
- for (let i = ptr; i < ptr + 4 * len; i += 4) {
120
- result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
121
- }
122
- wasm.__externref_drop_slice(ptr, len);
123
- return result;
115
+ function takeFromExternrefTable0(idx) {
116
+ const value = wasm.__wbindgen_export_2.get(idx);
117
+ wasm.__externref_table_dealloc(idx);
118
+ return value;
124
119
  }
125
120
 
126
121
  function _assertClass(instance, klass) {
@@ -129,12 +124,6 @@ function _assertClass(instance, klass) {
129
124
  }
130
125
  }
131
126
 
132
- function takeFromExternrefTable0(idx) {
133
- const value = wasm.__wbindgen_export_2.get(idx);
134
- wasm.__externref_table_dealloc(idx);
135
- return value;
136
- }
137
-
138
127
  let cachedUint16ArrayMemory0 = null;
139
128
 
140
129
  function getUint16ArrayMemory0() {
@@ -144,11 +133,20 @@ function getUint16ArrayMemory0() {
144
133
  return cachedUint16ArrayMemory0;
145
134
  }
146
135
 
147
- function passArray16ToWasm0(arg, malloc) {
148
- const ptr = malloc(arg.length * 2, 2) >>> 0;
149
- getUint16ArrayMemory0().set(arg, ptr / 2);
150
- WASM_VECTOR_LEN = arg.length;
151
- return ptr;
136
+ function getArrayU16FromWasm0(ptr, len) {
137
+ ptr = ptr >>> 0;
138
+ return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
139
+ }
140
+
141
+ function getArrayJsValueFromWasm0(ptr, len) {
142
+ ptr = ptr >>> 0;
143
+ const mem = getDataViewMemory0();
144
+ const result = [];
145
+ for (let i = ptr; i < ptr + 4 * len; i += 4) {
146
+ result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
147
+ }
148
+ wasm.__externref_drop_slice(ptr, len);
149
+ return result;
152
150
  }
153
151
 
154
152
  function passArray8ToWasm0(arg, malloc) {
@@ -157,11 +155,6 @@ function passArray8ToWasm0(arg, malloc) {
157
155
  WASM_VECTOR_LEN = arg.length;
158
156
  return ptr;
159
157
  }
160
-
161
- function getArrayU16FromWasm0(ptr, len) {
162
- ptr = ptr >>> 0;
163
- return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
164
- }
165
158
  /**
166
159
  * @param {ShipConditions} value
167
160
  * @returns {ShipConditions}
@@ -171,6 +164,13 @@ exports.parse_ship_conditions = function(value) {
171
164
  return ret;
172
165
  };
173
166
 
167
+ function passArray16ToWasm0(arg, malloc) {
168
+ const ptr = malloc(arg.length * 2, 2) >>> 0;
169
+ getUint16ArrayMemory0().set(arg, ptr / 2);
170
+ WASM_VECTOR_LEN = arg.length;
171
+ return ptr;
172
+ }
173
+
174
174
  exports.set_panic_hook = function() {
175
175
  wasm.set_panic_hook();
176
176
  };
@@ -200,6 +200,60 @@ class AirSquadron {
200
200
  const ptr = this.__destroy_into_raw();
201
201
  wasm.__wbg_airsquadron_free(ptr, 0);
202
202
  }
203
+ /**
204
+ * @returns {number}
205
+ */
206
+ fighter_power() {
207
+ const ret = wasm.airsquadron_fighter_power(this.__wbg_ptr);
208
+ return ret;
209
+ }
210
+ /**
211
+ * @param {number} index
212
+ * @returns {number}
213
+ */
214
+ get_slot_size(index) {
215
+ const ret = wasm.airsquadron_get_slot_size(this.__wbg_ptr, index);
216
+ if (ret[2]) {
217
+ throw takeFromExternrefTable0(ret[1]);
218
+ }
219
+ return ret[0];
220
+ }
221
+ /**
222
+ * @param {number} index
223
+ * @returns {number}
224
+ */
225
+ get_max_slot_size(index) {
226
+ const ret = wasm.airsquadron_get_max_slot_size(this.__wbg_ptr, index);
227
+ if (ret[2]) {
228
+ throw takeFromExternrefTable0(ret[1]);
229
+ }
230
+ return ret[0];
231
+ }
232
+ /**
233
+ * @returns {number}
234
+ */
235
+ interception_power() {
236
+ const ret = wasm.airsquadron_interception_power(this.__wbg_ptr);
237
+ return ret;
238
+ }
239
+ /**
240
+ * 行動半径
241
+ * @returns {number}
242
+ */
243
+ radius() {
244
+ const ret = wasm.airsquadron_radius(this.__wbg_ptr);
245
+ return ret;
246
+ }
247
+ /**
248
+ * @param {string} key
249
+ * @returns {Gear | undefined}
250
+ */
251
+ get_gear(key) {
252
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
253
+ const len0 = WASM_VECTOR_LEN;
254
+ const ret = wasm.airsquadron_get_gear(this.__wbg_ptr, ptr0, len0);
255
+ return ret === 0 ? undefined : Gear.__wrap(ret);
256
+ }
203
257
  /**
204
258
  * @returns {string}
205
259
  */
@@ -249,60 +303,6 @@ class AirSquadron {
249
303
  set mode(arg0) {
250
304
  wasm.__wbg_set_airsquadron_mode(this.__wbg_ptr, arg0);
251
305
  }
252
- /**
253
- * @param {string} key
254
- * @returns {Gear | undefined}
255
- */
256
- get_gear(key) {
257
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
258
- const len0 = WASM_VECTOR_LEN;
259
- const ret = wasm.airsquadron_get_gear(this.__wbg_ptr, ptr0, len0);
260
- return ret === 0 ? undefined : Gear.__wrap(ret);
261
- }
262
- /**
263
- * @param {number} index
264
- * @returns {number}
265
- */
266
- get_slot_size(index) {
267
- const ret = wasm.airsquadron_get_slot_size(this.__wbg_ptr, index);
268
- if (ret[2]) {
269
- throw takeFromExternrefTable0(ret[1]);
270
- }
271
- return ret[0];
272
- }
273
- /**
274
- * @param {number} index
275
- * @returns {number}
276
- */
277
- get_max_slot_size(index) {
278
- const ret = wasm.airsquadron_get_max_slot_size(this.__wbg_ptr, index);
279
- if (ret[2]) {
280
- throw takeFromExternrefTable0(ret[1]);
281
- }
282
- return ret[0];
283
- }
284
- /**
285
- * @returns {number}
286
- */
287
- fighter_power() {
288
- const ret = wasm.airsquadron_fighter_power(this.__wbg_ptr);
289
- return ret;
290
- }
291
- /**
292
- * @returns {number}
293
- */
294
- interception_power() {
295
- const ret = wasm.airsquadron_interception_power(this.__wbg_ptr);
296
- return ret;
297
- }
298
- /**
299
- * 行動半径
300
- * @returns {number}
301
- */
302
- radius() {
303
- const ret = wasm.airsquadron_radius(this.__wbg_ptr);
304
- return ret;
305
- }
306
306
  }
307
307
  if (Symbol.dispose) AirSquadron.prototype[Symbol.dispose] = AirSquadron.prototype.free;
308
308
 
@@ -334,16 +334,13 @@ class Analyzer {
334
334
  wasm.__wbg_analyzer_free(ptr, 0);
335
335
  }
336
336
  /**
337
- * @param {ShipAnalyzerConfig} config
338
- * @param {Ship} left
339
- * @param {Ship} right
340
- * @param {boolean} attacker_is_left
341
- * @returns {AttackAnalysis}
337
+ * @param {Comp} comp
338
+ * @param {CompAnalyzerConfig} config
339
+ * @returns {CompAnalysis}
342
340
  */
343
- analyze_ship_attack(config, left, right, attacker_is_left) {
344
- _assertClass(left, Ship);
345
- _assertClass(right, Ship);
346
- const ret = wasm.analyzer_analyze_ship_attack(this.__wbg_ptr, config, left.__wbg_ptr, right.__wbg_ptr, attacker_is_left);
341
+ analyze_comp(comp, config) {
342
+ _assertClass(comp, Comp);
343
+ const ret = wasm.analyzer_analyze_comp(this.__wbg_ptr, comp.__wbg_ptr, config);
347
344
  return ret;
348
345
  }
349
346
  /**
@@ -363,13 +360,16 @@ class Analyzer {
363
360
  return ret;
364
361
  }
365
362
  /**
366
- * @param {Comp} comp
367
- * @param {CompAnalyzerConfig} config
368
- * @returns {CompAnalysis}
363
+ * @param {ShipAnalyzerConfig} config
364
+ * @param {Ship} left
365
+ * @param {Ship} right
366
+ * @param {boolean} attacker_is_left
367
+ * @returns {AttackAnalysis}
369
368
  */
370
- analyze_comp(comp, config) {
371
- _assertClass(comp, Comp);
372
- const ret = wasm.analyzer_analyze_comp(this.__wbg_ptr, comp.__wbg_ptr, config);
369
+ analyze_ship_attack(config, left, right, attacker_is_left) {
370
+ _assertClass(left, Ship);
371
+ _assertClass(right, Ship);
372
+ const ret = wasm.analyzer_analyze_ship_attack(this.__wbg_ptr, config, left.__wbg_ptr, right.__wbg_ptr, attacker_is_left);
373
373
  return ret;
374
374
  }
375
375
  /**
@@ -501,13 +501,6 @@ class Comp {
501
501
  }
502
502
  wasm.__wbg_set_comp_boss_sup(this.__wbg_ptr, ptr0);
503
503
  }
504
- /**
505
- * @returns {Side}
506
- */
507
- side() {
508
- const ret = wasm.comp_side(this.__wbg_ptr);
509
- return ret;
510
- }
511
504
  /**
512
505
  * @returns {boolean}
513
506
  */
@@ -516,18 +509,17 @@ class Comp {
516
509
  return ret !== 0;
517
510
  }
518
511
  /**
519
- * @returns {boolean}
520
- */
521
- is_player() {
522
- const ret = wasm.comp_is_player(this.__wbg_ptr);
523
- return ret !== 0;
524
- }
525
- /**
526
- * @returns {boolean}
512
+ * @param {FleetType} ft
513
+ * @returns {string | undefined}
527
514
  */
528
- is_enemy() {
529
- const ret = wasm.comp_is_enemy(this.__wbg_ptr);
530
- return ret !== 0;
515
+ get_fleet_id(ft) {
516
+ const ret = wasm.comp_get_fleet_id(this.__wbg_ptr, ft);
517
+ let v1;
518
+ if (ret[0] !== 0) {
519
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
520
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
521
+ }
522
+ return v1;
531
523
  }
532
524
  /**
533
525
  * @param {string} id
@@ -539,6 +531,16 @@ class Comp {
539
531
  const ret = wasm.comp_has_ship_eid(this.__wbg_ptr, ptr0, len0);
540
532
  return ret !== 0;
541
533
  }
534
+ /**
535
+ * 制空値
536
+ * @param {boolean} escort_participates
537
+ * @param {AirWaveType} air_type
538
+ * @returns {number | undefined}
539
+ */
540
+ fighter_power(escort_participates, air_type) {
541
+ const ret = wasm.comp_fighter_power(this.__wbg_ptr, escort_participates, air_type);
542
+ return ret === 0x100000001 ? undefined : ret;
543
+ }
542
544
  /**
543
545
  * @returns {string | undefined}
544
546
  */
@@ -551,6 +553,14 @@ class Comp {
551
553
  }
552
554
  return v1;
553
555
  }
556
+ /**
557
+ * @param {FleetType} fleet_type
558
+ * @returns {number | undefined}
559
+ */
560
+ fleet_los_mod(fleet_type) {
561
+ const ret = wasm.comp_fleet_los_mod(this.__wbg_ptr, fleet_type);
562
+ return ret[0] === 0 ? undefined : ret[1];
563
+ }
554
564
  /**
555
565
  * @returns {boolean}
556
566
  */
@@ -559,33 +569,28 @@ class Comp {
559
569
  return ret !== 0;
560
570
  }
561
571
  /**
562
- * @returns {CompMeta}
572
+ * 輸送物資量(TP)
573
+ * @returns {number}
563
574
  */
564
- meta() {
565
- const ret = wasm.comp_meta(this.__wbg_ptr);
575
+ transport_point() {
576
+ const ret = wasm.comp_transport_point(this.__wbg_ptr);
566
577
  return ret;
567
578
  }
568
579
  /**
569
- * @param {FleetType} ft
570
- * @returns {string | undefined}
580
+ * 艦隊防空値
581
+ * @param {number} formation_mod
582
+ * @returns {number}
571
583
  */
572
- get_fleet_id(ft) {
573
- const ret = wasm.comp_get_fleet_id(this.__wbg_ptr, ft);
574
- let v1;
575
- if (ret[0] !== 0) {
576
- v1 = getStringFromWasm0(ret[0], ret[1]).slice();
577
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
578
- }
579
- return v1;
580
- }
581
- /**
582
- * @param {FleetType} ft
583
- * @param {ShipKey} key
584
- * @returns {Ship | undefined}
584
+ adjusted_anti_air(formation_mod) {
585
+ const ret = wasm.comp_adjusted_anti_air(this.__wbg_ptr, formation_mod);
586
+ return ret;
587
+ }
588
+ /**
589
+ * @returns {Formation}
585
590
  */
586
- get_ship_with_clone(ft, key) {
587
- const ret = wasm.comp_get_ship_with_clone(this.__wbg_ptr, ft, key);
588
- return ret === 0 ? undefined : Ship.__wrap(ret);
591
+ default_formation() {
592
+ const ret = wasm.comp_default_formation(this.__wbg_ptr);
593
+ return ret;
589
594
  }
590
595
  /**
591
596
  * @param {FleetType} ft
@@ -602,40 +607,33 @@ class Comp {
602
607
  return v1;
603
608
  }
604
609
  /**
605
- * @param {string} id
606
- * @returns {Ship | undefined}
607
- */
608
- get_ship_by_eid_with_clone(id) {
609
- const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
610
- const len0 = WASM_VECTOR_LEN;
611
- const ret = wasm.comp_get_ship_by_eid_with_clone(this.__wbg_ptr, ptr0, len0);
612
- return ret === 0 ? undefined : Ship.__wrap(ret);
613
- }
614
- /**
615
- * @returns {Formation}
610
+ * @param {Ship} ship
611
+ * @param {Formation | null} [formation]
612
+ * @returns {ShipConditions}
616
613
  */
617
- default_formation() {
618
- const ret = wasm.comp_default_formation(this.__wbg_ptr);
614
+ get_ship_conditions(ship, formation) {
615
+ _assertClass(ship, Ship);
616
+ const ret = wasm.comp_get_ship_conditions(this.__wbg_ptr, ship.__wbg_ptr, isLikeNone(formation) ? 0 : addToExternrefTable0(formation));
619
617
  return ret;
620
618
  }
621
619
  /**
622
- * 艦隊防空値
623
- * @param {number} formation_mod
624
- * @returns {number}
620
+ * @param {FleetType} ft
621
+ * @param {ShipKey} key
622
+ * @returns {Ship | undefined}
625
623
  */
626
- adjusted_anti_air(formation_mod) {
627
- const ret = wasm.comp_adjusted_anti_air(this.__wbg_ptr, formation_mod);
628
- return ret;
624
+ get_ship_with_clone(ft, key) {
625
+ const ret = wasm.comp_get_ship_with_clone(this.__wbg_ptr, ft, key);
626
+ return ret === 0 ? undefined : Ship.__wrap(ret);
629
627
  }
630
628
  /**
631
- * 制空値
632
- * @param {boolean} escort_participates
633
- * @param {AirWaveType} air_type
634
- * @returns {number | undefined}
629
+ * @param {string} id
630
+ * @returns {Ship | undefined}
635
631
  */
636
- fighter_power(escort_participates, air_type) {
637
- const ret = wasm.comp_fighter_power(this.__wbg_ptr, escort_participates, air_type);
638
- return ret === 0x100000001 ? undefined : ret;
632
+ get_ship_by_eid_with_clone(id) {
633
+ const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
634
+ const len0 = WASM_VECTOR_LEN;
635
+ const ret = wasm.comp_get_ship_by_eid_with_clone(this.__wbg_ptr, ptr0, len0);
636
+ return ret === 0 ? undefined : Ship.__wrap(ret);
639
637
  }
640
638
  /**
641
639
  * マップ索敵
@@ -647,31 +645,19 @@ class Comp {
647
645
  return ret[0] === 0 ? undefined : ret[1];
648
646
  }
649
647
  /**
650
- * 輸送物資量(TP)
651
- * @returns {number}
648
+ * @returns {CompMeta}
652
649
  */
653
- transport_point() {
654
- const ret = wasm.comp_transport_point(this.__wbg_ptr);
650
+ meta() {
651
+ const ret = wasm.comp_meta(this.__wbg_ptr);
655
652
  return ret;
656
653
  }
657
654
  /**
658
- * @param {Ship} ship
659
- * @param {Formation | null} [formation]
660
- * @returns {ShipConditions}
655
+ * @returns {Side}
661
656
  */
662
- get_ship_conditions(ship, formation) {
663
- _assertClass(ship, Ship);
664
- const ret = wasm.comp_get_ship_conditions(this.__wbg_ptr, ship.__wbg_ptr, isLikeNone(formation) ? 0 : addToExternrefTable0(formation));
657
+ side() {
658
+ const ret = wasm.comp_side(this.__wbg_ptr);
665
659
  return ret;
666
660
  }
667
- /**
668
- * @param {FleetType} fleet_type
669
- * @returns {number | undefined}
670
- */
671
- fleet_los_mod(fleet_type) {
672
- const ret = wasm.comp_fleet_los_mod(this.__wbg_ptr, fleet_type);
673
- return ret[0] === 0 ? undefined : ret[1];
674
- }
675
661
  /**
676
662
  * @returns {number}
677
663
  */
@@ -679,6 +665,20 @@ class Comp {
679
665
  const ret = wasm.comp_balloons(this.__wbg_ptr);
680
666
  return ret >>> 0;
681
667
  }
668
+ /**
669
+ * @returns {boolean}
670
+ */
671
+ is_enemy() {
672
+ const ret = wasm.comp_is_enemy(this.__wbg_ptr);
673
+ return ret !== 0;
674
+ }
675
+ /**
676
+ * @returns {boolean}
677
+ */
678
+ is_player() {
679
+ const ret = wasm.comp_is_player(this.__wbg_ptr);
680
+ return ret !== 0;
681
+ }
682
682
  }
683
683
  if (Symbol.dispose) Comp.prototype[Symbol.dispose] = Comp.prototype.free;
684
684
 
@@ -702,16 +702,12 @@ class FhCore {
702
702
  wasm.__wbg_fhcore_free(ptr, 0);
703
703
  }
704
704
  /**
705
- * @param {MasterData} js_master
705
+ * @param {OrgState | null} [input]
706
+ * @returns {Org | undefined}
706
707
  */
707
- constructor(js_master) {
708
- const ret = wasm.fhcore_new(js_master);
709
- if (ret[2]) {
710
- throw takeFromExternrefTable0(ret[1]);
711
- }
712
- this.__wbg_ptr = ret[0] >>> 0;
713
- FhCoreFinalization.register(this, this.__wbg_ptr, this);
714
- return this;
708
+ create_org(input) {
709
+ const ret = wasm.fhcore_create_org(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
710
+ return ret === 0 ? undefined : Org.__wrap(ret);
715
711
  }
716
712
  /**
717
713
  * @param {GearState | null} [input]
@@ -729,14 +725,6 @@ class FhCore {
729
725
  const ret = wasm.fhcore_create_ship(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
730
726
  return ret === 0 ? undefined : Ship.__wrap(ret);
731
727
  }
732
- /**
733
- * @param {AirSquadronState | null} [input]
734
- * @returns {AirSquadron}
735
- */
736
- create_air_squadron(input) {
737
- const ret = wasm.fhcore_create_air_squadron(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
738
- return AirSquadron.__wrap(ret);
739
- }
740
728
  /**
741
729
  * @param {FleetState | null} [input]
742
730
  * @returns {Fleet}
@@ -746,19 +734,17 @@ class FhCore {
746
734
  return Fleet.__wrap(ret);
747
735
  }
748
736
  /**
749
- * @param {OrgState | null} [input]
750
- * @returns {Org | undefined}
737
+ * @returns {Analyzer}
751
738
  */
752
- create_org(input) {
753
- const ret = wasm.fhcore_create_org(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
754
- return ret === 0 ? undefined : Org.__wrap(ret);
739
+ create_analyzer() {
740
+ const ret = wasm.fhcore_create_analyzer(this.__wbg_ptr);
741
+ return Analyzer.__wrap(ret);
755
742
  }
756
743
  /**
757
- * @param {number} ship_id
758
- * @returns {ShipState | undefined}
744
+ * @returns {Ship[]}
759
745
  */
760
- create_ship_state_by_id(ship_id) {
761
- const ret = wasm.fhcore_create_ship_state_by_id(this.__wbg_ptr, ship_id);
746
+ create_all_ships() {
747
+ const ret = wasm.fhcore_create_all_ships(this.__wbg_ptr);
762
748
  return ret;
763
749
  }
764
750
  /**
@@ -770,10 +756,26 @@ class FhCore {
770
756
  return ret === 0 ? undefined : Ship.__wrap(ret);
771
757
  }
772
758
  /**
773
- * @returns {Ship[]}
759
+ * @param {AirSquadronState | null} [input]
760
+ * @returns {AirSquadron}
774
761
  */
775
- create_all_ships() {
776
- const ret = wasm.fhcore_create_all_ships(this.__wbg_ptr);
762
+ create_air_squadron(input) {
763
+ const ret = wasm.fhcore_create_air_squadron(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
764
+ return AirSquadron.__wrap(ret);
765
+ }
766
+ /**
767
+ * @returns {Ship}
768
+ */
769
+ create_default_ship() {
770
+ const ret = wasm.fhcore_create_default_ship(this.__wbg_ptr);
771
+ return Ship.__wrap(ret);
772
+ }
773
+ /**
774
+ * @param {number} ship_id
775
+ * @returns {ShipState | undefined}
776
+ */
777
+ create_ship_state_by_id(ship_id) {
778
+ const ret = wasm.fhcore_create_ship_state_by_id(this.__wbg_ptr, ship_id);
777
779
  return ret;
778
780
  }
779
781
  /**
@@ -790,18 +792,16 @@ class FhCore {
790
792
  return Comp.__wrap(ret);
791
793
  }
792
794
  /**
793
- * @returns {Ship}
794
- */
795
- create_default_ship() {
796
- const ret = wasm.fhcore_create_default_ship(this.__wbg_ptr);
797
- return Ship.__wrap(ret);
798
- }
799
- /**
800
- * @returns {Analyzer}
795
+ * @param {MasterData} js_master
801
796
  */
802
- create_analyzer() {
803
- const ret = wasm.fhcore_create_analyzer(this.__wbg_ptr);
804
- return Analyzer.__wrap(ret);
797
+ constructor(js_master) {
798
+ const ret = wasm.fhcore_new(js_master);
799
+ if (ret[2]) {
800
+ throw takeFromExternrefTable0(ret[1]);
801
+ }
802
+ this.__wbg_ptr = ret[0] >>> 0;
803
+ FhCoreFinalization.register(this, this.__wbg_ptr, this);
804
+ return this;
805
805
  }
806
806
  }
807
807
  if (Symbol.dispose) FhCore.prototype[Symbol.dispose] = FhCore.prototype.free;
@@ -871,47 +871,34 @@ class Fleet {
871
871
  return ret >>> 0;
872
872
  }
873
873
  /**
874
- * @returns {FleetMeta}
875
- */
876
- meta() {
877
- const ret = wasm.fleet_meta(this.__wbg_ptr);
878
- return ret;
879
- }
880
- /**
881
- * @returns {string[]}
874
+ * @returns {number}
882
875
  */
883
- ship_keys() {
884
- const ret = wasm.fleet_ship_keys(this.__wbg_ptr);
885
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
886
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
887
- return v1;
876
+ count_ships() {
877
+ const ret = wasm.fleet_count_ships(this.__wbg_ptr);
878
+ return ret >>> 0;
888
879
  }
889
880
  /**
890
- * @returns {string[]}
881
+ * @param {AirWaveType} air_type
882
+ * @returns {number | undefined}
891
883
  */
892
- ship_ids() {
893
- const ret = wasm.fleet_ship_ids(this.__wbg_ptr);
894
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
895
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
896
- return v1;
884
+ fighter_power(air_type) {
885
+ const ret = wasm.fleet_fighter_power(this.__wbg_ptr, air_type);
886
+ return ret === 0x100000001 ? undefined : ret;
897
887
  }
898
888
  /**
899
- * @returns {string[]}
889
+ * @returns {number | undefined}
900
890
  */
901
- get_gear_ids_by_improvable() {
902
- const ret = wasm.fleet_get_gear_ids_by_improvable(this.__wbg_ptr);
903
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
904
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
905
- return v1;
891
+ get fleet_los_mod() {
892
+ const ret = wasm.fleet_fleet_los_mod(this.__wbg_ptr);
893
+ return ret[0] === 0 ? undefined : ret[1];
906
894
  }
907
895
  /**
908
- * @returns {string[]}
896
+ * 遠征ボーナス
897
+ * @returns {number}
909
898
  */
910
- get_gear_ids_by_proficiency() {
911
- const ret = wasm.fleet_get_gear_ids_by_proficiency(this.__wbg_ptr);
912
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
913
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
914
- return v1;
899
+ expedition_bonus() {
900
+ const ret = wasm.fleet_expedition_bonus(this.__wbg_ptr);
901
+ return ret;
915
902
  }
916
903
  /**
917
904
  * @param {string} id
@@ -924,16 +911,26 @@ class Fleet {
924
911
  const ret = wasm.fleet_get_damage_bound(this.__wbg_ptr, ptr0, len0, state);
925
912
  return ret === 0xFFFFFF ? undefined : ret;
926
913
  }
914
+ /**
915
+ * @param {string} key
916
+ * @returns {number | undefined}
917
+ */
918
+ sum_ship_stat_by(key) {
919
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
920
+ const len0 = WASM_VECTOR_LEN;
921
+ const ret = wasm.fleet_sum_ship_stat_by(this.__wbg_ptr, ptr0, len0);
922
+ return ret[0] === 0 ? undefined : ret[1];
923
+ }
927
924
  /**
928
925
  * @param {string} id
929
926
  * @param {number} rate
930
927
  * @param {boolean} ceil
931
928
  * @returns {number | undefined}
932
929
  */
933
- get_remaining_fuel(id, rate, ceil) {
930
+ get_remaining_ammo(id, rate, ceil) {
934
931
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
935
932
  const len0 = WASM_VECTOR_LEN;
936
- const ret = wasm.fleet_get_remaining_fuel(this.__wbg_ptr, ptr0, len0, rate, ceil);
933
+ const ret = wasm.fleet_get_remaining_ammo(this.__wbg_ptr, ptr0, len0, rate, ceil);
937
934
  return ret === 0xFFFFFF ? undefined : ret;
938
935
  }
939
936
  /**
@@ -942,41 +939,40 @@ class Fleet {
942
939
  * @param {boolean} ceil
943
940
  * @returns {number | undefined}
944
941
  */
945
- get_remaining_ammo(id, rate, ceil) {
942
+ get_remaining_fuel(id, rate, ceil) {
946
943
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
947
944
  const len0 = WASM_VECTOR_LEN;
948
- const ret = wasm.fleet_get_remaining_ammo(this.__wbg_ptr, ptr0, len0, rate, ceil);
945
+ const ret = wasm.fleet_get_remaining_fuel(this.__wbg_ptr, ptr0, len0, rate, ceil);
949
946
  return ret === 0xFFFFFF ? undefined : ret;
950
947
  }
951
- /**
952
- * @returns {number}
953
- */
954
- count_ships() {
955
- const ret = wasm.fleet_count_ships(this.__wbg_ptr);
956
- return ret >>> 0;
957
- }
958
- /**
959
- * @param {ShipKey} key
960
- * @returns {Ship | undefined}
961
- */
962
- get_ship(key) {
963
- const ret = wasm.fleet_get_ship(this.__wbg_ptr, key);
964
- return ret === 0 ? undefined : Ship.__wrap(ret);
948
+ reset_battle_state() {
949
+ wasm.fleet_reset_battle_state(this.__wbg_ptr);
965
950
  }
966
951
  /**
952
+ * 航空索敵スコア
967
953
  * @returns {number | undefined}
968
954
  */
969
- get fleet_los_mod() {
970
- const ret = wasm.fleet_fleet_los_mod(this.__wbg_ptr);
955
+ aviation_detection_score() {
956
+ const ret = wasm.fleet_aviation_detection_score(this.__wbg_ptr);
971
957
  return ret[0] === 0 ? undefined : ret[1];
972
958
  }
973
959
  /**
974
- * @param {AirWaveType} air_type
975
- * @returns {number | undefined}
960
+ * @returns {string[]}
976
961
  */
977
- fighter_power(air_type) {
978
- const ret = wasm.fleet_fighter_power(this.__wbg_ptr, air_type);
979
- return ret === 0x100000001 ? undefined : ret;
962
+ get_gear_ids_by_improvable() {
963
+ const ret = wasm.fleet_get_gear_ids_by_improvable(this.__wbg_ptr);
964
+ var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
965
+ wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
966
+ return v1;
967
+ }
968
+ /**
969
+ * @returns {string[]}
970
+ */
971
+ get_gear_ids_by_proficiency() {
972
+ const ret = wasm.fleet_get_gear_ids_by_proficiency(this.__wbg_ptr);
973
+ var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
974
+ wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
975
+ return v1;
980
976
  }
981
977
  /**
982
978
  * マップ索敵
@@ -989,33 +985,37 @@ class Fleet {
989
985
  return ret[0] === 0 ? undefined : ret[1];
990
986
  }
991
987
  /**
992
- * 航空索敵スコア
993
- * @returns {number | undefined}
988
+ * @returns {FleetMeta}
994
989
  */
995
- aviation_detection_score() {
996
- const ret = wasm.fleet_aviation_detection_score(this.__wbg_ptr);
997
- return ret[0] === 0 ? undefined : ret[1];
990
+ meta() {
991
+ const ret = wasm.fleet_meta(this.__wbg_ptr);
992
+ return ret;
998
993
  }
999
994
  /**
1000
- * 遠征ボーナス
1001
- * @returns {number}
995
+ * @param {ShipKey} key
996
+ * @returns {Ship | undefined}
1002
997
  */
1003
- expedition_bonus() {
1004
- const ret = wasm.fleet_expedition_bonus(this.__wbg_ptr);
1005
- return ret;
998
+ get_ship(key) {
999
+ const ret = wasm.fleet_get_ship(this.__wbg_ptr, key);
1000
+ return ret === 0 ? undefined : Ship.__wrap(ret);
1006
1001
  }
1007
1002
  /**
1008
- * @param {string} key
1009
- * @returns {number | undefined}
1003
+ * @returns {string[]}
1010
1004
  */
1011
- sum_ship_stat_by(key) {
1012
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1013
- const len0 = WASM_VECTOR_LEN;
1014
- const ret = wasm.fleet_sum_ship_stat_by(this.__wbg_ptr, ptr0, len0);
1015
- return ret[0] === 0 ? undefined : ret[1];
1005
+ ship_ids() {
1006
+ const ret = wasm.fleet_ship_ids(this.__wbg_ptr);
1007
+ var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
1008
+ wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
1009
+ return v1;
1016
1010
  }
1017
- reset_battle_state() {
1018
- wasm.fleet_reset_battle_state(this.__wbg_ptr);
1011
+ /**
1012
+ * @returns {string[]}
1013
+ */
1014
+ ship_keys() {
1015
+ const ret = wasm.fleet_ship_keys(this.__wbg_ptr);
1016
+ var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
1017
+ wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
1018
+ return v1;
1019
1019
  }
1020
1020
  }
1021
1021
  if (Symbol.dispose) Fleet.prototype[Symbol.dispose] = Fleet.prototype.free;
@@ -1279,118 +1279,111 @@ class Gear {
1279
1279
  return ret;
1280
1280
  }
1281
1281
  /**
1282
- * @returns {Gear}
1283
- */
1284
- static default() {
1285
- const ret = wasm.gear_default();
1286
- return Gear.__wrap(ret);
1287
- }
1288
- /**
1289
- * @returns {number}
1290
- */
1291
- get gear_type_id() {
1292
- const ret = wasm.gear_gear_type_id(this.__wbg_ptr);
1293
- return ret;
1294
- }
1295
- /**
1296
- * @returns {number}
1297
- */
1298
- get special_type() {
1299
- const ret = wasm.gear_special_type(this.__wbg_ptr);
1300
- return ret;
1301
- }
1302
- /**
1303
- * @returns {number}
1282
+ * @returns {boolean}
1304
1283
  */
1305
- get icon_id() {
1306
- const ret = wasm.gear_icon_id(this.__wbg_ptr);
1307
- return ret;
1284
+ is_abyssal() {
1285
+ const ret = wasm.gear_is_abyssal(this.__wbg_ptr);
1286
+ return ret !== 0;
1308
1287
  }
1309
1288
  /**
1310
- * @param {GearAttr} attr
1311
1289
  * @returns {boolean}
1312
1290
  */
1313
- has_attr(attr) {
1314
- const ret = wasm.gear_has_attr(this.__wbg_ptr, attr);
1291
+ is_balloon() {
1292
+ const ret = wasm.gear_is_balloon(this.__wbg_ptr);
1315
1293
  return ret !== 0;
1316
1294
  }
1317
1295
  /**
1318
- * @returns {GearCategory}
1296
+ * @returns {number}
1319
1297
  */
1320
- category() {
1321
- const ret = wasm.gear_category(this.__wbg_ptr);
1298
+ get anti_bomber() {
1299
+ const ret = wasm.gear_anti_bomber(this.__wbg_ptr);
1322
1300
  return ret;
1323
1301
  }
1324
1302
  /**
1325
1303
  * @returns {number}
1326
1304
  */
1327
- get ace() {
1328
- const ret = wasm.gear_ace(this.__wbg_ptr);
1305
+ get gear_type_id() {
1306
+ const ret = wasm.gear_gear_type_id(this.__wbg_ptr);
1329
1307
  return ret;
1330
1308
  }
1331
1309
  /**
1332
1310
  * @returns {number}
1333
1311
  */
1334
- get anti_bomber() {
1335
- const ret = wasm.gear_anti_bomber(this.__wbg_ptr);
1312
+ get interception() {
1313
+ const ret = wasm.gear_interception(this.__wbg_ptr);
1336
1314
  return ret;
1337
1315
  }
1338
1316
  /**
1339
1317
  * @returns {number}
1340
1318
  */
1341
- get interception() {
1342
- const ret = wasm.gear_interception(this.__wbg_ptr);
1319
+ get special_type() {
1320
+ const ret = wasm.gear_special_type(this.__wbg_ptr);
1343
1321
  return ret;
1344
1322
  }
1345
1323
  /**
1346
1324
  * @returns {boolean}
1347
1325
  */
1348
- is_high_angle_mount() {
1349
- const ret = wasm.gear_is_high_angle_mount(this.__wbg_ptr);
1326
+ is_night_plane() {
1327
+ const ret = wasm.gear_is_night_plane(this.__wbg_ptr);
1350
1328
  return ret !== 0;
1351
1329
  }
1352
1330
  /**
1353
1331
  * @returns {boolean}
1354
1332
  */
1355
- is_carrier_shelling_plane() {
1356
- const ret = wasm.gear_is_carrier_shelling_plane(this.__wbg_ptr);
1333
+ max_exp_eq_120() {
1334
+ const ret = wasm.gear_max_exp_eq_120(this.__wbg_ptr);
1357
1335
  return ret !== 0;
1358
1336
  }
1359
1337
  /**
1360
1338
  * @returns {boolean}
1361
1339
  */
1362
- is_hayabusa_20th_squadron() {
1363
- const ret = wasm.gear_is_hayabusa_20th_squadron(this.__wbg_ptr);
1340
+ has_proficiency() {
1341
+ const ret = wasm.gear_can_be_deployed_to_land_base(this.__wbg_ptr);
1364
1342
  return ret !== 0;
1365
1343
  }
1344
+ /**
1345
+ * @returns {number}
1346
+ */
1347
+ expedition_bonus() {
1348
+ const ret = wasm.gear_expedition_bonus(this.__wbg_ptr);
1349
+ return ret;
1350
+ }
1366
1351
  /**
1367
1352
  * @returns {boolean}
1368
1353
  */
1369
- has_proficiency() {
1370
- const ret = wasm.gear_can_be_deployed_to_land_base(this.__wbg_ptr);
1354
+ is_night_fighter() {
1355
+ const ret = wasm.gear_is_night_fighter(this.__wbg_ptr);
1371
1356
  return ret !== 0;
1372
1357
  }
1373
1358
  /**
1374
1359
  * @returns {boolean}
1375
1360
  */
1376
- max_exp_eq_120() {
1377
- const ret = wasm.gear_max_exp_eq_120(this.__wbg_ptr);
1361
+ is_night_attacker() {
1362
+ const ret = wasm.gear_is_night_attacker(this.__wbg_ptr);
1378
1363
  return ret !== 0;
1379
1364
  }
1380
1365
  /**
1381
1366
  * @param {number} slot_size
1367
+ * @param {boolean} anti_inst
1382
1368
  * @returns {number}
1383
1369
  */
1384
- calc_fighter_power(slot_size) {
1385
- const ret = wasm.gear_calc_fighter_power(this.__wbg_ptr, slot_size);
1370
+ night_plane_power(slot_size, anti_inst) {
1371
+ const ret = wasm.gear_night_plane_power(this.__wbg_ptr, slot_size, anti_inst);
1372
+ return ret;
1373
+ }
1374
+ /**
1375
+ * @returns {number}
1376
+ */
1377
+ ship_anti_air_mod() {
1378
+ const ret = wasm.gear_ship_anti_air_mod(this.__wbg_ptr);
1386
1379
  return ret;
1387
1380
  }
1388
1381
  /**
1389
1382
  * @param {number} slot_size
1390
1383
  * @returns {number}
1391
1384
  */
1392
- calc_interception_power(slot_size) {
1393
- const ret = wasm.gear_calc_interception_power(this.__wbg_ptr, slot_size);
1385
+ calc_fighter_power(slot_size) {
1386
+ const ret = wasm.gear_calc_fighter_power(this.__wbg_ptr, slot_size);
1394
1387
  return ret;
1395
1388
  }
1396
1389
  /**
@@ -1401,19 +1394,19 @@ class Gear {
1401
1394
  return ret;
1402
1395
  }
1403
1396
  /**
1397
+ * @param {number} level
1404
1398
  * @returns {number}
1405
1399
  */
1406
- ship_anti_air_mod() {
1407
- const ret = wasm.gear_ship_anti_air_mod(this.__wbg_ptr);
1400
+ night_contact_rate(level) {
1401
+ const ret = wasm.gear_night_contact_rate(this.__wbg_ptr, level);
1408
1402
  return ret;
1409
1403
  }
1410
1404
  /**
1411
- * @param {number} slot_size
1412
- * @returns {number}
1405
+ * @returns {boolean}
1413
1406
  */
1414
- calc_contact_trigger_factor(slot_size) {
1415
- const ret = wasm.gear_calc_contact_trigger_factor(this.__wbg_ptr, slot_size);
1416
- return ret;
1407
+ is_high_angle_mount() {
1408
+ const ret = wasm.gear_is_high_angle_mount(this.__wbg_ptr);
1409
+ return ret !== 0;
1417
1410
  }
1418
1411
  /**
1419
1412
  * @param {AirStateRank} rank
@@ -1424,55 +1417,40 @@ class Gear {
1424
1417
  return ret;
1425
1418
  }
1426
1419
  /**
1427
- * @param {number} level
1420
+ * @param {number} slot_size
1428
1421
  * @returns {number}
1429
1422
  */
1430
- night_contact_rate(level) {
1431
- const ret = wasm.gear_night_contact_rate(this.__wbg_ptr, level);
1423
+ calc_interception_power(slot_size) {
1424
+ const ret = wasm.gear_calc_interception_power(this.__wbg_ptr, slot_size);
1432
1425
  return ret;
1433
1426
  }
1434
1427
  /**
1435
1428
  * @returns {boolean}
1436
1429
  */
1437
- is_night_attacker() {
1438
- const ret = wasm.gear_is_night_attacker(this.__wbg_ptr);
1439
- return ret !== 0;
1440
- }
1441
- /**
1442
- * @returns {boolean}
1443
- */
1444
- is_night_fighter() {
1445
- const ret = wasm.gear_is_night_fighter(this.__wbg_ptr);
1430
+ is_carrier_shelling_plane() {
1431
+ const ret = wasm.gear_is_carrier_shelling_plane(this.__wbg_ptr);
1446
1432
  return ret !== 0;
1447
1433
  }
1448
1434
  /**
1449
1435
  * @returns {boolean}
1450
1436
  */
1451
- is_night_plane() {
1452
- const ret = wasm.gear_is_night_plane(this.__wbg_ptr);
1437
+ is_hayabusa_20th_squadron() {
1438
+ const ret = wasm.gear_is_hayabusa_20th_squadron(this.__wbg_ptr);
1453
1439
  return ret !== 0;
1454
1440
  }
1455
1441
  /**
1456
1442
  * @param {number} slot_size
1457
- * @param {boolean} anti_inst
1458
- * @returns {number}
1459
- */
1460
- night_plane_power(slot_size, anti_inst) {
1461
- const ret = wasm.gear_night_plane_power(this.__wbg_ptr, slot_size, anti_inst);
1462
- return ret;
1463
- }
1464
- /**
1465
1443
  * @returns {number}
1466
1444
  */
1467
- elos() {
1468
- const ret = wasm.gear_elos(this.__wbg_ptr);
1445
+ calc_contact_trigger_factor(slot_size) {
1446
+ const ret = wasm.gear_calc_contact_trigger_factor(this.__wbg_ptr, slot_size);
1469
1447
  return ret;
1470
1448
  }
1471
1449
  /**
1472
1450
  * @returns {boolean}
1473
1451
  */
1474
- is_abyssal() {
1475
- const ret = wasm.gear_is_abyssal(this.__wbg_ptr);
1452
+ can_be_deployed_to_land_base() {
1453
+ const ret = wasm.gear_can_be_deployed_to_land_base(this.__wbg_ptr);
1476
1454
  return ret !== 0;
1477
1455
  }
1478
1456
  /**
@@ -1492,22 +1470,44 @@ class Gear {
1492
1470
  /**
1493
1471
  * @returns {number}
1494
1472
  */
1495
- expedition_bonus() {
1496
- const ret = wasm.gear_expedition_bonus(this.__wbg_ptr);
1473
+ get ace() {
1474
+ const ret = wasm.gear_ace(this.__wbg_ptr);
1497
1475
  return ret;
1498
1476
  }
1499
1477
  /**
1500
- * @returns {boolean}
1478
+ * @returns {number}
1501
1479
  */
1502
- can_be_deployed_to_land_base() {
1503
- const ret = wasm.gear_can_be_deployed_to_land_base(this.__wbg_ptr);
1504
- return ret !== 0;
1480
+ elos() {
1481
+ const ret = wasm.gear_elos(this.__wbg_ptr);
1482
+ return ret;
1483
+ }
1484
+ /**
1485
+ * @returns {Gear}
1486
+ */
1487
+ static default() {
1488
+ const ret = wasm.gear_default();
1489
+ return Gear.__wrap(ret);
1490
+ }
1491
+ /**
1492
+ * @returns {number}
1493
+ */
1494
+ get icon_id() {
1495
+ const ret = wasm.gear_icon_id(this.__wbg_ptr);
1496
+ return ret;
1497
+ }
1498
+ /**
1499
+ * @returns {GearCategory}
1500
+ */
1501
+ category() {
1502
+ const ret = wasm.gear_category(this.__wbg_ptr);
1503
+ return ret;
1505
1504
  }
1506
1505
  /**
1506
+ * @param {GearAttr} attr
1507
1507
  * @returns {boolean}
1508
1508
  */
1509
- is_balloon() {
1510
- const ret = wasm.gear_is_balloon(this.__wbg_ptr);
1509
+ has_attr(attr) {
1510
+ const ret = wasm.gear_has_attr(this.__wbg_ptr, attr);
1511
1511
  return ret !== 0;
1512
1512
  }
1513
1513
  }
@@ -1606,39 +1606,35 @@ class Org {
1606
1606
  return ret;
1607
1607
  }
1608
1608
  /**
1609
- * @returns {string | undefined}
1609
+ * @param {FleetKey} fleet_key
1610
+ * @param {ShipKey} ship_key
1611
+ * @returns {Ship | undefined}
1610
1612
  */
1611
- first_ship_id() {
1612
- const ret = wasm.org_first_ship_id(this.__wbg_ptr);
1613
- let v1;
1614
- if (ret[0] !== 0) {
1615
- v1 = getStringFromWasm0(ret[0], ret[1]).slice();
1616
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1617
- }
1618
- return v1;
1613
+ clone_ship(fleet_key, ship_key) {
1614
+ const ret = wasm.org_clone_ship(this.__wbg_ptr, fleet_key, ship_key);
1615
+ return ret === 0 ? undefined : Ship.__wrap(ret);
1619
1616
  }
1620
1617
  /**
1621
- * @param {FleetKey} fleet_key
1622
- * @param {ShipKey} ship_key
1623
- * @returns {number | undefined}
1618
+ * @param {FleetKey} key
1619
+ * @returns {Fleet}
1624
1620
  */
1625
- get_ship_mid(fleet_key, ship_key) {
1626
- const ret = wasm.org_get_ship_mid(this.__wbg_ptr, fleet_key, ship_key);
1627
- return ret === 0xFFFFFF ? undefined : ret;
1621
+ clone_fleet(key) {
1622
+ const ret = wasm.org_clone_fleet(this.__wbg_ptr, key);
1623
+ return Fleet.__wrap(ret);
1628
1624
  }
1629
1625
  /**
1630
- * @param {FleetKey} fleet_key
1631
- * @param {ShipKey} ship_key
1632
- * @returns {string | undefined}
1626
+ * @returns {Comp}
1633
1627
  */
1634
- get_ship_eid(fleet_key, ship_key) {
1635
- const ret = wasm.org_get_ship_eid(this.__wbg_ptr, fleet_key, ship_key);
1636
- let v1;
1637
- if (ret[0] !== 0) {
1638
- v1 = getStringFromWasm0(ret[0], ret[1]).slice();
1639
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1640
- }
1641
- return v1;
1628
+ create_comp() {
1629
+ const ret = wasm.org_create_comp(this.__wbg_ptr);
1630
+ return Comp.__wrap(ret);
1631
+ }
1632
+ /**
1633
+ * @returns {boolean}
1634
+ */
1635
+ is_combined() {
1636
+ const ret = wasm.org_is_combined(this.__wbg_ptr);
1637
+ return ret !== 0;
1642
1638
  }
1643
1639
  /**
1644
1640
  * @param {FleetKey} key
@@ -1657,48 +1653,56 @@ class Org {
1657
1653
  }
1658
1654
  }
1659
1655
  /**
1660
- * @returns {string[]}
1656
+ * @param {FleetKey} fleet_key
1657
+ * @param {ShipKey} ship_key
1658
+ * @returns {string | undefined}
1661
1659
  */
1662
- air_squadron_ids() {
1663
- const ret = wasm.org_air_squadron_ids(this.__wbg_ptr);
1664
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
1665
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
1660
+ get_ship_eid(fleet_key, ship_key) {
1661
+ const ret = wasm.org_get_ship_eid(this.__wbg_ptr, fleet_key, ship_key);
1662
+ let v1;
1663
+ if (ret[0] !== 0) {
1664
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
1665
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1666
+ }
1666
1667
  return v1;
1667
1668
  }
1668
1669
  /**
1669
- * @returns {Uint16Array}
1670
+ * @param {FleetKey} fleet_key
1671
+ * @param {ShipKey} ship_key
1672
+ * @returns {number | undefined}
1670
1673
  */
1671
- main_ship_ids() {
1672
- const ret = wasm.org_main_ship_ids(this.__wbg_ptr);
1673
- var v1 = getArrayU16FromWasm0(ret[0], ret[1]).slice();
1674
- wasm.__wbindgen_free(ret[0], ret[1] * 2, 2);
1674
+ get_ship_mid(fleet_key, ship_key) {
1675
+ const ret = wasm.org_get_ship_mid(this.__wbg_ptr, fleet_key, ship_key);
1676
+ return ret === 0xFFFFFF ? undefined : ret;
1677
+ }
1678
+ /**
1679
+ * @returns {string | undefined}
1680
+ */
1681
+ first_ship_id() {
1682
+ const ret = wasm.org_first_ship_id(this.__wbg_ptr);
1683
+ let v1;
1684
+ if (ret[0] !== 0) {
1685
+ v1 = getStringFromWasm0(ret[0], ret[1]).slice();
1686
+ wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1687
+ }
1675
1688
  return v1;
1676
1689
  }
1677
1690
  /**
1678
1691
  * @returns {Uint16Array}
1679
1692
  */
1680
- escort_ship_ids() {
1681
- const ret = wasm.org_escort_ship_ids(this.__wbg_ptr);
1693
+ main_ship_ids() {
1694
+ const ret = wasm.org_main_ship_ids(this.__wbg_ptr);
1682
1695
  var v1 = getArrayU16FromWasm0(ret[0], ret[1]).slice();
1683
1696
  wasm.__wbindgen_free(ret[0], ret[1] * 2, 2);
1684
1697
  return v1;
1685
1698
  }
1686
1699
  /**
1687
1700
  * @param {FleetKey} key
1688
- * @returns {Fleet}
1689
- */
1690
- clone_fleet(key) {
1691
- const ret = wasm.org_clone_fleet(this.__wbg_ptr, key);
1692
- return Fleet.__wrap(ret);
1693
- }
1694
- /**
1695
- * @param {FleetKey} fleet_key
1696
- * @param {ShipKey} ship_key
1697
- * @returns {Ship | undefined}
1701
+ * @returns {FleetType | undefined}
1698
1702
  */
1699
- clone_ship(fleet_key, ship_key) {
1700
- const ret = wasm.org_clone_ship(this.__wbg_ptr, fleet_key, ship_key);
1701
- return ret === 0 ? undefined : Ship.__wrap(ret);
1703
+ get_fleet_type(key) {
1704
+ const ret = wasm.org_get_fleet_type(this.__wbg_ptr, key);
1705
+ return ret;
1702
1706
  }
1703
1707
  /**
1704
1708
  * @param {string} id
@@ -1711,21 +1715,35 @@ class Org {
1711
1715
  return ret === 0 ? undefined : Ship.__wrap(ret);
1712
1716
  }
1713
1717
  /**
1714
- * @param {FleetKey} key
1718
+ * @returns {Uint16Array}
1719
+ */
1720
+ escort_ship_ids() {
1721
+ const ret = wasm.org_escort_ship_ids(this.__wbg_ptr);
1722
+ var v1 = getArrayU16FromWasm0(ret[0], ret[1]).slice();
1723
+ wasm.__wbindgen_free(ret[0], ret[1] * 2, 2);
1724
+ return v1;
1725
+ }
1726
+ /**
1715
1727
  * @returns {string[]}
1716
1728
  */
1717
- ship_keys(key) {
1718
- const ret = wasm.org_ship_keys(this.__wbg_ptr, key);
1729
+ air_squadron_ids() {
1730
+ const ret = wasm.org_air_squadron_ids(this.__wbg_ptr);
1719
1731
  var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
1720
1732
  wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
1721
1733
  return v1;
1722
1734
  }
1723
1735
  /**
1724
- * @returns {Comp}
1736
+ * @param {string} key
1737
+ * @returns {AirSquadron}
1725
1738
  */
1726
- create_comp() {
1727
- const ret = wasm.org_create_comp(this.__wbg_ptr);
1728
- return Comp.__wrap(ret);
1739
+ get_air_squadron(key) {
1740
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1741
+ const len0 = WASM_VECTOR_LEN;
1742
+ const ret = wasm.org_get_air_squadron(this.__wbg_ptr, ptr0, len0);
1743
+ if (ret[2]) {
1744
+ throw takeFromExternrefTable0(ret[1]);
1745
+ }
1746
+ return AirSquadron.__wrap(ret[0]);
1729
1747
  }
1730
1748
  /**
1731
1749
  * @param {FleetKey} key
@@ -1736,17 +1754,32 @@ class Org {
1736
1754
  return Comp.__wrap(ret);
1737
1755
  }
1738
1756
  /**
1739
- * @param {string} key
1740
- * @returns {AirSquadron}
1757
+ * 防空時の基地制空値
1758
+ * @returns {number}
1741
1759
  */
1742
- get_air_squadron(key) {
1743
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1760
+ interception_power() {
1761
+ const ret = wasm.org_interception_power(this.__wbg_ptr);
1762
+ return ret;
1763
+ }
1764
+ /**
1765
+ * @param {string} id
1766
+ * @param {number} x
1767
+ * @param {number} y
1768
+ * @returns {MoveShipPayload | undefined}
1769
+ */
1770
+ create_move_ship_payload(id, x, y) {
1771
+ const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1744
1772
  const len0 = WASM_VECTOR_LEN;
1745
- const ret = wasm.org_get_air_squadron(this.__wbg_ptr, ptr0, len0);
1746
- if (ret[2]) {
1747
- throw takeFromExternrefTable0(ret[1]);
1748
- }
1749
- return AirSquadron.__wrap(ret[0]);
1773
+ const ret = wasm.org_create_move_ship_payload(this.__wbg_ptr, ptr0, len0, x, y);
1774
+ return ret;
1775
+ }
1776
+ /**
1777
+ * 高高度迎撃時の基地制空値
1778
+ * @returns {number}
1779
+ */
1780
+ high_altitude_interception_power() {
1781
+ const ret = wasm.org_high_altitude_interception_power(this.__wbg_ptr);
1782
+ return ret;
1750
1783
  }
1751
1784
  /**
1752
1785
  * @returns {string[]}
@@ -1773,13 +1806,6 @@ class Org {
1773
1806
  const ret = wasm.org_side(this.__wbg_ptr);
1774
1807
  return ret;
1775
1808
  }
1776
- /**
1777
- * @returns {boolean}
1778
- */
1779
- is_player() {
1780
- const ret = wasm.org_is_player(this.__wbg_ptr);
1781
- return ret !== 0;
1782
- }
1783
1809
  /**
1784
1810
  * @returns {boolean}
1785
1811
  */
@@ -1790,52 +1816,26 @@ class Org {
1790
1816
  /**
1791
1817
  * @returns {boolean}
1792
1818
  */
1793
- is_single() {
1794
- const ret = wasm.org_is_single(this.__wbg_ptr);
1819
+ is_player() {
1820
+ const ret = wasm.org_is_player(this.__wbg_ptr);
1795
1821
  return ret !== 0;
1796
1822
  }
1797
1823
  /**
1798
1824
  * @returns {boolean}
1799
1825
  */
1800
- is_combined() {
1801
- const ret = wasm.org_is_combined(this.__wbg_ptr);
1826
+ is_single() {
1827
+ const ret = wasm.org_is_single(this.__wbg_ptr);
1802
1828
  return ret !== 0;
1803
1829
  }
1804
- /**
1805
- * 防空時の基地制空値
1806
- * @returns {number}
1807
- */
1808
- interception_power() {
1809
- const ret = wasm.org_interception_power(this.__wbg_ptr);
1810
- return ret;
1811
- }
1812
- /**
1813
- * 高高度迎撃時の基地制空値
1814
- * @returns {number}
1815
- */
1816
- high_altitude_interception_power() {
1817
- const ret = wasm.org_high_altitude_interception_power(this.__wbg_ptr);
1818
- return ret;
1819
- }
1820
- /**
1821
- * @param {string} id
1822
- * @param {number} x
1823
- * @param {number} y
1824
- * @returns {MoveShipPayload | undefined}
1825
- */
1826
- create_move_ship_payload(id, x, y) {
1827
- const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1828
- const len0 = WASM_VECTOR_LEN;
1829
- const ret = wasm.org_create_move_ship_payload(this.__wbg_ptr, ptr0, len0, x, y);
1830
- return ret;
1831
- }
1832
1830
  /**
1833
1831
  * @param {FleetKey} key
1834
- * @returns {FleetType | undefined}
1832
+ * @returns {string[]}
1835
1833
  */
1836
- get_fleet_type(key) {
1837
- const ret = wasm.org_get_fleet_type(this.__wbg_ptr, key);
1838
- return ret;
1834
+ ship_keys(key) {
1835
+ const ret = wasm.org_ship_keys(this.__wbg_ptr, key);
1836
+ var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
1837
+ wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
1838
+ return v1;
1839
1839
  }
1840
1840
  }
1841
1841
  if (Symbol.dispose) Org.prototype[Symbol.dispose] = Org.prototype.free;
@@ -1867,6 +1867,29 @@ class Ship {
1867
1867
  const ptr = this.__destroy_into_raw();
1868
1868
  wasm.__wbg_ship_free(ptr, 0);
1869
1869
  }
1870
+ /**
1871
+ * フィット砲補正
1872
+ * @param {boolean} is_night
1873
+ * @returns {number}
1874
+ */
1875
+ gunfit_accuracy(is_night) {
1876
+ const ret = wasm.ship_gunfit_accuracy(this.__wbg_ptr, is_night);
1877
+ return ret;
1878
+ }
1879
+ /**
1880
+ * @returns {number | undefined}
1881
+ */
1882
+ state_day_gunfit_accuracy() {
1883
+ const ret = wasm.ship_state_day_gunfit_accuracy(this.__wbg_ptr);
1884
+ return ret[0] === 0 ? undefined : ret[1];
1885
+ }
1886
+ /**
1887
+ * @returns {number | undefined}
1888
+ */
1889
+ state_night_gunfit_accuracy() {
1890
+ const ret = wasm.ship_state_night_gunfit_accuracy(this.__wbg_ptr);
1891
+ return ret[0] === 0 ? undefined : ret[1];
1892
+ }
1870
1893
  /**
1871
1894
  * @returns {string}
1872
1895
  */
@@ -1967,18 +1990,36 @@ class Ship {
1967
1990
  wasm.__wbg_set_ship_slots(this.__wbg_ptr, arg0);
1968
1991
  }
1969
1992
  /**
1970
- * @returns {number | undefined}
1993
+ * @param {string} key
1994
+ * @returns {number}
1971
1995
  */
1972
- get naked_firepower() {
1973
- const ret = wasm.ship_naked_firepower(this.__wbg_ptr);
1974
- return ret === 0xFFFFFF ? undefined : ret;
1996
+ get_ebonus(key) {
1997
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1998
+ const len0 = WASM_VECTOR_LEN;
1999
+ const ret = wasm.ship_get_ebonus(this.__wbg_ptr, ptr0, len0);
2000
+ return ret;
1975
2001
  }
1976
2002
  /**
1977
- * @returns {number | undefined}
2003
+ * @returns {boolean}
1978
2004
  */
1979
- get naked_torpedo() {
1980
- const ret = wasm.ship_naked_torpedo(this.__wbg_ptr);
1981
- return ret === 0xFFFFFF ? undefined : ret;
2005
+ is_abyssal() {
2006
+ const ret = wasm.ship_is_abyssal(this.__wbg_ptr);
2007
+ return ret !== 0;
2008
+ }
2009
+ /**
2010
+ * @returns {boolean}
2011
+ */
2012
+ is_amagiri() {
2013
+ const ret = wasm.ship_is_amagiri(this.__wbg_ptr);
2014
+ return ret !== 0;
2015
+ }
2016
+ /**
2017
+ * 確殺攻撃力
2018
+ * @returns {number | undefined}
2019
+ */
2020
+ ohko_power() {
2021
+ const ret = wasm.ship_ohko_power(this.__wbg_ptr);
2022
+ return ret[0] === 0 ? undefined : ret[1];
1982
2023
  }
1983
2024
  /**
1984
2025
  * @returns {number | undefined}
@@ -1990,102 +2031,173 @@ class Ship {
1990
2031
  /**
1991
2032
  * @returns {number | undefined}
1992
2033
  */
1993
- get naked_anti_air() {
1994
- const ret = wasm.ship_naked_anti_air(this.__wbg_ptr);
2034
+ get naked_range() {
2035
+ const ret = wasm.ship_naked_range(this.__wbg_ptr);
1995
2036
  return ret === 0xFFFFFF ? undefined : ret;
1996
2037
  }
1997
2038
  /**
2039
+ * @returns {number}
2040
+ */
2041
+ get naked_speed() {
2042
+ const ret = wasm.ship_naked_speed(this.__wbg_ptr);
2043
+ return ret;
2044
+ }
2045
+ /**
2046
+ * @returns {DamageState}
2047
+ */
2048
+ damage_state() {
2049
+ const ret = wasm.ship_damage_state(this.__wbg_ptr);
2050
+ return ret;
2051
+ }
2052
+ /**
2053
+ * @param {number} formation_mod
2054
+ * @param {number} postcap_additive
2055
+ * @param {number} postcap_multiplicative
1998
2056
  * @returns {number | undefined}
1999
2057
  */
2000
- get naked_evasion() {
2001
- const ret = wasm.ship_naked_evasion(this.__wbg_ptr);
2002
- return ret === 0xFFFFFF ? undefined : ret;
2058
+ evasion_term(formation_mod, postcap_additive, postcap_multiplicative) {
2059
+ const ret = wasm.ship_evasion_term(this.__wbg_ptr, formation_mod, postcap_additive, postcap_multiplicative);
2060
+ return ret[0] === 0 ? undefined : ret[1];
2003
2061
  }
2004
2062
  /**
2063
+ * @param {string} key
2005
2064
  * @returns {number | undefined}
2006
2065
  */
2007
- get naked_asw() {
2008
- const ret = wasm.ship_naked_asw(this.__wbg_ptr);
2066
+ get_stat_mod(key) {
2067
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2068
+ const len0 = WASM_VECTOR_LEN;
2069
+ const ret = wasm.ship_get_stat_mod(this.__wbg_ptr, ptr0, len0);
2009
2070
  return ret === 0xFFFFFF ? undefined : ret;
2010
2071
  }
2011
2072
  /**
2073
+ * @returns {boolean}
2074
+ */
2075
+ is_submarine() {
2076
+ const ret = wasm.ship_is_submarine(this.__wbg_ptr);
2077
+ return ret !== 0;
2078
+ }
2079
+ /**
2080
+ * @returns {MoraleState}
2081
+ */
2082
+ morale_state() {
2083
+ const ret = wasm.ship_morale_state(this.__wbg_ptr);
2084
+ return ret;
2085
+ }
2086
+ /**
2087
+ * @returns {number}
2088
+ */
2089
+ get remodel_rank() {
2090
+ const ret = wasm.ship_remodel_rank(this.__wbg_ptr);
2091
+ return ret;
2092
+ }
2093
+ /**
2094
+ * @param {AirWaveType} air_type
2012
2095
  * @returns {number | undefined}
2013
2096
  */
2014
- get naked_los() {
2015
- const ret = wasm.ship_naked_los(this.__wbg_ptr);
2016
- return ret === 0xFFFFFF ? undefined : ret;
2097
+ fighter_power(air_type) {
2098
+ const ret = wasm.ship_fighter_power(this.__wbg_ptr, air_type);
2099
+ return ret === 0x100000001 ? undefined : ret;
2100
+ }
2101
+ /**
2102
+ * @param {string} key
2103
+ * @returns {number}
2104
+ */
2105
+ get_gear_stat(key) {
2106
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2107
+ const len0 = WASM_VECTOR_LEN;
2108
+ const ret = wasm.ship_get_gear_stat(this.__wbg_ptr, ptr0, len0);
2109
+ return ret;
2017
2110
  }
2018
2111
  /**
2112
+ * @param {number} index
2019
2113
  * @returns {number | undefined}
2020
2114
  */
2021
- get firepower() {
2022
- const ret = wasm.ship_firepower(this.__wbg_ptr);
2115
+ get_slot_size(index) {
2116
+ const ret = wasm.ship_get_slot_size(this.__wbg_ptr, index);
2023
2117
  return ret === 0xFFFFFF ? undefined : ret;
2024
2118
  }
2025
2119
  /**
2026
2120
  * @returns {number | undefined}
2027
2121
  */
2028
- get torpedo() {
2029
- const ret = wasm.ship_torpedo(this.__wbg_ptr);
2122
+ get naked_evasion() {
2123
+ const ret = wasm.ship_naked_evasion(this.__wbg_ptr);
2030
2124
  return ret === 0xFFFFFF ? undefined : ret;
2031
2125
  }
2032
2126
  /**
2033
2127
  * @returns {number | undefined}
2034
2128
  */
2035
- get armor() {
2036
- const ret = wasm.ship_armor(this.__wbg_ptr);
2129
+ get naked_torpedo() {
2130
+ const ret = wasm.ship_naked_torpedo(this.__wbg_ptr);
2037
2131
  return ret === 0xFFFFFF ? undefined : ret;
2038
2132
  }
2039
2133
  /**
2134
+ * @param {string} key
2040
2135
  * @returns {number | undefined}
2041
2136
  */
2042
- get anti_air() {
2043
- const ret = wasm.ship_anti_air(this.__wbg_ptr);
2137
+ get_naked_stat(key) {
2138
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2139
+ const len0 = WASM_VECTOR_LEN;
2140
+ const ret = wasm.ship_get_naked_stat(this.__wbg_ptr, ptr0, len0);
2044
2141
  return ret === 0xFFFFFF ? undefined : ret;
2045
2142
  }
2046
2143
  /**
2047
2144
  * @returns {number | undefined}
2048
2145
  */
2049
- get evasion() {
2050
- const ret = wasm.ship_evasion(this.__wbg_ptr);
2146
+ get naked_anti_air() {
2147
+ const ret = wasm.ship_naked_anti_air(this.__wbg_ptr);
2051
2148
  return ret === 0xFFFFFF ? undefined : ret;
2052
2149
  }
2150
+ /**
2151
+ * @returns {boolean}
2152
+ */
2153
+ is_installation() {
2154
+ const ret = wasm.ship_is_installation(this.__wbg_ptr);
2155
+ return ret !== 0;
2156
+ }
2053
2157
  /**
2054
2158
  * @returns {number | undefined}
2055
2159
  */
2056
- get asw() {
2057
- const ret = wasm.ship_asw(this.__wbg_ptr);
2160
+ get naked_firepower() {
2161
+ const ret = wasm.ship_naked_firepower(this.__wbg_ptr);
2058
2162
  return ret === 0xFFFFFF ? undefined : ret;
2059
2163
  }
2164
+ /**
2165
+ * @returns {number}
2166
+ */
2167
+ transport_point() {
2168
+ const ret = wasm.ship_transport_point(this.__wbg_ptr);
2169
+ return ret;
2170
+ }
2060
2171
  /**
2061
2172
  * @returns {number | undefined}
2062
2173
  */
2063
- get los() {
2064
- const ret = wasm.ship_los(this.__wbg_ptr);
2065
- return ret === 0xFFFFFF ? undefined : ret;
2174
+ fleet_los_factor() {
2175
+ const ret = wasm.ship_fleet_los_factor(this.__wbg_ptr);
2176
+ return ret[0] === 0 ? undefined : ret[1];
2066
2177
  }
2067
2178
  /**
2068
- * @returns {Ship}
2179
+ * @param {DamageState} state
2180
+ * @returns {number | undefined}
2069
2181
  */
2070
- static default() {
2071
- const ret = wasm.ship_default();
2072
- return Ship.__wrap(ret);
2182
+ get_damage_bound(state) {
2183
+ const ret = wasm.ship_get_damage_bound(this.__wbg_ptr, state);
2184
+ return ret === 0xFFFFFF ? undefined : ret;
2073
2185
  }
2074
2186
  /**
2075
- * @param {string} id
2187
+ * @param {string} key
2076
2188
  * @returns {boolean}
2077
2189
  */
2078
- eq_id(id) {
2079
- const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2190
+ has_unknown_stat(key) {
2191
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2080
2192
  const len0 = WASM_VECTOR_LEN;
2081
- const ret = wasm.ship_eq_id(this.__wbg_ptr, ptr0, len0);
2193
+ const ret = wasm.ship_has_unknown_stat(this.__wbg_ptr, ptr0, len0);
2082
2194
  return ret !== 0;
2083
2195
  }
2084
2196
  /**
2085
- * @returns {ShipState}
2197
+ * @returns {number}
2086
2198
  */
2087
- state() {
2088
- const ret = wasm.ship_state(this.__wbg_ptr);
2199
+ cruiser_fit_bonus() {
2200
+ const ret = wasm.ship_cruiser_fit_bonus(this.__wbg_ptr);
2089
2201
  return ret;
2090
2202
  }
2091
2203
  /**
@@ -2096,187 +2208,100 @@ class Ship {
2096
2208
  return ret;
2097
2209
  }
2098
2210
  /**
2099
- * @returns {ShipMeta}
2100
- */
2101
- meta() {
2102
- const ret = wasm.ship_meta(this.__wbg_ptr);
2103
- return ret;
2104
- }
2105
- /**
2106
- * @returns {string}
2211
+ * @param {number} index
2212
+ * @returns {number | undefined}
2107
2213
  */
2108
- get name() {
2109
- let deferred1_0;
2110
- let deferred1_1;
2111
- try {
2112
- const ret = wasm.ship_name(this.__wbg_ptr);
2113
- deferred1_0 = ret[0];
2114
- deferred1_1 = ret[1];
2115
- return getStringFromWasm0(ret[0], ret[1]);
2116
- } finally {
2117
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
2118
- }
2214
+ get_max_slot_size(index) {
2215
+ const ret = wasm.ship_get_max_slot_size(this.__wbg_ptr, index);
2216
+ return ret === 0xFFFFFF ? undefined : ret;
2119
2217
  }
2120
2218
  /**
2121
- * @returns {string}
2219
+ * @returns {number | undefined}
2122
2220
  */
2123
- get yomi() {
2124
- let deferred1_0;
2125
- let deferred1_1;
2126
- try {
2127
- const ret = wasm.ship_yomi(this.__wbg_ptr);
2128
- deferred1_0 = ret[0];
2129
- deferred1_1 = ret[1];
2130
- return getStringFromWasm0(ret[0], ret[1]);
2131
- } finally {
2132
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
2133
- }
2221
+ basic_evasion_term() {
2222
+ const ret = wasm.ship_basic_evasion_term(this.__wbg_ptr);
2223
+ return ret[0] === 0 ? undefined : ret[1];
2134
2224
  }
2135
2225
  /**
2226
+ * 艦隊対空補正
2136
2227
  * @returns {number}
2137
2228
  */
2138
- get stype() {
2139
- const ret = wasm.ship_stype(this.__wbg_ptr);
2229
+ fleet_anti_air_mod() {
2230
+ const ret = wasm.ship_fleet_anti_air_mod(this.__wbg_ptr);
2140
2231
  return ret;
2141
2232
  }
2142
2233
  /**
2234
+ * @param {number} rate
2235
+ * @param {boolean} ceil
2143
2236
  * @returns {number}
2144
2237
  */
2145
- get sort_id() {
2146
- const ret = wasm.ship_sort_id(this.__wbg_ptr);
2238
+ get_remaining_ammo(rate, ceil) {
2239
+ const ret = wasm.ship_get_remaining_ammo(this.__wbg_ptr, rate, ceil);
2147
2240
  return ret;
2148
2241
  }
2149
2242
  /**
2243
+ * @param {number} rate
2244
+ * @param {boolean} ceil
2150
2245
  * @returns {number}
2151
2246
  */
2152
- get remodel_rank() {
2153
- const ret = wasm.ship_remodel_rank(this.__wbg_ptr);
2247
+ get_remaining_fuel(rate, ceil) {
2248
+ const ret = wasm.ship_get_remaining_fuel(this.__wbg_ptr, rate, ceil);
2154
2249
  return ret;
2155
2250
  }
2156
2251
  /**
2157
2252
  * @returns {number}
2158
2253
  */
2159
- get slotnum() {
2160
- const ret = wasm.ship_slotnum(this.__wbg_ptr);
2161
- return ret >>> 0;
2254
+ remaining_ammo_mod() {
2255
+ const ret = wasm.ship_remaining_ammo_mod(this.__wbg_ptr);
2256
+ return ret;
2162
2257
  }
2163
2258
  /**
2164
2259
  * @returns {number}
2165
2260
  */
2166
- get next_id() {
2167
- const ret = wasm.ship_next_id(this.__wbg_ptr);
2261
+ remaining_fuel_mod() {
2262
+ const ret = wasm.ship_remaining_fuel_mod(this.__wbg_ptr);
2168
2263
  return ret;
2169
2264
  }
2170
2265
  /**
2171
- * @returns {boolean}
2266
+ * @returns {SpecialEnemyType}
2172
2267
  */
2173
- get useful() {
2174
- const ret = wasm.ship_useful(this.__wbg_ptr);
2175
- return ret !== 0;
2268
+ special_enemy_type() {
2269
+ const ret = wasm.ship_special_enemy_type(this.__wbg_ptr);
2270
+ return ret;
2176
2271
  }
2177
2272
  /**
2178
- * @returns {DamageState}
2273
+ * @returns {number | undefined}
2179
2274
  */
2180
- damage_state() {
2181
- const ret = wasm.ship_damage_state(this.__wbg_ptr);
2182
- return ret;
2275
+ basic_accuracy_term() {
2276
+ const ret = wasm.ship_basic_accuracy_term(this.__wbg_ptr);
2277
+ return ret[0] === 0 ? undefined : ret[1];
2183
2278
  }
2184
2279
  /**
2185
- * @returns {MoraleState}
2280
+ * @param {number} armor_penetration
2281
+ * @returns {number | undefined}
2186
2282
  */
2187
- morale_state() {
2188
- const ret = wasm.ship_morale_state(this.__wbg_ptr);
2189
- return ret;
2190
- }
2191
- /**
2192
- * @returns {ShipCategory}
2193
- */
2194
- category() {
2195
- const ret = wasm.ship_category(this.__wbg_ptr);
2196
- return ret;
2197
- }
2198
- /**
2199
- * @param {ShipAttr} attr
2200
- * @returns {boolean}
2201
- */
2202
- has_attr(attr) {
2203
- const ret = wasm.ship_has_attr(this.__wbg_ptr, attr);
2204
- return ret !== 0;
2205
- }
2206
- /**
2207
- * @returns {string[]}
2208
- */
2209
- gear_keys() {
2210
- const ret = wasm.ship_gear_keys(this.__wbg_ptr);
2211
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
2212
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
2213
- return v1;
2214
- }
2215
- /**
2216
- * @param {string} key
2217
- * @returns {Gear | undefined}
2218
- */
2219
- get_gear(key) {
2220
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2221
- const len0 = WASM_VECTOR_LEN;
2222
- const ret = wasm.ship_get_gear(this.__wbg_ptr, ptr0, len0);
2223
- return ret === 0 ? undefined : Gear.__wrap(ret);
2224
- }
2225
- /**
2226
- * @param {DamageState} state
2227
- * @returns {number | undefined}
2228
- */
2229
- get_damage_bound(state) {
2230
- const ret = wasm.ship_get_damage_bound(this.__wbg_ptr, state);
2231
- return ret === 0xFFFFFF ? undefined : ret;
2232
- }
2233
- /**
2234
- * @param {number} rate
2235
- * @param {boolean} ceil
2236
- * @returns {number}
2237
- */
2238
- get_remaining_fuel(rate, ceil) {
2239
- const ret = wasm.ship_get_remaining_fuel(this.__wbg_ptr, rate, ceil);
2240
- return ret;
2241
- }
2242
- /**
2243
- * @param {number} rate
2244
- * @param {boolean} ceil
2245
- * @returns {number}
2246
- */
2247
- get_remaining_ammo(rate, ceil) {
2248
- const ret = wasm.ship_get_remaining_ammo(this.__wbg_ptr, rate, ceil);
2249
- return ret;
2250
- }
2251
- /**
2252
- * @param {string} key
2253
- * @returns {boolean}
2254
- */
2255
- has_unknown_stat(key) {
2256
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2257
- const len0 = WASM_VECTOR_LEN;
2258
- const ret = wasm.ship_has_unknown_stat(this.__wbg_ptr, ptr0, len0);
2259
- return ret !== 0;
2283
+ basic_defense_power(armor_penetration) {
2284
+ const ret = wasm.ship_basic_defense_power(this.__wbg_ptr, armor_penetration);
2285
+ return ret[0] === 0 ? undefined : ret[1];
2260
2286
  }
2261
2287
  /**
2262
2288
  * @param {string} key
2263
2289
  * @returns {number | undefined}
2264
2290
  */
2265
- get_naked_stat(key) {
2291
+ get_stat_interval_left(key) {
2266
2292
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2267
2293
  const len0 = WASM_VECTOR_LEN;
2268
- const ret = wasm.ship_get_naked_stat(this.__wbg_ptr, ptr0, len0);
2294
+ const ret = wasm.ship_get_stat_interval_left(this.__wbg_ptr, ptr0, len0);
2269
2295
  return ret === 0xFFFFFF ? undefined : ret;
2270
2296
  }
2271
2297
  /**
2272
- * @param {string} key
2298
+ * 加重対空
2299
+ * @param {Side} side
2273
2300
  * @returns {number | undefined}
2274
2301
  */
2275
- get_stat_interval_left(key) {
2276
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2277
- const len0 = WASM_VECTOR_LEN;
2278
- const ret = wasm.ship_get_stat_interval_left(this.__wbg_ptr, ptr0, len0);
2279
- return ret === 0xFFFFFF ? undefined : ret;
2302
+ ship_adjusted_anti_air(side) {
2303
+ const ret = wasm.ship_ship_adjusted_anti_air(this.__wbg_ptr, side);
2304
+ return ret[0] === 0 ? undefined : ret[1];
2280
2305
  }
2281
2306
  /**
2282
2307
  * @param {string} key
@@ -2289,109 +2314,101 @@ class Ship {
2289
2314
  return ret === 0xFFFFFF ? undefined : ret;
2290
2315
  }
2291
2316
  /**
2292
- * @param {string} key
2293
2317
  * @returns {number}
2294
2318
  */
2295
- get_gear_stat(key) {
2296
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2297
- const len0 = WASM_VECTOR_LEN;
2298
- const ret = wasm.ship_get_gear_stat(this.__wbg_ptr, ptr0, len0);
2299
- return ret;
2300
- }
2301
- /**
2302
- * @param {string} key
2303
- * @returns {number}
2304
- */
2305
- get_ebonus(key) {
2306
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2307
- const len0 = WASM_VECTOR_LEN;
2308
- const ret = wasm.ship_get_ebonus(this.__wbg_ptr, ptr0, len0);
2319
+ get innate_torpedo_accuracy() {
2320
+ const ret = wasm.ship_innate_torpedo_accuracy(this.__wbg_ptr);
2309
2321
  return ret;
2310
2322
  }
2311
- /**
2312
- * @param {string} key
2313
- * @returns {number | undefined}
2314
- */
2315
- get_stat_mod(key) {
2316
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2317
- const len0 = WASM_VECTOR_LEN;
2318
- const ret = wasm.ship_get_stat_mod(this.__wbg_ptr, ptr0, len0);
2319
- return ret === 0xFFFFFF ? undefined : ret;
2320
- }
2321
2323
  /**
2322
2324
  * @returns {boolean}
2323
2325
  */
2324
- is_abyssal() {
2325
- const ret = wasm.ship_is_abyssal(this.__wbg_ptr);
2326
+ is_attackable_by_torpedo() {
2327
+ const ret = wasm.ship_is_attackable_by_torpedo(this.__wbg_ptr);
2326
2328
  return ret !== 0;
2327
2329
  }
2328
2330
  /**
2329
- * @returns {boolean}
2331
+ * @returns {number | undefined}
2330
2332
  */
2331
- is_submarine() {
2332
- const ret = wasm.ship_is_submarine(this.__wbg_ptr);
2333
- return ret !== 0;
2333
+ get asw() {
2334
+ const ret = wasm.ship_asw(this.__wbg_ptr);
2335
+ return ret === 0xFFFFFF ? undefined : ret;
2334
2336
  }
2335
2337
  /**
2336
- * @returns {boolean}
2338
+ * @returns {number | undefined}
2337
2339
  */
2338
- is_amagiri() {
2339
- const ret = wasm.ship_is_amagiri(this.__wbg_ptr);
2340
- return ret !== 0;
2340
+ get los() {
2341
+ const ret = wasm.ship_los(this.__wbg_ptr);
2342
+ return ret === 0xFFFFFF ? undefined : ret;
2341
2343
  }
2342
2344
  /**
2343
- * @param {Gear} gear
2344
- * @param {string} key
2345
- * @returns {boolean}
2345
+ * @param {number} node_divaricated_factor
2346
+ * @returns {number | undefined}
2346
2347
  */
2347
- can_equip(gear, key) {
2348
- _assertClass(gear, Gear);
2349
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2350
- const len0 = WASM_VECTOR_LEN;
2351
- const ret = wasm.ship_can_equip(this.__wbg_ptr, gear.__wbg_ptr, ptr0, len0);
2352
- return ret !== 0;
2348
+ elos(node_divaricated_factor) {
2349
+ const ret = wasm.ship_elos(this.__wbg_ptr, node_divaricated_factor);
2350
+ return ret[0] === 0 ? undefined : ret[1];
2353
2351
  }
2354
2352
  /**
2355
2353
  * @returns {number | undefined}
2356
2354
  */
2357
- get max_hp() {
2358
- const ret = wasm.ship_max_hp(this.__wbg_ptr);
2355
+ get luck() {
2356
+ const ret = wasm.ship_luck(this.__wbg_ptr);
2359
2357
  return ret === 0xFFFFFF ? undefined : ret;
2360
2358
  }
2361
2359
  /**
2362
- * @returns {number}
2360
+ * @returns {ShipMeta}
2363
2361
  */
2364
- get max_ammo() {
2365
- const ret = wasm.ship_max_ammo(this.__wbg_ptr);
2362
+ meta() {
2363
+ const ret = wasm.ship_meta(this.__wbg_ptr);
2366
2364
  return ret;
2367
2365
  }
2368
2366
  /**
2369
- * @returns {number}
2367
+ * @returns {string}
2370
2368
  */
2371
- get max_fuel() {
2372
- const ret = wasm.ship_max_fuel(this.__wbg_ptr);
2373
- return ret;
2369
+ get name() {
2370
+ let deferred1_0;
2371
+ let deferred1_1;
2372
+ try {
2373
+ const ret = wasm.ship_name(this.__wbg_ptr);
2374
+ deferred1_0 = ret[0];
2375
+ deferred1_1 = ret[1];
2376
+ return getStringFromWasm0(ret[0], ret[1]);
2377
+ } finally {
2378
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
2379
+ }
2374
2380
  }
2375
2381
  /**
2376
- * @returns {number | undefined}
2382
+ * @returns {string}
2377
2383
  */
2378
- get naked_range() {
2379
- const ret = wasm.ship_naked_range(this.__wbg_ptr);
2380
- return ret === 0xFFFFFF ? undefined : ret;
2384
+ get yomi() {
2385
+ let deferred1_0;
2386
+ let deferred1_1;
2387
+ try {
2388
+ const ret = wasm.ship_yomi(this.__wbg_ptr);
2389
+ deferred1_0 = ret[0];
2390
+ deferred1_1 = ret[1];
2391
+ return getStringFromWasm0(ret[0], ret[1]);
2392
+ } finally {
2393
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
2394
+ }
2381
2395
  }
2382
2396
  /**
2383
- * @returns {number}
2397
+ * @returns {number | undefined}
2384
2398
  */
2385
- get naked_speed() {
2386
- const ret = wasm.ship_naked_speed(this.__wbg_ptr);
2387
- return ret;
2399
+ get armor() {
2400
+ const ret = wasm.ship_armor(this.__wbg_ptr);
2401
+ return ret === 0xFFFFFF ? undefined : ret;
2388
2402
  }
2389
2403
  /**
2390
- * @returns {number | undefined}
2404
+ * @param {string} id
2405
+ * @returns {boolean}
2391
2406
  */
2392
- get luck() {
2393
- const ret = wasm.ship_luck(this.__wbg_ptr);
2394
- return ret === 0xFFFFFF ? undefined : ret;
2407
+ eq_id(id) {
2408
+ const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2409
+ const len0 = WASM_VECTOR_LEN;
2410
+ const ret = wasm.ship_eq_id(this.__wbg_ptr, ptr0, len0);
2411
+ return ret !== 0;
2395
2412
  }
2396
2413
  /**
2397
2414
  * @returns {number | undefined}
@@ -2408,193 +2425,176 @@ class Ship {
2408
2425
  return ret;
2409
2426
  }
2410
2427
  /**
2411
- * @returns {number}
2428
+ * @returns {ShipState}
2412
2429
  */
2413
- get accuracy() {
2414
- const ret = wasm.ship_accuracy(this.__wbg_ptr);
2430
+ state() {
2431
+ const ret = wasm.ship_state(this.__wbg_ptr);
2415
2432
  return ret;
2416
2433
  }
2417
2434
  /**
2418
2435
  * @returns {number}
2419
2436
  */
2420
- get innate_torpedo_accuracy() {
2421
- const ret = wasm.ship_innate_torpedo_accuracy(this.__wbg_ptr);
2437
+ get stype() {
2438
+ const ret = wasm.ship_stype(this.__wbg_ptr);
2422
2439
  return ret;
2423
2440
  }
2424
2441
  /**
2425
- * @returns {boolean}
2442
+ * @returns {number | undefined}
2426
2443
  */
2427
- is_installation() {
2428
- const ret = wasm.ship_is_installation(this.__wbg_ptr);
2429
- return ret !== 0;
2444
+ get max_hp() {
2445
+ const ret = wasm.ship_max_hp(this.__wbg_ptr);
2446
+ return ret === 0xFFFFFF ? undefined : ret;
2430
2447
  }
2431
2448
  /**
2432
2449
  * @returns {boolean}
2433
2450
  */
2434
- is_pt_imp() {
2435
- const ret = wasm.ship_is_pt_imp(this.__wbg_ptr);
2451
+ get useful() {
2452
+ const ret = wasm.ship_useful(this.__wbg_ptr);
2436
2453
  return ret !== 0;
2437
2454
  }
2438
2455
  /**
2439
- * @returns {SpecialEnemyType}
2440
- */
2441
- special_enemy_type() {
2442
- const ret = wasm.ship_special_enemy_type(this.__wbg_ptr);
2443
- return ret;
2444
- }
2445
- /**
2446
- * @returns {boolean}
2456
+ * @returns {Ship}
2447
2457
  */
2448
- is_attackable_by_torpedo() {
2449
- const ret = wasm.ship_is_attackable_by_torpedo(this.__wbg_ptr);
2450
- return ret !== 0;
2458
+ static default() {
2459
+ const ret = wasm.ship_default();
2460
+ return Ship.__wrap(ret);
2451
2461
  }
2452
2462
  /**
2453
- * @param {number} index
2454
2463
  * @returns {number | undefined}
2455
2464
  */
2456
- get_slot_size(index) {
2457
- const ret = wasm.ship_get_slot_size(this.__wbg_ptr, index);
2465
+ get evasion() {
2466
+ const ret = wasm.ship_evasion(this.__wbg_ptr);
2458
2467
  return ret === 0xFFFFFF ? undefined : ret;
2459
2468
  }
2460
2469
  /**
2461
- * @param {number} index
2462
- * @returns {number | undefined}
2470
+ * @returns {number}
2463
2471
  */
2464
- get_max_slot_size(index) {
2465
- const ret = wasm.ship_get_max_slot_size(this.__wbg_ptr, index);
2466
- return ret === 0xFFFFFF ? undefined : ret;
2472
+ get next_id() {
2473
+ const ret = wasm.ship_next_id(this.__wbg_ptr);
2474
+ return ret;
2467
2475
  }
2468
2476
  /**
2469
2477
  * @returns {number}
2470
2478
  */
2471
- remaining_ammo_mod() {
2472
- const ret = wasm.ship_remaining_ammo_mod(this.__wbg_ptr);
2473
- return ret;
2479
+ get slotnum() {
2480
+ const ret = wasm.ship_slotnum(this.__wbg_ptr);
2481
+ return ret >>> 0;
2474
2482
  }
2475
2483
  /**
2476
2484
  * @returns {number}
2477
2485
  */
2478
- remaining_fuel_mod() {
2479
- const ret = wasm.ship_remaining_fuel_mod(this.__wbg_ptr);
2486
+ get sort_id() {
2487
+ const ret = wasm.ship_sort_id(this.__wbg_ptr);
2480
2488
  return ret;
2481
2489
  }
2482
2490
  /**
2483
- * @param {AirWaveType} air_type
2484
2491
  * @returns {number | undefined}
2485
2492
  */
2486
- fighter_power(air_type) {
2487
- const ret = wasm.ship_fighter_power(this.__wbg_ptr, air_type);
2488
- return ret === 0x100000001 ? undefined : ret;
2493
+ get torpedo() {
2494
+ const ret = wasm.ship_torpedo(this.__wbg_ptr);
2495
+ return ret === 0xFFFFFF ? undefined : ret;
2489
2496
  }
2490
2497
  /**
2491
- * @returns {number | undefined}
2498
+ * @returns {number}
2492
2499
  */
2493
- fleet_los_factor() {
2494
- const ret = wasm.ship_fleet_los_factor(this.__wbg_ptr);
2495
- return ret[0] === 0 ? undefined : ret[1];
2500
+ get accuracy() {
2501
+ const ret = wasm.ship_accuracy(this.__wbg_ptr);
2502
+ return ret;
2496
2503
  }
2497
2504
  /**
2498
- * 加重対空
2499
- * @param {Side} side
2500
2505
  * @returns {number | undefined}
2501
2506
  */
2502
- ship_adjusted_anti_air(side) {
2503
- const ret = wasm.ship_ship_adjusted_anti_air(this.__wbg_ptr, side);
2504
- return ret[0] === 0 ? undefined : ret[1];
2505
- }
2506
- /**
2507
- * 艦隊対空補正
2508
- * @returns {number}
2509
- */
2510
- fleet_anti_air_mod() {
2511
- const ret = wasm.ship_fleet_anti_air_mod(this.__wbg_ptr);
2512
- return ret;
2507
+ get anti_air() {
2508
+ const ret = wasm.ship_anti_air(this.__wbg_ptr);
2509
+ return ret === 0xFFFFFF ? undefined : ret;
2513
2510
  }
2514
2511
  /**
2515
- * @returns {number}
2512
+ * @returns {ShipCategory}
2516
2513
  */
2517
- cruiser_fit_bonus() {
2518
- const ret = wasm.ship_cruiser_fit_bonus(this.__wbg_ptr);
2514
+ category() {
2515
+ const ret = wasm.ship_category(this.__wbg_ptr);
2519
2516
  return ret;
2520
2517
  }
2521
2518
  /**
2522
- * @returns {number | undefined}
2519
+ * @param {string} key
2520
+ * @returns {Gear | undefined}
2523
2521
  */
2524
- basic_accuracy_term() {
2525
- const ret = wasm.ship_basic_accuracy_term(this.__wbg_ptr);
2526
- return ret[0] === 0 ? undefined : ret[1];
2522
+ get_gear(key) {
2523
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2524
+ const len0 = WASM_VECTOR_LEN;
2525
+ const ret = wasm.ship_get_gear(this.__wbg_ptr, ptr0, len0);
2526
+ return ret === 0 ? undefined : Gear.__wrap(ret);
2527
2527
  }
2528
2528
  /**
2529
- * @returns {number | undefined}
2529
+ * @param {ShipAttr} attr
2530
+ * @returns {boolean}
2530
2531
  */
2531
- basic_evasion_term() {
2532
- const ret = wasm.ship_basic_evasion_term(this.__wbg_ptr);
2533
- return ret[0] === 0 ? undefined : ret[1];
2532
+ has_attr(attr) {
2533
+ const ret = wasm.ship_has_attr(this.__wbg_ptr, attr);
2534
+ return ret !== 0;
2534
2535
  }
2535
2536
  /**
2536
- * @param {number} formation_mod
2537
- * @param {number} postcap_additive
2538
- * @param {number} postcap_multiplicative
2539
- * @returns {number | undefined}
2537
+ * @returns {number}
2540
2538
  */
2541
- evasion_term(formation_mod, postcap_additive, postcap_multiplicative) {
2542
- const ret = wasm.ship_evasion_term(this.__wbg_ptr, formation_mod, postcap_additive, postcap_multiplicative);
2543
- return ret[0] === 0 ? undefined : ret[1];
2539
+ get max_ammo() {
2540
+ const ret = wasm.ship_max_ammo(this.__wbg_ptr);
2541
+ return ret;
2544
2542
  }
2545
2543
  /**
2546
- * @param {number} armor_penetration
2547
- * @returns {number | undefined}
2544
+ * @returns {number}
2548
2545
  */
2549
- basic_defense_power(armor_penetration) {
2550
- const ret = wasm.ship_basic_defense_power(this.__wbg_ptr, armor_penetration);
2551
- return ret[0] === 0 ? undefined : ret[1];
2546
+ get max_fuel() {
2547
+ const ret = wasm.ship_max_fuel(this.__wbg_ptr);
2548
+ return ret;
2552
2549
  }
2553
2550
  /**
2554
- * @returns {number}
2551
+ * @param {Gear} gear
2552
+ * @param {string} key
2553
+ * @returns {boolean}
2555
2554
  */
2556
- transport_point() {
2557
- const ret = wasm.ship_transport_point(this.__wbg_ptr);
2558
- return ret;
2555
+ can_equip(gear, key) {
2556
+ _assertClass(gear, Gear);
2557
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2558
+ const len0 = WASM_VECTOR_LEN;
2559
+ const ret = wasm.ship_can_equip(this.__wbg_ptr, gear.__wbg_ptr, ptr0, len0);
2560
+ return ret !== 0;
2559
2561
  }
2560
2562
  /**
2561
- * @param {number} node_divaricated_factor
2562
2563
  * @returns {number | undefined}
2563
2564
  */
2564
- elos(node_divaricated_factor) {
2565
- const ret = wasm.ship_elos(this.__wbg_ptr, node_divaricated_factor);
2566
- return ret[0] === 0 ? undefined : ret[1];
2565
+ get firepower() {
2566
+ const ret = wasm.ship_firepower(this.__wbg_ptr);
2567
+ return ret === 0xFFFFFF ? undefined : ret;
2567
2568
  }
2568
2569
  /**
2569
- * 確殺攻撃力
2570
- * @returns {number | undefined}
2570
+ * @returns {string[]}
2571
2571
  */
2572
- ohko_power() {
2573
- const ret = wasm.ship_ohko_power(this.__wbg_ptr);
2574
- return ret[0] === 0 ? undefined : ret[1];
2572
+ gear_keys() {
2573
+ const ret = wasm.ship_gear_keys(this.__wbg_ptr);
2574
+ var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
2575
+ wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
2576
+ return v1;
2575
2577
  }
2576
2578
  /**
2577
- * @returns {number | undefined}
2579
+ * @returns {boolean}
2578
2580
  */
2579
- state_day_gunfit_accuracy() {
2580
- const ret = wasm.ship_state_day_gunfit_accuracy(this.__wbg_ptr);
2581
- return ret[0] === 0 ? undefined : ret[1];
2581
+ is_pt_imp() {
2582
+ const ret = wasm.ship_is_pt_imp(this.__wbg_ptr);
2583
+ return ret !== 0;
2582
2584
  }
2583
2585
  /**
2584
2586
  * @returns {number | undefined}
2585
2587
  */
2586
- state_night_gunfit_accuracy() {
2587
- const ret = wasm.ship_state_night_gunfit_accuracy(this.__wbg_ptr);
2588
- return ret[0] === 0 ? undefined : ret[1];
2588
+ get naked_asw() {
2589
+ const ret = wasm.ship_naked_asw(this.__wbg_ptr);
2590
+ return ret === 0xFFFFFF ? undefined : ret;
2589
2591
  }
2590
2592
  /**
2591
- * フィット砲補正
2592
- * @param {boolean} is_night
2593
- * @returns {number}
2593
+ * @returns {number | undefined}
2594
2594
  */
2595
- gunfit_accuracy(is_night) {
2596
- const ret = wasm.ship_gunfit_accuracy(this.__wbg_ptr, is_night);
2597
- return ret;
2595
+ get naked_los() {
2596
+ const ret = wasm.ship_naked_los(this.__wbg_ptr);
2597
+ return ret === 0xFFFFFF ? undefined : ret;
2598
2598
  }
2599
2599
  }
2600
2600
  if (Symbol.dispose) Ship.prototype[Symbol.dispose] = Ship.prototype.free;