fleethub-core 1.12.10 → 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.
@@ -126,14 +126,6 @@ function takeFromExternrefTable0(idx) {
126
126
  wasm.__externref_table_dealloc(idx);
127
127
  return value;
128
128
  }
129
- /**
130
- * @param {ShipConditions} value
131
- * @returns {ShipConditions}
132
- */
133
- export function parse_ship_conditions(value) {
134
- const ret = wasm.parse_ship_conditions(value);
135
- return ret;
136
- }
137
129
 
138
130
  function _assertClass(instance, klass) {
139
131
  if (!(instance instanceof klass)) {
@@ -141,6 +133,20 @@ function _assertClass(instance, klass) {
141
133
  }
142
134
  }
143
135
 
136
+ let cachedUint16ArrayMemory0 = null;
137
+
138
+ function getUint16ArrayMemory0() {
139
+ if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
140
+ cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
141
+ }
142
+ return cachedUint16ArrayMemory0;
143
+ }
144
+
145
+ function getArrayU16FromWasm0(ptr, len) {
146
+ ptr = ptr >>> 0;
147
+ return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
148
+ }
149
+
144
150
  function getArrayJsValueFromWasm0(ptr, len) {
145
151
  ptr = ptr >>> 0;
146
152
  const mem = getDataViewMemory0();
@@ -158,19 +164,13 @@ function passArray8ToWasm0(arg, malloc) {
158
164
  WASM_VECTOR_LEN = arg.length;
159
165
  return ptr;
160
166
  }
161
-
162
- let cachedUint16ArrayMemory0 = null;
163
-
164
- function getUint16ArrayMemory0() {
165
- if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
166
- cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
167
- }
168
- return cachedUint16ArrayMemory0;
169
- }
170
-
171
- function getArrayU16FromWasm0(ptr, len) {
172
- ptr = ptr >>> 0;
173
- return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
167
+ /**
168
+ * @param {ShipConditions} value
169
+ * @returns {ShipConditions}
170
+ */
171
+ export function parse_ship_conditions(value) {
172
+ const ret = wasm.parse_ship_conditions(value);
173
+ return ret;
174
174
  }
175
175
 
176
176
  function passArray16ToWasm0(arg, malloc) {
@@ -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,18 +574,36 @@ 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);
582
+ return ret;
583
+ }
584
+ /**
585
+ * 艦隊防空値
586
+ * @param {number} formation_mod
587
+ * @returns {number}
588
+ */
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}
595
+ */
596
+ default_formation() {
597
+ const ret = wasm.comp_default_formation(this.__wbg_ptr);
571
598
  return ret;
572
599
  }
573
600
  /**
574
601
  * @param {FleetType} ft
602
+ * @param {ShipKey} key
575
603
  * @returns {string | undefined}
576
604
  */
577
- get_fleet_id(ft) {
578
- const ret = wasm.comp_get_fleet_id(this.__wbg_ptr, ft);
605
+ get_ship_entity_id(ft, key) {
606
+ const ret = wasm.comp_get_ship_entity_id(this.__wbg_ptr, ft, key);
579
607
  let v1;
580
608
  if (ret[0] !== 0) {
581
609
  v1 = getStringFromWasm0(ret[0], ret[1]).slice();
@@ -584,27 +612,23 @@ export class Comp {
584
612
  return v1;
585
613
  }
586
614
  /**
587
- * @param {FleetType} ft
588
- * @param {ShipKey} key
589
- * @returns {Ship | undefined}
615
+ * @param {Ship} ship
616
+ * @param {Formation | null} [formation]
617
+ * @returns {ShipConditions}
590
618
  */
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);
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));
622
+ return ret;
594
623
  }
595
624
  /**
596
625
  * @param {FleetType} ft
597
626
  * @param {ShipKey} key
598
- * @returns {string | undefined}
627
+ * @returns {Ship | undefined}
599
628
  */
600
- get_ship_entity_id(ft, key) {
601
- const ret = wasm.comp_get_ship_entity_id(this.__wbg_ptr, ft, key);
602
- let v1;
603
- if (ret[0] !== 0) {
604
- v1 = getStringFromWasm0(ret[0], ret[1]).slice();
605
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
606
- }
607
- return v1;
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);
608
632
  }
609
633
  /**
610
634
  * @param {string} id
@@ -616,32 +640,6 @@ export class Comp {
616
640
  const ret = wasm.comp_get_ship_by_eid_with_clone(this.__wbg_ptr, ptr0, len0);
617
641
  return ret === 0 ? undefined : Ship.__wrap(ret);
618
642
  }
619
- /**
620
- * @returns {Formation}
621
- */
622
- default_formation() {
623
- const ret = wasm.comp_default_formation(this.__wbg_ptr);
624
- return ret;
625
- }
626
- /**
627
- * 艦隊防空値
628
- * @param {number} formation_mod
629
- * @returns {number}
630
- */
631
- adjusted_anti_air(formation_mod) {
632
- const ret = wasm.comp_adjusted_anti_air(this.__wbg_ptr, formation_mod);
633
- return ret;
634
- }
635
- /**
636
- * 制空値
637
- * @param {boolean} escort_participates
638
- * @param {AirWaveType} air_type
639
- * @returns {number | undefined}
640
- */
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;
644
- }
645
643
  /**
646
644
  * マップ索敵
647
645
  * @param {number} node_divaricated_factor
@@ -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
@@ -926,16 +913,14 @@ export class Fleet {
926
913
  return ret === 0xFFFFFF ? undefined : ret;
927
914
  }
928
915
  /**
929
- * @param {string} id
930
- * @param {number} rate
931
- * @param {boolean} ceil
916
+ * @param {string} key
932
917
  * @returns {number | undefined}
933
918
  */
934
- get_remaining_fuel(id, rate, ceil) {
935
- const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
919
+ sum_ship_stat_by(key) {
920
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
936
921
  const len0 = WASM_VECTOR_LEN;
937
- const ret = wasm.fleet_get_remaining_fuel(this.__wbg_ptr, ptr0, len0, rate, ceil);
938
- return ret === 0xFFFFFF ? undefined : ret;
922
+ const ret = wasm.fleet_sum_ship_stat_by(this.__wbg_ptr, ptr0, len0);
923
+ return ret[0] === 0 ? undefined : ret[1];
939
924
  }
940
925
  /**
941
926
  * @param {string} id
@@ -950,34 +935,45 @@ export class Fleet {
950
935
  return ret === 0xFFFFFF ? undefined : ret;
951
936
  }
952
937
  /**
953
- * @returns {number}
938
+ * @param {string} id
939
+ * @param {number} rate
940
+ * @param {boolean} ceil
941
+ * @returns {number | undefined}
954
942
  */
955
- count_ships() {
956
- const ret = wasm.fleet_count_ships(this.__wbg_ptr);
957
- return ret >>> 0;
943
+ get_remaining_fuel(id, rate, ceil) {
944
+ const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
945
+ const len0 = WASM_VECTOR_LEN;
946
+ const ret = wasm.fleet_get_remaining_fuel(this.__wbg_ptr, ptr0, len0, rate, ceil);
947
+ return ret === 0xFFFFFF ? undefined : ret;
958
948
  }
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,15 @@ 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
+ }
1865
1874
  /**
1866
1875
  * @returns {number | undefined}
1867
1876
  */
@@ -1876,15 +1885,6 @@ export class Ship {
1876
1885
  const ret = wasm.ship_state_night_gunfit_accuracy(this.__wbg_ptr);
1877
1886
  return ret[0] === 0 ? undefined : ret[1];
1878
1887
  }
1879
- /**
1880
- * フィット砲補正
1881
- * @param {boolean} is_night
1882
- * @returns {number}
1883
- */
1884
- gunfit_accuracy(is_night) {
1885
- const ret = wasm.ship_gunfit_accuracy(this.__wbg_ptr, is_night);
1886
- return ret;
1887
- }
1888
1888
  /**
1889
1889
  * @returns {string}
1890
1890
  */
@@ -1985,268 +1985,254 @@ export class Ship {
1985
1985
  wasm.__wbg_set_ship_slots(this.__wbg_ptr, arg0);
1986
1986
  }
1987
1987
  /**
1988
- * @returns {number | undefined}
1988
+ * @param {string} key
1989
+ * @returns {number}
1989
1990
  */
1990
- get naked_firepower() {
1991
- const ret = wasm.ship_naked_firepower(this.__wbg_ptr);
1992
- 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;
1993
1996
  }
1994
1997
  /**
1995
- * @returns {number | undefined}
1998
+ * @returns {boolean}
1996
1999
  */
1997
- get naked_torpedo() {
1998
- const ret = wasm.ship_naked_torpedo(this.__wbg_ptr);
1999
- return ret === 0xFFFFFF ? undefined : ret;
2000
+ is_abyssal() {
2001
+ const ret = wasm.ship_is_abyssal(this.__wbg_ptr);
2002
+ return ret !== 0;
2000
2003
  }
2001
2004
  /**
2002
- * @returns {number | undefined}
2005
+ * @returns {boolean}
2003
2006
  */
2004
- get naked_armor() {
2005
- const ret = wasm.ship_naked_armor(this.__wbg_ptr);
2006
- return ret === 0xFFFFFF ? undefined : ret;
2007
+ is_amagiri() {
2008
+ const ret = wasm.ship_is_amagiri(this.__wbg_ptr);
2009
+ return ret !== 0;
2007
2010
  }
2008
2011
  /**
2012
+ * 確殺攻撃力
2009
2013
  * @returns {number | undefined}
2010
2014
  */
2011
- get naked_anti_air() {
2012
- const ret = wasm.ship_naked_anti_air(this.__wbg_ptr);
2013
- return ret === 0xFFFFFF ? undefined : ret;
2015
+ ohko_power() {
2016
+ const ret = wasm.ship_ohko_power(this.__wbg_ptr);
2017
+ return ret[0] === 0 ? undefined : ret[1];
2014
2018
  }
2015
2019
  /**
2016
2020
  * @returns {number | undefined}
2017
2021
  */
2018
- get naked_evasion() {
2019
- const ret = wasm.ship_naked_evasion(this.__wbg_ptr);
2022
+ get naked_armor() {
2023
+ const ret = wasm.ship_naked_armor(this.__wbg_ptr);
2020
2024
  return ret === 0xFFFFFF ? undefined : ret;
2021
2025
  }
2022
2026
  /**
2023
2027
  * @returns {number | undefined}
2024
2028
  */
2025
- get naked_asw() {
2026
- const ret = wasm.ship_naked_asw(this.__wbg_ptr);
2029
+ get naked_range() {
2030
+ const ret = wasm.ship_naked_range(this.__wbg_ptr);
2027
2031
  return ret === 0xFFFFFF ? undefined : ret;
2028
2032
  }
2029
2033
  /**
2030
- * @returns {number | undefined}
2034
+ * @returns {number}
2031
2035
  */
2032
- get naked_los() {
2033
- const ret = wasm.ship_naked_los(this.__wbg_ptr);
2034
- return ret === 0xFFFFFF ? undefined : ret;
2036
+ get naked_speed() {
2037
+ const ret = wasm.ship_naked_speed(this.__wbg_ptr);
2038
+ return ret;
2035
2039
  }
2036
2040
  /**
2037
- * @returns {number | undefined}
2041
+ * @returns {DamageState}
2038
2042
  */
2039
- get firepower() {
2040
- const ret = wasm.ship_firepower(this.__wbg_ptr);
2041
- return ret === 0xFFFFFF ? undefined : ret;
2043
+ damage_state() {
2044
+ const ret = wasm.ship_damage_state(this.__wbg_ptr);
2045
+ return ret;
2042
2046
  }
2043
2047
  /**
2048
+ * @param {number} formation_mod
2049
+ * @param {number} postcap_additive
2050
+ * @param {number} postcap_multiplicative
2044
2051
  * @returns {number | undefined}
2045
2052
  */
2046
- get torpedo() {
2047
- const ret = wasm.ship_torpedo(this.__wbg_ptr);
2048
- 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];
2049
2056
  }
2050
2057
  /**
2058
+ * @param {string} key
2051
2059
  * @returns {number | undefined}
2052
2060
  */
2053
- get armor() {
2054
- const ret = wasm.ship_armor(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);
2055
2065
  return ret === 0xFFFFFF ? undefined : ret;
2056
2066
  }
2057
2067
  /**
2058
- * @returns {number | undefined}
2068
+ * @returns {boolean}
2059
2069
  */
2060
- get anti_air() {
2061
- const ret = wasm.ship_anti_air(this.__wbg_ptr);
2062
- return ret === 0xFFFFFF ? undefined : ret;
2070
+ is_submarine() {
2071
+ const ret = wasm.ship_is_submarine(this.__wbg_ptr);
2072
+ return ret !== 0;
2063
2073
  }
2064
2074
  /**
2065
- * @returns {number | undefined}
2075
+ * @returns {MoraleState}
2066
2076
  */
2067
- get evasion() {
2068
- const ret = wasm.ship_evasion(this.__wbg_ptr);
2069
- return ret === 0xFFFFFF ? undefined : ret;
2077
+ morale_state() {
2078
+ const ret = wasm.ship_morale_state(this.__wbg_ptr);
2079
+ return ret;
2070
2080
  }
2071
2081
  /**
2072
- * @returns {number | undefined}
2082
+ * @returns {number}
2073
2083
  */
2074
- get asw() {
2075
- const ret = wasm.ship_asw(this.__wbg_ptr);
2076
- return ret === 0xFFFFFF ? undefined : ret;
2084
+ get remodel_rank() {
2085
+ const ret = wasm.ship_remodel_rank(this.__wbg_ptr);
2086
+ return ret;
2077
2087
  }
2078
2088
  /**
2089
+ * @param {AirWaveType} air_type
2079
2090
  * @returns {number | undefined}
2080
2091
  */
2081
- get los() {
2082
- const ret = wasm.ship_los(this.__wbg_ptr);
2083
- return ret === 0xFFFFFF ? undefined : ret;
2084
- }
2085
- /**
2086
- * @returns {Ship}
2087
- */
2088
- static default() {
2089
- const ret = wasm.ship_default();
2090
- return Ship.__wrap(ret);
2092
+ fighter_power(air_type) {
2093
+ const ret = wasm.ship_fighter_power(this.__wbg_ptr, air_type);
2094
+ return ret === 0x100000001 ? undefined : ret;
2091
2095
  }
2092
2096
  /**
2093
- * @param {string} id
2094
- * @returns {boolean}
2097
+ * @param {string} key
2098
+ * @returns {number}
2095
2099
  */
2096
- eq_id(id) {
2097
- const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2100
+ get_gear_stat(key) {
2101
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2098
2102
  const len0 = WASM_VECTOR_LEN;
2099
- const ret = wasm.ship_eq_id(this.__wbg_ptr, ptr0, len0);
2100
- return ret !== 0;
2103
+ const ret = wasm.ship_get_gear_stat(this.__wbg_ptr, ptr0, len0);
2104
+ return ret;
2101
2105
  }
2102
2106
  /**
2103
- * @returns {ShipState}
2107
+ * @param {number} index
2108
+ * @returns {number | undefined}
2104
2109
  */
2105
- state() {
2106
- const ret = wasm.ship_state(this.__wbg_ptr);
2107
- return ret;
2110
+ get_slot_size(index) {
2111
+ const ret = wasm.ship_get_slot_size(this.__wbg_ptr, index);
2112
+ return ret === 0xFFFFFF ? undefined : ret;
2108
2113
  }
2109
2114
  /**
2110
- * @returns {CustomPowerModifiers}
2115
+ * @returns {number | undefined}
2111
2116
  */
2112
- custom_power_mods() {
2113
- const ret = wasm.ship_custom_power_mods(this.__wbg_ptr);
2114
- return ret;
2117
+ get naked_evasion() {
2118
+ const ret = wasm.ship_naked_evasion(this.__wbg_ptr);
2119
+ return ret === 0xFFFFFF ? undefined : ret;
2115
2120
  }
2116
2121
  /**
2117
- * @returns {ShipMeta}
2122
+ * @returns {number | undefined}
2118
2123
  */
2119
- meta() {
2120
- const ret = wasm.ship_meta(this.__wbg_ptr);
2121
- return ret;
2124
+ get naked_torpedo() {
2125
+ const ret = wasm.ship_naked_torpedo(this.__wbg_ptr);
2126
+ return ret === 0xFFFFFF ? undefined : ret;
2122
2127
  }
2123
2128
  /**
2124
- * @returns {string}
2129
+ * @param {string} key
2130
+ * @returns {number | undefined}
2125
2131
  */
2126
- get name() {
2127
- let deferred1_0;
2128
- let deferred1_1;
2129
- try {
2130
- const ret = wasm.ship_name(this.__wbg_ptr);
2131
- deferred1_0 = ret[0];
2132
- deferred1_1 = ret[1];
2133
- return getStringFromWasm0(ret[0], ret[1]);
2134
- } finally {
2135
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
2136
- }
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);
2136
+ return ret === 0xFFFFFF ? undefined : ret;
2137
2137
  }
2138
2138
  /**
2139
- * @returns {string}
2139
+ * @returns {number | undefined}
2140
2140
  */
2141
- get yomi() {
2142
- let deferred1_0;
2143
- let deferred1_1;
2144
- try {
2145
- const ret = wasm.ship_yomi(this.__wbg_ptr);
2146
- deferred1_0 = ret[0];
2147
- deferred1_1 = ret[1];
2148
- return getStringFromWasm0(ret[0], ret[1]);
2149
- } finally {
2150
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
2151
- }
2141
+ get naked_anti_air() {
2142
+ const ret = wasm.ship_naked_anti_air(this.__wbg_ptr);
2143
+ return ret === 0xFFFFFF ? undefined : ret;
2152
2144
  }
2153
2145
  /**
2154
- * @returns {number}
2146
+ * @returns {boolean}
2155
2147
  */
2156
- get stype() {
2157
- const ret = wasm.ship_stype(this.__wbg_ptr);
2158
- return ret;
2148
+ is_installation() {
2149
+ const ret = wasm.ship_is_installation(this.__wbg_ptr);
2150
+ return ret !== 0;
2159
2151
  }
2160
2152
  /**
2161
- * @returns {number}
2153
+ * @returns {number | undefined}
2162
2154
  */
2163
- get sort_id() {
2164
- const ret = wasm.ship_sort_id(this.__wbg_ptr);
2165
- return ret;
2155
+ get naked_firepower() {
2156
+ const ret = wasm.ship_naked_firepower(this.__wbg_ptr);
2157
+ return ret === 0xFFFFFF ? undefined : ret;
2166
2158
  }
2167
2159
  /**
2168
2160
  * @returns {number}
2169
2161
  */
2170
- get remodel_rank() {
2171
- const ret = wasm.ship_remodel_rank(this.__wbg_ptr);
2162
+ transport_point() {
2163
+ const ret = wasm.ship_transport_point(this.__wbg_ptr);
2172
2164
  return ret;
2173
2165
  }
2174
2166
  /**
2175
- * @returns {number}
2167
+ * @returns {number | undefined}
2176
2168
  */
2177
- get slotnum() {
2178
- const ret = wasm.ship_slotnum(this.__wbg_ptr);
2179
- return ret >>> 0;
2169
+ fleet_los_factor() {
2170
+ const ret = wasm.ship_fleet_los_factor(this.__wbg_ptr);
2171
+ return ret[0] === 0 ? undefined : ret[1];
2180
2172
  }
2181
2173
  /**
2182
- * @returns {number}
2174
+ * @param {DamageState} state
2175
+ * @returns {number | undefined}
2183
2176
  */
2184
- get next_id() {
2185
- const ret = wasm.ship_next_id(this.__wbg_ptr);
2186
- return ret;
2177
+ get_damage_bound(state) {
2178
+ const ret = wasm.ship_get_damage_bound(this.__wbg_ptr, state);
2179
+ return ret === 0xFFFFFF ? undefined : ret;
2187
2180
  }
2188
2181
  /**
2182
+ * @param {string} key
2189
2183
  * @returns {boolean}
2190
2184
  */
2191
- get useful() {
2192
- const ret = wasm.ship_useful(this.__wbg_ptr);
2185
+ has_unknown_stat(key) {
2186
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2187
+ const len0 = WASM_VECTOR_LEN;
2188
+ const ret = wasm.ship_has_unknown_stat(this.__wbg_ptr, ptr0, len0);
2193
2189
  return ret !== 0;
2194
2190
  }
2195
2191
  /**
2196
- * @returns {DamageState}
2197
- */
2198
- damage_state() {
2199
- const ret = wasm.ship_damage_state(this.__wbg_ptr);
2200
- return ret;
2201
- }
2202
- /**
2203
- * @returns {MoraleState}
2192
+ * @returns {number}
2204
2193
  */
2205
- morale_state() {
2206
- const ret = wasm.ship_morale_state(this.__wbg_ptr);
2194
+ cruiser_fit_bonus() {
2195
+ const ret = wasm.ship_cruiser_fit_bonus(this.__wbg_ptr);
2207
2196
  return ret;
2208
2197
  }
2209
2198
  /**
2210
- * @returns {ShipCategory}
2199
+ * @returns {CustomPowerModifiers}
2211
2200
  */
2212
- category() {
2213
- const ret = wasm.ship_category(this.__wbg_ptr);
2201
+ custom_power_mods() {
2202
+ const ret = wasm.ship_custom_power_mods(this.__wbg_ptr);
2214
2203
  return ret;
2215
2204
  }
2216
2205
  /**
2217
- * @param {ShipAttr} attr
2218
- * @returns {boolean}
2206
+ * @param {number} index
2207
+ * @returns {number | undefined}
2219
2208
  */
2220
- has_attr(attr) {
2221
- const ret = wasm.ship_has_attr(this.__wbg_ptr, attr);
2222
- return ret !== 0;
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;
2223
2212
  }
2224
2213
  /**
2225
- * @returns {string[]}
2214
+ * @returns {number | undefined}
2226
2215
  */
2227
- gear_keys() {
2228
- const ret = wasm.ship_gear_keys(this.__wbg_ptr);
2229
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
2230
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
2231
- return v1;
2216
+ basic_evasion_term() {
2217
+ const ret = wasm.ship_basic_evasion_term(this.__wbg_ptr);
2218
+ return ret[0] === 0 ? undefined : ret[1];
2232
2219
  }
2233
2220
  /**
2234
- * @param {string} key
2235
- * @returns {Gear | undefined}
2221
+ * 艦隊対空補正
2222
+ * @returns {number}
2236
2223
  */
2237
- get_gear(key) {
2238
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2239
- const len0 = WASM_VECTOR_LEN;
2240
- const ret = wasm.ship_get_gear(this.__wbg_ptr, ptr0, len0);
2241
- return ret === 0 ? undefined : Gear.__wrap(ret);
2224
+ fleet_anti_air_mod() {
2225
+ const ret = wasm.ship_fleet_anti_air_mod(this.__wbg_ptr);
2226
+ return ret;
2242
2227
  }
2243
2228
  /**
2244
- * @param {DamageState} state
2245
- * @returns {number | undefined}
2229
+ * @param {number} rate
2230
+ * @param {boolean} ceil
2231
+ * @returns {number}
2246
2232
  */
2247
- get_damage_bound(state) {
2248
- const ret = wasm.ship_get_damage_bound(this.__wbg_ptr, state);
2249
- return ret === 0xFFFFFF ? undefined : ret;
2233
+ get_remaining_ammo(rate, ceil) {
2234
+ const ret = wasm.ship_get_remaining_ammo(this.__wbg_ptr, rate, ceil);
2235
+ return ret;
2250
2236
  }
2251
2237
  /**
2252
2238
  * @param {number} rate
@@ -2258,159 +2244,167 @@ export class Ship {
2258
2244
  return ret;
2259
2245
  }
2260
2246
  /**
2261
- * @param {number} rate
2262
- * @param {boolean} ceil
2263
2247
  * @returns {number}
2264
2248
  */
2265
- get_remaining_ammo(rate, ceil) {
2266
- const ret = wasm.ship_get_remaining_ammo(this.__wbg_ptr, rate, ceil);
2249
+ remaining_ammo_mod() {
2250
+ const ret = wasm.ship_remaining_ammo_mod(this.__wbg_ptr);
2267
2251
  return ret;
2268
2252
  }
2269
2253
  /**
2270
- * @param {string} key
2271
- * @returns {boolean}
2254
+ * @returns {number}
2272
2255
  */
2273
- has_unknown_stat(key) {
2274
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2275
- const len0 = WASM_VECTOR_LEN;
2276
- const ret = wasm.ship_has_unknown_stat(this.__wbg_ptr, ptr0, len0);
2277
- return ret !== 0;
2256
+ remaining_fuel_mod() {
2257
+ const ret = wasm.ship_remaining_fuel_mod(this.__wbg_ptr);
2258
+ return ret;
2278
2259
  }
2279
2260
  /**
2280
- * @param {string} key
2281
- * @returns {number | undefined}
2261
+ * @returns {SpecialEnemyType}
2282
2262
  */
2283
- get_naked_stat(key) {
2284
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2285
- const len0 = WASM_VECTOR_LEN;
2286
- const ret = wasm.ship_get_naked_stat(this.__wbg_ptr, ptr0, len0);
2287
- return ret === 0xFFFFFF ? undefined : ret;
2263
+ special_enemy_type() {
2264
+ const ret = wasm.ship_special_enemy_type(this.__wbg_ptr);
2265
+ return ret;
2288
2266
  }
2289
2267
  /**
2290
- * @param {string} key
2291
2268
  * @returns {number | undefined}
2292
2269
  */
2293
- get_stat_interval_left(key) {
2294
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2295
- const len0 = WASM_VECTOR_LEN;
2296
- const ret = wasm.ship_get_stat_interval_left(this.__wbg_ptr, ptr0, len0);
2297
- return ret === 0xFFFFFF ? undefined : ret;
2270
+ basic_accuracy_term() {
2271
+ const ret = wasm.ship_basic_accuracy_term(this.__wbg_ptr);
2272
+ return ret[0] === 0 ? undefined : ret[1];
2298
2273
  }
2299
2274
  /**
2300
- * @param {string} key
2275
+ * @param {number} armor_penetration
2301
2276
  * @returns {number | undefined}
2302
2277
  */
2303
- get_stat_interval_right(key) {
2304
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2305
- const len0 = WASM_VECTOR_LEN;
2306
- const ret = wasm.ship_get_stat_interval_right(this.__wbg_ptr, ptr0, len0);
2307
- return ret === 0xFFFFFF ? undefined : ret;
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];
2308
2281
  }
2309
2282
  /**
2310
2283
  * @param {string} key
2311
- * @returns {number}
2284
+ * @returns {number | undefined}
2312
2285
  */
2313
- get_gear_stat(key) {
2286
+ get_stat_interval_left(key) {
2314
2287
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2315
2288
  const len0 = WASM_VECTOR_LEN;
2316
- const ret = wasm.ship_get_gear_stat(this.__wbg_ptr, ptr0, len0);
2317
- return ret;
2289
+ const ret = wasm.ship_get_stat_interval_left(this.__wbg_ptr, ptr0, len0);
2290
+ return ret === 0xFFFFFF ? undefined : ret;
2318
2291
  }
2319
2292
  /**
2320
- * @param {string} key
2321
- * @returns {number}
2293
+ * 加重対空
2294
+ * @param {Side} side
2295
+ * @returns {number | undefined}
2322
2296
  */
2323
- get_ebonus(key) {
2324
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2325
- const len0 = WASM_VECTOR_LEN;
2326
- const ret = wasm.ship_get_ebonus(this.__wbg_ptr, ptr0, len0);
2327
- return 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];
2328
2300
  }
2329
2301
  /**
2330
2302
  * @param {string} key
2331
2303
  * @returns {number | undefined}
2332
2304
  */
2333
- get_stat_mod(key) {
2305
+ get_stat_interval_right(key) {
2334
2306
  const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2335
2307
  const len0 = WASM_VECTOR_LEN;
2336
- const ret = wasm.ship_get_stat_mod(this.__wbg_ptr, ptr0, len0);
2308
+ const ret = wasm.ship_get_stat_interval_right(this.__wbg_ptr, ptr0, len0);
2337
2309
  return ret === 0xFFFFFF ? undefined : ret;
2338
2310
  }
2339
2311
  /**
2340
- * @returns {boolean}
2341
- */
2342
- is_abyssal() {
2343
- const ret = wasm.ship_is_abyssal(this.__wbg_ptr);
2344
- return ret !== 0;
2345
- }
2346
- /**
2347
- * @returns {boolean}
2348
- */
2349
- is_submarine() {
2350
- const ret = wasm.ship_is_submarine(this.__wbg_ptr);
2351
- return ret !== 0;
2352
- }
2353
- /**
2354
- * @returns {boolean}
2312
+ * @returns {number}
2355
2313
  */
2356
- is_amagiri() {
2357
- const ret = wasm.ship_is_amagiri(this.__wbg_ptr);
2358
- return ret !== 0;
2314
+ get innate_torpedo_accuracy() {
2315
+ const ret = wasm.ship_innate_torpedo_accuracy(this.__wbg_ptr);
2316
+ return ret;
2359
2317
  }
2360
- /**
2361
- * @param {Gear} gear
2362
- * @param {string} key
2363
- * @returns {boolean}
2364
- */
2365
- can_equip(gear, key) {
2366
- _assertClass(gear, Gear);
2367
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2368
- const len0 = WASM_VECTOR_LEN;
2369
- const ret = wasm.ship_can_equip(this.__wbg_ptr, gear.__wbg_ptr, ptr0, len0);
2318
+ /**
2319
+ * @returns {boolean}
2320
+ */
2321
+ is_attackable_by_torpedo() {
2322
+ const ret = wasm.ship_is_attackable_by_torpedo(this.__wbg_ptr);
2370
2323
  return ret !== 0;
2371
2324
  }
2372
2325
  /**
2373
2326
  * @returns {number | undefined}
2374
2327
  */
2375
- get max_hp() {
2376
- const ret = wasm.ship_max_hp(this.__wbg_ptr);
2328
+ get asw() {
2329
+ const ret = wasm.ship_asw(this.__wbg_ptr);
2377
2330
  return ret === 0xFFFFFF ? undefined : ret;
2378
2331
  }
2379
2332
  /**
2380
- * @returns {number}
2333
+ * @returns {number | undefined}
2381
2334
  */
2382
- get max_ammo() {
2383
- const ret = wasm.ship_max_ammo(this.__wbg_ptr);
2384
- return ret;
2335
+ get los() {
2336
+ const ret = wasm.ship_los(this.__wbg_ptr);
2337
+ return ret === 0xFFFFFF ? undefined : ret;
2385
2338
  }
2386
2339
  /**
2387
- * @returns {number}
2340
+ * @param {number} node_divaricated_factor
2341
+ * @returns {number | undefined}
2388
2342
  */
2389
- get max_fuel() {
2390
- const ret = wasm.ship_max_fuel(this.__wbg_ptr);
2391
- return ret;
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];
2392
2346
  }
2393
2347
  /**
2394
2348
  * @returns {number | undefined}
2395
2349
  */
2396
- get naked_range() {
2397
- const ret = wasm.ship_naked_range(this.__wbg_ptr);
2350
+ get luck() {
2351
+ const ret = wasm.ship_luck(this.__wbg_ptr);
2398
2352
  return ret === 0xFFFFFF ? undefined : ret;
2399
2353
  }
2400
2354
  /**
2401
- * @returns {number}
2355
+ * @returns {ShipMeta}
2402
2356
  */
2403
- get naked_speed() {
2404
- const ret = wasm.ship_naked_speed(this.__wbg_ptr);
2357
+ meta() {
2358
+ const ret = wasm.ship_meta(this.__wbg_ptr);
2405
2359
  return ret;
2406
2360
  }
2361
+ /**
2362
+ * @returns {string}
2363
+ */
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
+ }
2375
+ }
2376
+ /**
2377
+ * @returns {string}
2378
+ */
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
+ }
2390
+ }
2407
2391
  /**
2408
2392
  * @returns {number | undefined}
2409
2393
  */
2410
- get luck() {
2411
- const ret = wasm.ship_luck(this.__wbg_ptr);
2394
+ get armor() {
2395
+ const ret = wasm.ship_armor(this.__wbg_ptr);
2412
2396
  return ret === 0xFFFFFF ? undefined : ret;
2413
2397
  }
2398
+ /**
2399
+ * @param {string} id
2400
+ * @returns {boolean}
2401
+ */
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;
2407
+ }
2414
2408
  /**
2415
2409
  * @returns {number | undefined}
2416
2410
  */
@@ -2426,170 +2420,176 @@ export class Ship {
2426
2420
  return ret;
2427
2421
  }
2428
2422
  /**
2429
- * @returns {number}
2423
+ * @returns {ShipState}
2430
2424
  */
2431
- get accuracy() {
2432
- const ret = wasm.ship_accuracy(this.__wbg_ptr);
2425
+ state() {
2426
+ const ret = wasm.ship_state(this.__wbg_ptr);
2433
2427
  return ret;
2434
2428
  }
2435
2429
  /**
2436
2430
  * @returns {number}
2437
2431
  */
2438
- get innate_torpedo_accuracy() {
2439
- const ret = wasm.ship_innate_torpedo_accuracy(this.__wbg_ptr);
2432
+ get stype() {
2433
+ const ret = wasm.ship_stype(this.__wbg_ptr);
2440
2434
  return ret;
2441
2435
  }
2442
2436
  /**
2443
- * @returns {boolean}
2437
+ * @returns {number | undefined}
2444
2438
  */
2445
- is_installation() {
2446
- const ret = wasm.ship_is_installation(this.__wbg_ptr);
2447
- return ret !== 0;
2439
+ get max_hp() {
2440
+ const ret = wasm.ship_max_hp(this.__wbg_ptr);
2441
+ return ret === 0xFFFFFF ? undefined : ret;
2448
2442
  }
2449
2443
  /**
2450
2444
  * @returns {boolean}
2451
2445
  */
2452
- is_pt_imp() {
2453
- const ret = wasm.ship_is_pt_imp(this.__wbg_ptr);
2446
+ get useful() {
2447
+ const ret = wasm.ship_useful(this.__wbg_ptr);
2454
2448
  return ret !== 0;
2455
2449
  }
2456
2450
  /**
2457
- * @returns {SpecialEnemyType}
2458
- */
2459
- special_enemy_type() {
2460
- const ret = wasm.ship_special_enemy_type(this.__wbg_ptr);
2461
- return ret;
2462
- }
2463
- /**
2464
- * @returns {boolean}
2451
+ * @returns {Ship}
2465
2452
  */
2466
- is_attackable_by_torpedo() {
2467
- const ret = wasm.ship_is_attackable_by_torpedo(this.__wbg_ptr);
2468
- return ret !== 0;
2453
+ static default() {
2454
+ const ret = wasm.ship_default();
2455
+ return Ship.__wrap(ret);
2469
2456
  }
2470
2457
  /**
2471
- * @param {number} index
2472
2458
  * @returns {number | undefined}
2473
2459
  */
2474
- get_slot_size(index) {
2475
- const ret = wasm.ship_get_slot_size(this.__wbg_ptr, index);
2460
+ get evasion() {
2461
+ const ret = wasm.ship_evasion(this.__wbg_ptr);
2476
2462
  return ret === 0xFFFFFF ? undefined : ret;
2477
2463
  }
2478
2464
  /**
2479
- * @param {number} index
2480
- * @returns {number | undefined}
2465
+ * @returns {number}
2481
2466
  */
2482
- get_max_slot_size(index) {
2483
- const ret = wasm.ship_get_max_slot_size(this.__wbg_ptr, index);
2484
- return ret === 0xFFFFFF ? undefined : ret;
2467
+ get next_id() {
2468
+ const ret = wasm.ship_next_id(this.__wbg_ptr);
2469
+ return ret;
2485
2470
  }
2486
2471
  /**
2487
2472
  * @returns {number}
2488
2473
  */
2489
- remaining_ammo_mod() {
2490
- const ret = wasm.ship_remaining_ammo_mod(this.__wbg_ptr);
2491
- return ret;
2474
+ get slotnum() {
2475
+ const ret = wasm.ship_slotnum(this.__wbg_ptr);
2476
+ return ret >>> 0;
2492
2477
  }
2493
2478
  /**
2494
2479
  * @returns {number}
2495
2480
  */
2496
- remaining_fuel_mod() {
2497
- const ret = wasm.ship_remaining_fuel_mod(this.__wbg_ptr);
2481
+ get sort_id() {
2482
+ const ret = wasm.ship_sort_id(this.__wbg_ptr);
2498
2483
  return ret;
2499
2484
  }
2500
2485
  /**
2501
- * @param {AirWaveType} air_type
2502
2486
  * @returns {number | undefined}
2503
2487
  */
2504
- fighter_power(air_type) {
2505
- const ret = wasm.ship_fighter_power(this.__wbg_ptr, air_type);
2506
- return ret === 0x100000001 ? undefined : ret;
2488
+ get torpedo() {
2489
+ const ret = wasm.ship_torpedo(this.__wbg_ptr);
2490
+ return ret === 0xFFFFFF ? undefined : ret;
2507
2491
  }
2508
2492
  /**
2509
- * @returns {number | undefined}
2493
+ * @returns {number}
2510
2494
  */
2511
- fleet_los_factor() {
2512
- const ret = wasm.ship_fleet_los_factor(this.__wbg_ptr);
2513
- return ret[0] === 0 ? undefined : ret[1];
2495
+ get accuracy() {
2496
+ const ret = wasm.ship_accuracy(this.__wbg_ptr);
2497
+ return ret;
2514
2498
  }
2515
2499
  /**
2516
- * 加重対空
2517
- * @param {Side} side
2518
2500
  * @returns {number | undefined}
2519
2501
  */
2520
- ship_adjusted_anti_air(side) {
2521
- const ret = wasm.ship_ship_adjusted_anti_air(this.__wbg_ptr, side);
2522
- return ret[0] === 0 ? undefined : ret[1];
2502
+ get anti_air() {
2503
+ const ret = wasm.ship_anti_air(this.__wbg_ptr);
2504
+ return ret === 0xFFFFFF ? undefined : ret;
2523
2505
  }
2524
2506
  /**
2525
- * 艦隊対空補正
2526
- * @returns {number}
2507
+ * @returns {ShipCategory}
2527
2508
  */
2528
- fleet_anti_air_mod() {
2529
- const ret = wasm.ship_fleet_anti_air_mod(this.__wbg_ptr);
2509
+ category() {
2510
+ const ret = wasm.ship_category(this.__wbg_ptr);
2530
2511
  return ret;
2531
2512
  }
2513
+ /**
2514
+ * @param {string} key
2515
+ * @returns {Gear | undefined}
2516
+ */
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
+ }
2523
+ /**
2524
+ * @param {ShipAttr} attr
2525
+ * @returns {boolean}
2526
+ */
2527
+ has_attr(attr) {
2528
+ const ret = wasm.ship_has_attr(this.__wbg_ptr, attr);
2529
+ return ret !== 0;
2530
+ }
2532
2531
  /**
2533
2532
  * @returns {number}
2534
2533
  */
2535
- cruiser_fit_bonus() {
2536
- const ret = wasm.ship_cruiser_fit_bonus(this.__wbg_ptr);
2534
+ get max_ammo() {
2535
+ const ret = wasm.ship_max_ammo(this.__wbg_ptr);
2537
2536
  return ret;
2538
2537
  }
2539
2538
  /**
2540
- * @returns {number | undefined}
2539
+ * @returns {number}
2541
2540
  */
2542
- basic_accuracy_term() {
2543
- const ret = wasm.ship_basic_accuracy_term(this.__wbg_ptr);
2544
- return ret[0] === 0 ? undefined : ret[1];
2541
+ get max_fuel() {
2542
+ const ret = wasm.ship_max_fuel(this.__wbg_ptr);
2543
+ return ret;
2545
2544
  }
2546
2545
  /**
2547
- * @returns {number | undefined}
2546
+ * @param {Gear} gear
2547
+ * @param {string} key
2548
+ * @returns {boolean}
2548
2549
  */
2549
- basic_evasion_term() {
2550
- const ret = wasm.ship_basic_evasion_term(this.__wbg_ptr);
2551
- return ret[0] === 0 ? undefined : ret[1];
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;
2552
2556
  }
2553
2557
  /**
2554
- * @param {number} formation_mod
2555
- * @param {number} postcap_additive
2556
- * @param {number} postcap_multiplicative
2557
2558
  * @returns {number | undefined}
2558
2559
  */
2559
- evasion_term(formation_mod, postcap_additive, postcap_multiplicative) {
2560
- const ret = wasm.ship_evasion_term(this.__wbg_ptr, formation_mod, postcap_additive, postcap_multiplicative);
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
- * @param {number} armor_penetration
2565
- * @returns {number | undefined}
2565
+ * @returns {string[]}
2566
2566
  */
2567
- basic_defense_power(armor_penetration) {
2568
- const ret = wasm.ship_basic_defense_power(this.__wbg_ptr, armor_penetration);
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}
2574
+ * @returns {boolean}
2573
2575
  */
2574
- transport_point() {
2575
- const ret = wasm.ship_transport_point(this.__wbg_ptr);
2576
- return ret;
2576
+ is_pt_imp() {
2577
+ const ret = wasm.ship_is_pt_imp(this.__wbg_ptr);
2578
+ return ret !== 0;
2577
2579
  }
2578
2580
  /**
2579
- * @param {number} node_divaricated_factor
2580
2581
  * @returns {number | undefined}
2581
2582
  */
2582
- elos(node_divaricated_factor) {
2583
- const ret = wasm.ship_elos(this.__wbg_ptr, node_divaricated_factor);
2584
- 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;
2585
2586
  }
2586
2587
  /**
2587
- * 確殺攻撃力
2588
2588
  * @returns {number | undefined}
2589
2589
  */
2590
- ohko_power() {
2591
- const ret = wasm.ship_ohko_power(this.__wbg_ptr);
2592
- return ret[0] === 0 ? undefined : ret[1];
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;