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