fleethub-core 1.12.18 → 1.12.20
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/node/fleethub_core.d.ts +984 -952
- package/node/fleethub_core.js +1606 -1517
- package/node/fleethub_core_bg.wasm +0 -0
- package/node/fleethub_core_bg.wasm.d.ts +112 -112
- package/package.json +10 -4
- package/pkg/fleethub_core.d.ts +984 -952
- package/pkg/fleethub_core.js +5 -1
- package/pkg/fleethub_core_bg.js +1593 -1503
- package/pkg/fleethub_core_bg.wasm +0 -0
- package/pkg/fleethub_core_bg.wasm.d.ts +112 -112
package/pkg/fleethub_core_bg.js
CHANGED
|
@@ -1,210 +1,19 @@
|
|
|
1
|
-
|
|
2
|
-
export function __wbg_set_wasm(val) {
|
|
3
|
-
wasm = val;
|
|
4
|
-
}
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
function addToExternrefTable0(obj) {
|
|
8
|
-
const idx = wasm.__externref_table_alloc();
|
|
9
|
-
wasm.__wbindgen_export_2.set(idx, obj);
|
|
10
|
-
return idx;
|
|
11
|
-
}
|
|
12
|
-
|
|
13
|
-
function handleError(f, args) {
|
|
14
|
-
try {
|
|
15
|
-
return f.apply(this, args);
|
|
16
|
-
} catch (e) {
|
|
17
|
-
const idx = addToExternrefTable0(e);
|
|
18
|
-
wasm.__wbindgen_exn_store(idx);
|
|
19
|
-
}
|
|
20
|
-
}
|
|
21
|
-
|
|
22
|
-
let cachedUint8ArrayMemory0 = null;
|
|
23
|
-
|
|
24
|
-
function getUint8ArrayMemory0() {
|
|
25
|
-
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
26
|
-
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
|
|
27
|
-
}
|
|
28
|
-
return cachedUint8ArrayMemory0;
|
|
29
|
-
}
|
|
30
|
-
|
|
31
|
-
let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
|
32
|
-
|
|
33
|
-
cachedTextDecoder.decode();
|
|
34
|
-
|
|
35
|
-
const MAX_SAFARI_DECODE_BYTES = 2146435072;
|
|
36
|
-
let numBytesDecoded = 0;
|
|
37
|
-
function decodeText(ptr, len) {
|
|
38
|
-
numBytesDecoded += len;
|
|
39
|
-
if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
|
|
40
|
-
cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
|
41
|
-
cachedTextDecoder.decode();
|
|
42
|
-
numBytesDecoded = len;
|
|
43
|
-
}
|
|
44
|
-
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
|
|
45
|
-
}
|
|
46
|
-
|
|
47
|
-
function getStringFromWasm0(ptr, len) {
|
|
48
|
-
ptr = ptr >>> 0;
|
|
49
|
-
return decodeText(ptr, len);
|
|
50
|
-
}
|
|
51
|
-
|
|
52
|
-
function getArrayU8FromWasm0(ptr, len) {
|
|
53
|
-
ptr = ptr >>> 0;
|
|
54
|
-
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
55
|
-
}
|
|
56
|
-
|
|
57
|
-
let WASM_VECTOR_LEN = 0;
|
|
58
|
-
|
|
59
|
-
const cachedTextEncoder = new TextEncoder();
|
|
60
|
-
|
|
61
|
-
if (!('encodeInto' in cachedTextEncoder)) {
|
|
62
|
-
cachedTextEncoder.encodeInto = function (arg, view) {
|
|
63
|
-
const buf = cachedTextEncoder.encode(arg);
|
|
64
|
-
view.set(buf);
|
|
65
|
-
return {
|
|
66
|
-
read: arg.length,
|
|
67
|
-
written: buf.length
|
|
68
|
-
};
|
|
69
|
-
}
|
|
70
|
-
}
|
|
71
|
-
|
|
72
|
-
function passStringToWasm0(arg, malloc, realloc) {
|
|
73
|
-
|
|
74
|
-
if (realloc === undefined) {
|
|
75
|
-
const buf = cachedTextEncoder.encode(arg);
|
|
76
|
-
const ptr = malloc(buf.length, 1) >>> 0;
|
|
77
|
-
getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
|
|
78
|
-
WASM_VECTOR_LEN = buf.length;
|
|
79
|
-
return ptr;
|
|
80
|
-
}
|
|
81
|
-
|
|
82
|
-
let len = arg.length;
|
|
83
|
-
let ptr = malloc(len, 1) >>> 0;
|
|
84
|
-
|
|
85
|
-
const mem = getUint8ArrayMemory0();
|
|
86
|
-
|
|
87
|
-
let offset = 0;
|
|
88
|
-
|
|
89
|
-
for (; offset < len; offset++) {
|
|
90
|
-
const code = arg.charCodeAt(offset);
|
|
91
|
-
if (code > 0x7F) break;
|
|
92
|
-
mem[ptr + offset] = code;
|
|
93
|
-
}
|
|
94
|
-
|
|
95
|
-
if (offset !== len) {
|
|
96
|
-
if (offset !== 0) {
|
|
97
|
-
arg = arg.slice(offset);
|
|
98
|
-
}
|
|
99
|
-
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
|
|
100
|
-
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
|
|
101
|
-
const ret = cachedTextEncoder.encodeInto(arg, view);
|
|
102
|
-
|
|
103
|
-
offset += ret.written;
|
|
104
|
-
ptr = realloc(ptr, len, offset, 1) >>> 0;
|
|
105
|
-
}
|
|
106
|
-
|
|
107
|
-
WASM_VECTOR_LEN = offset;
|
|
108
|
-
return ptr;
|
|
109
|
-
}
|
|
110
|
-
|
|
111
|
-
let cachedDataViewMemory0 = null;
|
|
112
|
-
|
|
113
|
-
function getDataViewMemory0() {
|
|
114
|
-
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
|
|
115
|
-
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
116
|
-
}
|
|
117
|
-
return cachedDataViewMemory0;
|
|
118
|
-
}
|
|
119
|
-
|
|
120
|
-
function isLikeNone(x) {
|
|
121
|
-
return x === undefined || x === null;
|
|
122
|
-
}
|
|
123
|
-
|
|
124
|
-
let cachedUint16ArrayMemory0 = null;
|
|
125
|
-
|
|
126
|
-
function getUint16ArrayMemory0() {
|
|
127
|
-
if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
|
|
128
|
-
cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
|
|
129
|
-
}
|
|
130
|
-
return cachedUint16ArrayMemory0;
|
|
131
|
-
}
|
|
132
|
-
|
|
133
|
-
function passArray16ToWasm0(arg, malloc) {
|
|
134
|
-
const ptr = malloc(arg.length * 2, 2) >>> 0;
|
|
135
|
-
getUint16ArrayMemory0().set(arg, ptr / 2);
|
|
136
|
-
WASM_VECTOR_LEN = arg.length;
|
|
137
|
-
return ptr;
|
|
138
|
-
}
|
|
139
|
-
|
|
140
|
-
function takeFromExternrefTable0(idx) {
|
|
141
|
-
const value = wasm.__wbindgen_export_2.get(idx);
|
|
142
|
-
wasm.__externref_table_dealloc(idx);
|
|
143
|
-
return value;
|
|
144
|
-
}
|
|
145
|
-
|
|
146
|
-
function _assertClass(instance, klass) {
|
|
147
|
-
if (!(instance instanceof klass)) {
|
|
148
|
-
throw new Error(`expected instance of ${klass.name}`);
|
|
149
|
-
}
|
|
150
|
-
}
|
|
151
|
-
/**
|
|
152
|
-
* @param {ShipConditions} value
|
|
153
|
-
* @returns {ShipConditions}
|
|
154
|
-
*/
|
|
155
|
-
export function parse_ship_conditions(value) {
|
|
156
|
-
const ret = wasm.parse_ship_conditions(value);
|
|
157
|
-
return ret;
|
|
158
|
-
}
|
|
159
|
-
|
|
160
|
-
export function set_panic_hook() {
|
|
161
|
-
wasm.set_panic_hook();
|
|
162
|
-
}
|
|
163
|
-
|
|
164
|
-
function getArrayU16FromWasm0(ptr, len) {
|
|
165
|
-
ptr = ptr >>> 0;
|
|
166
|
-
return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
|
|
167
|
-
}
|
|
168
|
-
|
|
169
|
-
function getArrayJsValueFromWasm0(ptr, len) {
|
|
170
|
-
ptr = ptr >>> 0;
|
|
171
|
-
const mem = getDataViewMemory0();
|
|
172
|
-
const result = [];
|
|
173
|
-
for (let i = ptr; i < ptr + 4 * len; i += 4) {
|
|
174
|
-
result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
|
|
175
|
-
}
|
|
176
|
-
wasm.__externref_drop_slice(ptr, len);
|
|
177
|
-
return result;
|
|
178
|
-
}
|
|
179
|
-
|
|
180
|
-
function passArray8ToWasm0(arg, malloc) {
|
|
181
|
-
const ptr = malloc(arg.length * 1, 1) >>> 0;
|
|
182
|
-
getUint8ArrayMemory0().set(arg, ptr / 1);
|
|
183
|
-
WASM_VECTOR_LEN = arg.length;
|
|
184
|
-
return ptr;
|
|
185
|
-
}
|
|
1
|
+
import { createEquipmentBonuses } from 'equipment-bonus';
|
|
186
2
|
|
|
187
|
-
const AirSquadronFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
188
|
-
? { register: () => {}, unregister: () => {} }
|
|
189
|
-
: new FinalizationRegistry(ptr => wasm.__wbg_airsquadron_free(ptr >>> 0, 1));
|
|
190
3
|
|
|
191
4
|
export class AirSquadron {
|
|
192
|
-
|
|
193
5
|
static __wrap(ptr) {
|
|
194
|
-
ptr = ptr >>> 0;
|
|
195
6
|
const obj = Object.create(AirSquadron.prototype);
|
|
196
7
|
obj.__wbg_ptr = ptr;
|
|
197
8
|
AirSquadronFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
198
9
|
return obj;
|
|
199
10
|
}
|
|
200
|
-
|
|
201
11
|
__destroy_into_raw() {
|
|
202
12
|
const ptr = this.__wbg_ptr;
|
|
203
13
|
this.__wbg_ptr = 0;
|
|
204
14
|
AirSquadronFinalization.unregister(this);
|
|
205
15
|
return ptr;
|
|
206
16
|
}
|
|
207
|
-
|
|
208
17
|
free() {
|
|
209
18
|
const ptr = this.__destroy_into_raw();
|
|
210
19
|
wasm.__wbg_airsquadron_free(ptr, 0);
|
|
@@ -216,12 +25,22 @@ export class AirSquadron {
|
|
|
216
25
|
const ret = wasm.airsquadron_fighter_power(this.__wbg_ptr);
|
|
217
26
|
return ret;
|
|
218
27
|
}
|
|
28
|
+
/**
|
|
29
|
+
* @param {string} key
|
|
30
|
+
* @returns {Gear | undefined}
|
|
31
|
+
*/
|
|
32
|
+
get_gear(key) {
|
|
33
|
+
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
34
|
+
const len0 = WASM_VECTOR_LEN;
|
|
35
|
+
const ret = wasm.airsquadron_get_gear(this.__wbg_ptr, ptr0, len0);
|
|
36
|
+
return ret === 0 ? undefined : Gear.__wrap(ret);
|
|
37
|
+
}
|
|
219
38
|
/**
|
|
220
39
|
* @param {number} index
|
|
221
40
|
* @returns {number}
|
|
222
41
|
*/
|
|
223
|
-
|
|
224
|
-
const ret = wasm.
|
|
42
|
+
get_max_slot_size(index) {
|
|
43
|
+
const ret = wasm.airsquadron_get_max_slot_size(this.__wbg_ptr, index);
|
|
225
44
|
if (ret[2]) {
|
|
226
45
|
throw takeFromExternrefTable0(ret[1]);
|
|
227
46
|
}
|
|
@@ -231,8 +50,8 @@ export class AirSquadron {
|
|
|
231
50
|
* @param {number} index
|
|
232
51
|
* @returns {number}
|
|
233
52
|
*/
|
|
234
|
-
|
|
235
|
-
const ret = wasm.
|
|
53
|
+
get_slot_size(index) {
|
|
54
|
+
const ret = wasm.airsquadron_get_slot_size(this.__wbg_ptr, index);
|
|
236
55
|
if (ret[2]) {
|
|
237
56
|
throw takeFromExternrefTable0(ret[1]);
|
|
238
57
|
}
|
|
@@ -245,6 +64,16 @@ export class AirSquadron {
|
|
|
245
64
|
const ret = wasm.airsquadron_interception_power(this.__wbg_ptr);
|
|
246
65
|
return ret;
|
|
247
66
|
}
|
|
67
|
+
/**
|
|
68
|
+
* @returns {AirSquadronMode}
|
|
69
|
+
*/
|
|
70
|
+
get mode() {
|
|
71
|
+
const ret = wasm.airsquadron_mode(this.__wbg_ptr);
|
|
72
|
+
if (ret[2]) {
|
|
73
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
74
|
+
}
|
|
75
|
+
return takeFromExternrefTable0(ret[0]);
|
|
76
|
+
}
|
|
248
77
|
/**
|
|
249
78
|
* 行動半径
|
|
250
79
|
* @returns {number}
|
|
@@ -254,14 +83,20 @@ export class AirSquadron {
|
|
|
254
83
|
return ret;
|
|
255
84
|
}
|
|
256
85
|
/**
|
|
257
|
-
* @param {
|
|
258
|
-
* @returns {Gear | undefined}
|
|
86
|
+
* @param {AirSquadronMode} mode
|
|
259
87
|
*/
|
|
260
|
-
|
|
261
|
-
const
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
88
|
+
set mode(mode) {
|
|
89
|
+
const ret = wasm.airsquadron_set_mode(this.__wbg_ptr, mode);
|
|
90
|
+
if (ret[1]) {
|
|
91
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
/**
|
|
95
|
+
* @returns {bigint}
|
|
96
|
+
*/
|
|
97
|
+
get hash() {
|
|
98
|
+
const ret = wasm.__wbg_get_airsquadron_hash(this.__wbg_ptr);
|
|
99
|
+
return BigInt.asUintN(64, ret);
|
|
265
100
|
}
|
|
266
101
|
/**
|
|
267
102
|
* @returns {string}
|
|
@@ -278,21 +113,6 @@ export class AirSquadron {
|
|
|
278
113
|
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
279
114
|
}
|
|
280
115
|
}
|
|
281
|
-
/**
|
|
282
|
-
* @param {string} arg0
|
|
283
|
-
*/
|
|
284
|
-
set id(arg0) {
|
|
285
|
-
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
286
|
-
const len0 = WASM_VECTOR_LEN;
|
|
287
|
-
wasm.__wbg_set_airsquadron_id(this.__wbg_ptr, ptr0, len0);
|
|
288
|
-
}
|
|
289
|
-
/**
|
|
290
|
-
* @returns {bigint}
|
|
291
|
-
*/
|
|
292
|
-
get hash() {
|
|
293
|
-
const ret = wasm.__wbg_get_airsquadron_hash(this.__wbg_ptr);
|
|
294
|
-
return BigInt.asUintN(64, ret);
|
|
295
|
-
}
|
|
296
116
|
/**
|
|
297
117
|
* @param {bigint} arg0
|
|
298
118
|
*/
|
|
@@ -300,42 +120,29 @@ export class AirSquadron {
|
|
|
300
120
|
wasm.__wbg_set_airsquadron_hash(this.__wbg_ptr, arg0);
|
|
301
121
|
}
|
|
302
122
|
/**
|
|
303
|
-
* @
|
|
304
|
-
*/
|
|
305
|
-
get mode() {
|
|
306
|
-
const ret = wasm.__wbg_get_airsquadron_mode(this.__wbg_ptr);
|
|
307
|
-
return ret;
|
|
308
|
-
}
|
|
309
|
-
/**
|
|
310
|
-
* @param {AirSquadronMode} arg0
|
|
123
|
+
* @param {string} arg0
|
|
311
124
|
*/
|
|
312
|
-
set
|
|
313
|
-
wasm.
|
|
125
|
+
set id(arg0) {
|
|
126
|
+
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
127
|
+
const len0 = WASM_VECTOR_LEN;
|
|
128
|
+
wasm.__wbg_set_airsquadron_id(this.__wbg_ptr, ptr0, len0);
|
|
314
129
|
}
|
|
315
130
|
}
|
|
316
131
|
if (Symbol.dispose) AirSquadron.prototype[Symbol.dispose] = AirSquadron.prototype.free;
|
|
317
132
|
|
|
318
|
-
const AnalyzerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
319
|
-
? { register: () => {}, unregister: () => {} }
|
|
320
|
-
: new FinalizationRegistry(ptr => wasm.__wbg_analyzer_free(ptr >>> 0, 1));
|
|
321
|
-
|
|
322
133
|
export class Analyzer {
|
|
323
|
-
|
|
324
134
|
static __wrap(ptr) {
|
|
325
|
-
ptr = ptr >>> 0;
|
|
326
135
|
const obj = Object.create(Analyzer.prototype);
|
|
327
136
|
obj.__wbg_ptr = ptr;
|
|
328
137
|
AnalyzerFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
329
138
|
return obj;
|
|
330
139
|
}
|
|
331
|
-
|
|
332
140
|
__destroy_into_raw() {
|
|
333
141
|
const ptr = this.__wbg_ptr;
|
|
334
142
|
this.__wbg_ptr = 0;
|
|
335
143
|
AnalyzerFinalization.unregister(this);
|
|
336
144
|
return ptr;
|
|
337
145
|
}
|
|
338
|
-
|
|
339
146
|
free() {
|
|
340
147
|
const ptr = this.__destroy_into_raw();
|
|
341
148
|
wasm.__wbg_analyzer_free(ptr, 0);
|
|
@@ -348,7 +155,10 @@ export class Analyzer {
|
|
|
348
155
|
analyze_comp(comp, config) {
|
|
349
156
|
_assertClass(comp, Comp);
|
|
350
157
|
const ret = wasm.analyzer_analyze_comp(this.__wbg_ptr, comp.__wbg_ptr, config);
|
|
351
|
-
|
|
158
|
+
if (ret[2]) {
|
|
159
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
160
|
+
}
|
|
161
|
+
return takeFromExternrefTable0(ret[0]);
|
|
352
162
|
}
|
|
353
163
|
/**
|
|
354
164
|
* @param {NodeAttackAnalyzerConfig} config
|
|
@@ -356,15 +166,19 @@ export class Analyzer {
|
|
|
356
166
|
* @param {Ship} left_ship
|
|
357
167
|
* @param {Comp} right_comp
|
|
358
168
|
* @param {Ship} right_ship
|
|
169
|
+
* @param {DensityDetail | null} [density_detail]
|
|
359
170
|
* @returns {NodeAttackAnalysis}
|
|
360
171
|
*/
|
|
361
|
-
analyze_node_attack(config, left_comp, left_ship, right_comp, right_ship) {
|
|
172
|
+
analyze_node_attack(config, left_comp, left_ship, right_comp, right_ship, density_detail) {
|
|
362
173
|
_assertClass(left_comp, Comp);
|
|
363
174
|
_assertClass(left_ship, Ship);
|
|
364
175
|
_assertClass(right_comp, Comp);
|
|
365
176
|
_assertClass(right_ship, Ship);
|
|
366
|
-
const ret = wasm.analyzer_analyze_node_attack(this.__wbg_ptr, config, left_comp.__wbg_ptr, left_ship.__wbg_ptr, right_comp.__wbg_ptr, right_ship.__wbg_ptr);
|
|
367
|
-
|
|
177
|
+
const ret = wasm.analyzer_analyze_node_attack(this.__wbg_ptr, config, left_comp.__wbg_ptr, left_ship.__wbg_ptr, right_comp.__wbg_ptr, right_ship.__wbg_ptr, isLikeNone(density_detail) ? 0 : addToExternrefTable0(density_detail));
|
|
178
|
+
if (ret[2]) {
|
|
179
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
180
|
+
}
|
|
181
|
+
return takeFromExternrefTable0(ret[0]);
|
|
368
182
|
}
|
|
369
183
|
/**
|
|
370
184
|
* @param {ShipAnalyzerConfig} config
|
|
@@ -377,7 +191,10 @@ export class Analyzer {
|
|
|
377
191
|
_assertClass(left, Ship);
|
|
378
192
|
_assertClass(right, Ship);
|
|
379
193
|
const ret = wasm.analyzer_analyze_ship_attack(this.__wbg_ptr, config, left.__wbg_ptr, right.__wbg_ptr, attacker_is_left);
|
|
380
|
-
|
|
194
|
+
if (ret[2]) {
|
|
195
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
196
|
+
}
|
|
197
|
+
return takeFromExternrefTable0(ret[0]);
|
|
381
198
|
}
|
|
382
199
|
/**
|
|
383
200
|
* @param {Comp} player_comp
|
|
@@ -398,143 +215,57 @@ export class Analyzer {
|
|
|
398
215
|
}
|
|
399
216
|
if (Symbol.dispose) Analyzer.prototype[Symbol.dispose] = Analyzer.prototype.free;
|
|
400
217
|
|
|
401
|
-
const CompFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
402
|
-
? { register: () => {}, unregister: () => {} }
|
|
403
|
-
: new FinalizationRegistry(ptr => wasm.__wbg_comp_free(ptr >>> 0, 1));
|
|
404
|
-
|
|
405
218
|
export class Comp {
|
|
406
|
-
|
|
407
219
|
static __wrap(ptr) {
|
|
408
|
-
ptr = ptr >>> 0;
|
|
409
220
|
const obj = Object.create(Comp.prototype);
|
|
410
221
|
obj.__wbg_ptr = ptr;
|
|
411
222
|
CompFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
412
223
|
return obj;
|
|
413
224
|
}
|
|
414
|
-
|
|
415
225
|
__destroy_into_raw() {
|
|
416
226
|
const ptr = this.__wbg_ptr;
|
|
417
227
|
this.__wbg_ptr = 0;
|
|
418
228
|
CompFinalization.unregister(this);
|
|
419
229
|
return ptr;
|
|
420
230
|
}
|
|
421
|
-
|
|
422
231
|
free() {
|
|
423
232
|
const ptr = this.__destroy_into_raw();
|
|
424
233
|
wasm.__wbg_comp_free(ptr, 0);
|
|
425
234
|
}
|
|
426
235
|
/**
|
|
427
|
-
*
|
|
428
|
-
|
|
429
|
-
get org_type() {
|
|
430
|
-
const ret = wasm.__wbg_get_comp_org_type(this.__wbg_ptr);
|
|
431
|
-
return ret;
|
|
432
|
-
}
|
|
433
|
-
/**
|
|
236
|
+
* 艦隊防空値
|
|
237
|
+
* @param {number} formation_mod
|
|
434
238
|
* @returns {number}
|
|
435
239
|
*/
|
|
436
|
-
|
|
437
|
-
const ret = wasm.
|
|
240
|
+
adjusted_anti_air(formation_mod) {
|
|
241
|
+
const ret = wasm.comp_adjusted_anti_air(this.__wbg_ptr, formation_mod);
|
|
438
242
|
return ret;
|
|
439
243
|
}
|
|
440
244
|
/**
|
|
441
|
-
* @returns {
|
|
442
|
-
*/
|
|
443
|
-
get main() {
|
|
444
|
-
const ret = wasm.__wbg_get_comp_main(this.__wbg_ptr);
|
|
445
|
-
return Fleet.__wrap(ret);
|
|
446
|
-
}
|
|
447
|
-
/**
|
|
448
|
-
* @param {Fleet} arg0
|
|
449
|
-
*/
|
|
450
|
-
set main(arg0) {
|
|
451
|
-
_assertClass(arg0, Fleet);
|
|
452
|
-
var ptr0 = arg0.__destroy_into_raw();
|
|
453
|
-
wasm.__wbg_set_comp_main(this.__wbg_ptr, ptr0);
|
|
454
|
-
}
|
|
455
|
-
/**
|
|
456
|
-
* @returns {Fleet | undefined}
|
|
457
|
-
*/
|
|
458
|
-
get escort() {
|
|
459
|
-
const ret = wasm.__wbg_get_comp_escort(this.__wbg_ptr);
|
|
460
|
-
return ret === 0 ? undefined : Fleet.__wrap(ret);
|
|
461
|
-
}
|
|
462
|
-
/**
|
|
463
|
-
* @param {Fleet | null} [arg0]
|
|
464
|
-
*/
|
|
465
|
-
set escort(arg0) {
|
|
466
|
-
let ptr0 = 0;
|
|
467
|
-
if (!isLikeNone(arg0)) {
|
|
468
|
-
_assertClass(arg0, Fleet);
|
|
469
|
-
ptr0 = arg0.__destroy_into_raw();
|
|
470
|
-
}
|
|
471
|
-
wasm.__wbg_set_comp_escort(this.__wbg_ptr, ptr0);
|
|
472
|
-
}
|
|
473
|
-
/**
|
|
474
|
-
* @returns {Fleet | undefined}
|
|
475
|
-
*/
|
|
476
|
-
get route_sup() {
|
|
477
|
-
const ret = wasm.__wbg_get_comp_route_sup(this.__wbg_ptr);
|
|
478
|
-
return ret === 0 ? undefined : Fleet.__wrap(ret);
|
|
479
|
-
}
|
|
480
|
-
/**
|
|
481
|
-
* @param {Fleet | null} [arg0]
|
|
482
|
-
*/
|
|
483
|
-
set route_sup(arg0) {
|
|
484
|
-
let ptr0 = 0;
|
|
485
|
-
if (!isLikeNone(arg0)) {
|
|
486
|
-
_assertClass(arg0, Fleet);
|
|
487
|
-
ptr0 = arg0.__destroy_into_raw();
|
|
488
|
-
}
|
|
489
|
-
wasm.__wbg_set_comp_route_sup(this.__wbg_ptr, ptr0);
|
|
490
|
-
}
|
|
491
|
-
/**
|
|
492
|
-
* @returns {Fleet | undefined}
|
|
493
|
-
*/
|
|
494
|
-
get boss_sup() {
|
|
495
|
-
const ret = wasm.__wbg_get_comp_boss_sup(this.__wbg_ptr);
|
|
496
|
-
return ret === 0 ? undefined : Fleet.__wrap(ret);
|
|
497
|
-
}
|
|
498
|
-
/**
|
|
499
|
-
* @param {Fleet | null} [arg0]
|
|
500
|
-
*/
|
|
501
|
-
set boss_sup(arg0) {
|
|
502
|
-
let ptr0 = 0;
|
|
503
|
-
if (!isLikeNone(arg0)) {
|
|
504
|
-
_assertClass(arg0, Fleet);
|
|
505
|
-
ptr0 = arg0.__destroy_into_raw();
|
|
506
|
-
}
|
|
507
|
-
wasm.__wbg_set_comp_boss_sup(this.__wbg_ptr, ptr0);
|
|
508
|
-
}
|
|
509
|
-
/**
|
|
510
|
-
* @returns {boolean}
|
|
245
|
+
* @returns {number}
|
|
511
246
|
*/
|
|
512
|
-
|
|
513
|
-
const ret = wasm.
|
|
514
|
-
return ret
|
|
247
|
+
balloons() {
|
|
248
|
+
const ret = wasm.comp_balloons(this.__wbg_ptr);
|
|
249
|
+
return ret >>> 0;
|
|
515
250
|
}
|
|
516
251
|
/**
|
|
517
|
-
* @
|
|
518
|
-
* @returns {string | undefined}
|
|
252
|
+
* @returns {Formation}
|
|
519
253
|
*/
|
|
520
|
-
|
|
521
|
-
const ret = wasm.
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
v1 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
525
|
-
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
254
|
+
default_formation() {
|
|
255
|
+
const ret = wasm.comp_default_formation(this.__wbg_ptr);
|
|
256
|
+
if (ret[2]) {
|
|
257
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
526
258
|
}
|
|
527
|
-
return
|
|
259
|
+
return takeFromExternrefTable0(ret[0]);
|
|
528
260
|
}
|
|
529
261
|
/**
|
|
530
|
-
*
|
|
531
|
-
* @
|
|
262
|
+
* マップ索敵
|
|
263
|
+
* @param {number} node_divaricated_factor
|
|
264
|
+
* @returns {number | undefined}
|
|
532
265
|
*/
|
|
533
|
-
|
|
534
|
-
const
|
|
535
|
-
|
|
536
|
-
const ret = wasm.comp_has_ship_eid(this.__wbg_ptr, ptr0, len0);
|
|
537
|
-
return ret !== 0;
|
|
266
|
+
elos(node_divaricated_factor) {
|
|
267
|
+
const ret = wasm.comp_elos(this.__wbg_ptr, node_divaricated_factor);
|
|
268
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
538
269
|
}
|
|
539
270
|
/**
|
|
540
271
|
* 制空値
|
|
@@ -544,7 +275,10 @@ export class Comp {
|
|
|
544
275
|
*/
|
|
545
276
|
fighter_power(escort_participates, air_type) {
|
|
546
277
|
const ret = wasm.comp_fighter_power(this.__wbg_ptr, escort_participates, air_type);
|
|
547
|
-
|
|
278
|
+
if (ret[2]) {
|
|
279
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
280
|
+
}
|
|
281
|
+
return ret[0] === Number.MAX_SAFE_INTEGER ? undefined : ret[0];
|
|
548
282
|
}
|
|
549
283
|
/**
|
|
550
284
|
* @returns {string | undefined}
|
|
@@ -553,7 +287,7 @@ export class Comp {
|
|
|
553
287
|
const ret = wasm.comp_first_ship_id(this.__wbg_ptr);
|
|
554
288
|
let v1;
|
|
555
289
|
if (ret[0] !== 0) {
|
|
556
|
-
v1 = getStringFromWasm0(ret[0], ret[1])
|
|
290
|
+
v1 = getStringFromWasm0(ret[0], ret[1]);
|
|
557
291
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
558
292
|
}
|
|
559
293
|
return v1;
|
|
@@ -564,38 +298,49 @@ export class Comp {
|
|
|
564
298
|
*/
|
|
565
299
|
fleet_los_mod(fleet_type) {
|
|
566
300
|
const ret = wasm.comp_fleet_los_mod(this.__wbg_ptr, fleet_type);
|
|
301
|
+
if (ret[3]) {
|
|
302
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
303
|
+
}
|
|
567
304
|
return ret[0] === 0 ? undefined : ret[1];
|
|
568
305
|
}
|
|
569
306
|
/**
|
|
570
|
-
* @
|
|
571
|
-
|
|
572
|
-
has_route_sup() {
|
|
573
|
-
const ret = wasm.comp_has_route_sup(this.__wbg_ptr);
|
|
574
|
-
return ret !== 0;
|
|
575
|
-
}
|
|
576
|
-
/**
|
|
577
|
-
* 輸送物資量(TP)
|
|
578
|
-
* @returns {number}
|
|
307
|
+
* @param {FleetType} ft
|
|
308
|
+
* @returns {string | undefined}
|
|
579
309
|
*/
|
|
580
|
-
|
|
581
|
-
const ret = wasm.
|
|
582
|
-
|
|
310
|
+
get_fleet_id(ft) {
|
|
311
|
+
const ret = wasm.comp_get_fleet_id(this.__wbg_ptr, ft);
|
|
312
|
+
if (ret[3]) {
|
|
313
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
314
|
+
}
|
|
315
|
+
let v1;
|
|
316
|
+
if (ret[0] !== 0) {
|
|
317
|
+
v1 = getStringFromWasm0(ret[0], ret[1]);
|
|
318
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
319
|
+
}
|
|
320
|
+
return v1;
|
|
583
321
|
}
|
|
584
322
|
/**
|
|
585
|
-
*
|
|
586
|
-
* @
|
|
587
|
-
* @returns {number}
|
|
323
|
+
* @param {string} id
|
|
324
|
+
* @returns {Ship | undefined}
|
|
588
325
|
*/
|
|
589
|
-
|
|
590
|
-
const
|
|
591
|
-
|
|
326
|
+
get_ship_by_eid_with_clone(id) {
|
|
327
|
+
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
328
|
+
const len0 = WASM_VECTOR_LEN;
|
|
329
|
+
const ret = wasm.comp_get_ship_by_eid_with_clone(this.__wbg_ptr, ptr0, len0);
|
|
330
|
+
return ret === 0 ? undefined : Ship.__wrap(ret);
|
|
592
331
|
}
|
|
593
332
|
/**
|
|
594
|
-
* @
|
|
333
|
+
* @param {Ship} ship
|
|
334
|
+
* @param {Formation | null} [formation]
|
|
335
|
+
* @returns {ShipConditions}
|
|
595
336
|
*/
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
337
|
+
get_ship_conditions(ship, formation) {
|
|
338
|
+
_assertClass(ship, Ship);
|
|
339
|
+
const ret = wasm.comp_get_ship_conditions(this.__wbg_ptr, ship.__wbg_ptr, isLikeNone(formation) ? 0 : addToExternrefTable0(formation));
|
|
340
|
+
if (ret[2]) {
|
|
341
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
342
|
+
}
|
|
343
|
+
return takeFromExternrefTable0(ret[0]);
|
|
599
344
|
}
|
|
600
345
|
/**
|
|
601
346
|
* @param {FleetType} ft
|
|
@@ -604,23 +349,16 @@ export class Comp {
|
|
|
604
349
|
*/
|
|
605
350
|
get_ship_entity_id(ft, key) {
|
|
606
351
|
const ret = wasm.comp_get_ship_entity_id(this.__wbg_ptr, ft, key);
|
|
352
|
+
if (ret[3]) {
|
|
353
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
354
|
+
}
|
|
607
355
|
let v1;
|
|
608
356
|
if (ret[0] !== 0) {
|
|
609
|
-
v1 = getStringFromWasm0(ret[0], ret[1])
|
|
357
|
+
v1 = getStringFromWasm0(ret[0], ret[1]);
|
|
610
358
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
611
359
|
}
|
|
612
360
|
return v1;
|
|
613
361
|
}
|
|
614
|
-
/**
|
|
615
|
-
* @param {Ship} ship
|
|
616
|
-
* @param {Formation | null} [formation]
|
|
617
|
-
* @returns {ShipConditions}
|
|
618
|
-
*/
|
|
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;
|
|
623
|
-
}
|
|
624
362
|
/**
|
|
625
363
|
* @param {FleetType} ft
|
|
626
364
|
* @param {ShipKey} key
|
|
@@ -628,47 +366,34 @@ export class Comp {
|
|
|
628
366
|
*/
|
|
629
367
|
get_ship_with_clone(ft, key) {
|
|
630
368
|
const ret = wasm.comp_get_ship_with_clone(this.__wbg_ptr, ft, key);
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
|
|
634
|
-
|
|
635
|
-
* @returns {Ship | undefined}
|
|
636
|
-
*/
|
|
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);
|
|
642
|
-
}
|
|
643
|
-
/**
|
|
644
|
-
* マップ索敵
|
|
645
|
-
* @param {number} node_divaricated_factor
|
|
646
|
-
* @returns {number | undefined}
|
|
647
|
-
*/
|
|
648
|
-
elos(node_divaricated_factor) {
|
|
649
|
-
const ret = wasm.comp_elos(this.__wbg_ptr, node_divaricated_factor);
|
|
650
|
-
return ret[0] === 0 ? undefined : ret[1];
|
|
369
|
+
if (ret[2]) {
|
|
370
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
371
|
+
}
|
|
372
|
+
return ret[0] === 0 ? undefined : Ship.__wrap(ret[0]);
|
|
651
373
|
}
|
|
652
374
|
/**
|
|
653
|
-
* @returns {
|
|
375
|
+
* @returns {boolean}
|
|
654
376
|
*/
|
|
655
|
-
|
|
656
|
-
const ret = wasm.
|
|
657
|
-
return ret;
|
|
377
|
+
has_route_sup() {
|
|
378
|
+
const ret = wasm.comp_has_route_sup(this.__wbg_ptr);
|
|
379
|
+
return ret !== 0;
|
|
658
380
|
}
|
|
659
381
|
/**
|
|
660
|
-
* @
|
|
382
|
+
* @param {string} id
|
|
383
|
+
* @returns {boolean}
|
|
661
384
|
*/
|
|
662
|
-
|
|
663
|
-
const
|
|
664
|
-
|
|
385
|
+
has_ship_eid(id) {
|
|
386
|
+
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
387
|
+
const len0 = WASM_VECTOR_LEN;
|
|
388
|
+
const ret = wasm.comp_has_ship_eid(this.__wbg_ptr, ptr0, len0);
|
|
389
|
+
return ret !== 0;
|
|
665
390
|
}
|
|
666
391
|
/**
|
|
667
|
-
* @returns {
|
|
392
|
+
* @returns {boolean}
|
|
668
393
|
*/
|
|
669
|
-
|
|
670
|
-
const ret = wasm.
|
|
671
|
-
return ret
|
|
394
|
+
is_combined() {
|
|
395
|
+
const ret = wasm.comp_is_combined(this.__wbg_ptr);
|
|
396
|
+
return ret !== 0;
|
|
672
397
|
}
|
|
673
398
|
/**
|
|
674
399
|
* @returns {boolean}
|
|
@@ -684,79 +409,133 @@ export class Comp {
|
|
|
684
409
|
const ret = wasm.comp_is_player(this.__wbg_ptr);
|
|
685
410
|
return ret !== 0;
|
|
686
411
|
}
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
__destroy_into_raw() {
|
|
697
|
-
const ptr = this.__wbg_ptr;
|
|
698
|
-
this.__wbg_ptr = 0;
|
|
699
|
-
FhCoreFinalization.unregister(this);
|
|
700
|
-
return ptr;
|
|
412
|
+
/**
|
|
413
|
+
* @returns {CompMeta}
|
|
414
|
+
*/
|
|
415
|
+
meta() {
|
|
416
|
+
const ret = wasm.comp_meta(this.__wbg_ptr);
|
|
417
|
+
if (ret[2]) {
|
|
418
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
419
|
+
}
|
|
420
|
+
return takeFromExternrefTable0(ret[0]);
|
|
701
421
|
}
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
|
|
422
|
+
/**
|
|
423
|
+
* @returns {OrgType}
|
|
424
|
+
*/
|
|
425
|
+
get org_type() {
|
|
426
|
+
const ret = wasm.comp_org_type(this.__wbg_ptr);
|
|
427
|
+
if (ret[2]) {
|
|
428
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
429
|
+
}
|
|
430
|
+
return takeFromExternrefTable0(ret[0]);
|
|
706
431
|
}
|
|
707
432
|
/**
|
|
708
|
-
* @
|
|
709
|
-
* @returns {Org | undefined}
|
|
433
|
+
* @returns {Side}
|
|
710
434
|
*/
|
|
711
|
-
|
|
712
|
-
const ret = wasm.
|
|
713
|
-
|
|
435
|
+
side() {
|
|
436
|
+
const ret = wasm.comp_side(this.__wbg_ptr);
|
|
437
|
+
if (ret[2]) {
|
|
438
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
439
|
+
}
|
|
440
|
+
return takeFromExternrefTable0(ret[0]);
|
|
714
441
|
}
|
|
715
442
|
/**
|
|
716
|
-
*
|
|
717
|
-
* @returns {
|
|
443
|
+
* 輸送物資量(TP)
|
|
444
|
+
* @returns {number}
|
|
718
445
|
*/
|
|
719
|
-
|
|
720
|
-
const ret = wasm.
|
|
721
|
-
return ret
|
|
446
|
+
transport_point() {
|
|
447
|
+
const ret = wasm.comp_transport_point(this.__wbg_ptr);
|
|
448
|
+
return ret;
|
|
722
449
|
}
|
|
723
450
|
/**
|
|
724
|
-
* @
|
|
725
|
-
* @returns {Ship | undefined}
|
|
451
|
+
* @returns {Fleet | undefined}
|
|
726
452
|
*/
|
|
727
|
-
|
|
728
|
-
const ret = wasm.
|
|
729
|
-
return ret === 0 ? undefined :
|
|
453
|
+
get boss_sup() {
|
|
454
|
+
const ret = wasm.__wbg_get_comp_boss_sup(this.__wbg_ptr);
|
|
455
|
+
return ret === 0 ? undefined : Fleet.__wrap(ret);
|
|
456
|
+
}
|
|
457
|
+
/**
|
|
458
|
+
* @returns {Fleet | undefined}
|
|
459
|
+
*/
|
|
460
|
+
get escort() {
|
|
461
|
+
const ret = wasm.__wbg_get_comp_escort(this.__wbg_ptr);
|
|
462
|
+
return ret === 0 ? undefined : Fleet.__wrap(ret);
|
|
463
|
+
}
|
|
464
|
+
/**
|
|
465
|
+
* @returns {number}
|
|
466
|
+
*/
|
|
467
|
+
get hq_level() {
|
|
468
|
+
const ret = wasm.__wbg_get_comp_hq_level(this.__wbg_ptr);
|
|
469
|
+
return ret;
|
|
730
470
|
}
|
|
731
471
|
/**
|
|
732
|
-
* @param {FleetState | null} [input]
|
|
733
472
|
* @returns {Fleet}
|
|
734
473
|
*/
|
|
735
|
-
|
|
736
|
-
const ret = wasm.
|
|
474
|
+
get main() {
|
|
475
|
+
const ret = wasm.__wbg_get_comp_main(this.__wbg_ptr);
|
|
737
476
|
return Fleet.__wrap(ret);
|
|
738
477
|
}
|
|
739
478
|
/**
|
|
740
|
-
* @returns {
|
|
479
|
+
* @returns {Fleet | undefined}
|
|
741
480
|
*/
|
|
742
|
-
|
|
743
|
-
const ret = wasm.
|
|
744
|
-
return
|
|
481
|
+
get route_sup() {
|
|
482
|
+
const ret = wasm.__wbg_get_comp_route_sup(this.__wbg_ptr);
|
|
483
|
+
return ret === 0 ? undefined : Fleet.__wrap(ret);
|
|
745
484
|
}
|
|
746
485
|
/**
|
|
747
|
-
* @
|
|
486
|
+
* @param {Fleet | null} [arg0]
|
|
748
487
|
*/
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
488
|
+
set boss_sup(arg0) {
|
|
489
|
+
let ptr0 = 0;
|
|
490
|
+
if (!isLikeNone(arg0)) {
|
|
491
|
+
_assertClass(arg0, Fleet);
|
|
492
|
+
ptr0 = arg0.__destroy_into_raw();
|
|
493
|
+
}
|
|
494
|
+
wasm.__wbg_set_comp_boss_sup(this.__wbg_ptr, ptr0);
|
|
752
495
|
}
|
|
753
496
|
/**
|
|
754
|
-
* @param {
|
|
755
|
-
* @returns {Ship | undefined}
|
|
497
|
+
* @param {Fleet | null} [arg0]
|
|
756
498
|
*/
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
499
|
+
set escort(arg0) {
|
|
500
|
+
let ptr0 = 0;
|
|
501
|
+
if (!isLikeNone(arg0)) {
|
|
502
|
+
_assertClass(arg0, Fleet);
|
|
503
|
+
ptr0 = arg0.__destroy_into_raw();
|
|
504
|
+
}
|
|
505
|
+
wasm.__wbg_set_comp_escort(this.__wbg_ptr, ptr0);
|
|
506
|
+
}
|
|
507
|
+
/**
|
|
508
|
+
* @param {Fleet} arg0
|
|
509
|
+
*/
|
|
510
|
+
set main(arg0) {
|
|
511
|
+
_assertClass(arg0, Fleet);
|
|
512
|
+
var ptr0 = arg0.__destroy_into_raw();
|
|
513
|
+
wasm.__wbg_set_comp_main(this.__wbg_ptr, ptr0);
|
|
514
|
+
}
|
|
515
|
+
/**
|
|
516
|
+
* @param {Fleet | null} [arg0]
|
|
517
|
+
*/
|
|
518
|
+
set route_sup(arg0) {
|
|
519
|
+
let ptr0 = 0;
|
|
520
|
+
if (!isLikeNone(arg0)) {
|
|
521
|
+
_assertClass(arg0, Fleet);
|
|
522
|
+
ptr0 = arg0.__destroy_into_raw();
|
|
523
|
+
}
|
|
524
|
+
wasm.__wbg_set_comp_route_sup(this.__wbg_ptr, ptr0);
|
|
525
|
+
}
|
|
526
|
+
}
|
|
527
|
+
if (Symbol.dispose) Comp.prototype[Symbol.dispose] = Comp.prototype.free;
|
|
528
|
+
|
|
529
|
+
export class FhCore {
|
|
530
|
+
__destroy_into_raw() {
|
|
531
|
+
const ptr = this.__wbg_ptr;
|
|
532
|
+
this.__wbg_ptr = 0;
|
|
533
|
+
FhCoreFinalization.unregister(this);
|
|
534
|
+
return ptr;
|
|
535
|
+
}
|
|
536
|
+
free() {
|
|
537
|
+
const ptr = this.__destroy_into_raw();
|
|
538
|
+
wasm.__wbg_fhcore_free(ptr, 0);
|
|
760
539
|
}
|
|
761
540
|
/**
|
|
762
541
|
* @param {AirSquadronState | null} [input]
|
|
@@ -764,22 +543,24 @@ export class FhCore {
|
|
|
764
543
|
*/
|
|
765
544
|
create_air_squadron(input) {
|
|
766
545
|
const ret = wasm.fhcore_create_air_squadron(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
|
|
767
|
-
|
|
546
|
+
if (ret[2]) {
|
|
547
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
548
|
+
}
|
|
549
|
+
return AirSquadron.__wrap(ret[0]);
|
|
768
550
|
}
|
|
769
551
|
/**
|
|
770
|
-
* @returns {Ship}
|
|
552
|
+
* @returns {Ship[]}
|
|
771
553
|
*/
|
|
772
|
-
|
|
773
|
-
const ret = wasm.
|
|
774
|
-
return
|
|
554
|
+
create_all_ships() {
|
|
555
|
+
const ret = wasm.fhcore_create_all_ships(this.__wbg_ptr);
|
|
556
|
+
return ret;
|
|
775
557
|
}
|
|
776
558
|
/**
|
|
777
|
-
* @
|
|
778
|
-
* @returns {ShipState | undefined}
|
|
559
|
+
* @returns {Analyzer}
|
|
779
560
|
*/
|
|
780
|
-
|
|
781
|
-
const ret = wasm.
|
|
782
|
-
return ret;
|
|
561
|
+
create_analyzer() {
|
|
562
|
+
const ret = wasm.fhcore_create_analyzer(this.__wbg_ptr);
|
|
563
|
+
return Analyzer.__wrap(ret);
|
|
783
564
|
}
|
|
784
565
|
/**
|
|
785
566
|
* @param {Uint16Array} main
|
|
@@ -794,6 +575,76 @@ export class FhCore {
|
|
|
794
575
|
const ret = wasm.fhcore_create_comp_by_map_enemy(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
795
576
|
return Comp.__wrap(ret);
|
|
796
577
|
}
|
|
578
|
+
/**
|
|
579
|
+
* @returns {Ship}
|
|
580
|
+
*/
|
|
581
|
+
create_default_ship() {
|
|
582
|
+
const ret = wasm.fhcore_create_default_ship(this.__wbg_ptr);
|
|
583
|
+
return Ship.__wrap(ret);
|
|
584
|
+
}
|
|
585
|
+
/**
|
|
586
|
+
* @param {FleetState | null} [input]
|
|
587
|
+
* @returns {Fleet}
|
|
588
|
+
*/
|
|
589
|
+
create_fleet(input) {
|
|
590
|
+
const ret = wasm.fhcore_create_fleet(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
|
|
591
|
+
if (ret[2]) {
|
|
592
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
593
|
+
}
|
|
594
|
+
return Fleet.__wrap(ret[0]);
|
|
595
|
+
}
|
|
596
|
+
/**
|
|
597
|
+
* @param {GearState | null} [input]
|
|
598
|
+
* @returns {Gear | undefined}
|
|
599
|
+
*/
|
|
600
|
+
create_gear(input) {
|
|
601
|
+
const ret = wasm.fhcore_create_gear(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
|
|
602
|
+
if (ret[2]) {
|
|
603
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
604
|
+
}
|
|
605
|
+
return ret[0] === 0 ? undefined : Gear.__wrap(ret[0]);
|
|
606
|
+
}
|
|
607
|
+
/**
|
|
608
|
+
* @param {OrgState | null} [input]
|
|
609
|
+
* @returns {Org | undefined}
|
|
610
|
+
*/
|
|
611
|
+
create_org(input) {
|
|
612
|
+
const ret = wasm.fhcore_create_org(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
|
|
613
|
+
if (ret[2]) {
|
|
614
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
615
|
+
}
|
|
616
|
+
return ret[0] === 0 ? undefined : Org.__wrap(ret[0]);
|
|
617
|
+
}
|
|
618
|
+
/**
|
|
619
|
+
* @param {ShipState | null} [input]
|
|
620
|
+
* @returns {Ship | undefined}
|
|
621
|
+
*/
|
|
622
|
+
create_ship(input) {
|
|
623
|
+
const ret = wasm.fhcore_create_ship(this.__wbg_ptr, isLikeNone(input) ? 0 : addToExternrefTable0(input));
|
|
624
|
+
if (ret[2]) {
|
|
625
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
626
|
+
}
|
|
627
|
+
return ret[0] === 0 ? undefined : Ship.__wrap(ret[0]);
|
|
628
|
+
}
|
|
629
|
+
/**
|
|
630
|
+
* @param {number} ship_id
|
|
631
|
+
* @returns {Ship | undefined}
|
|
632
|
+
*/
|
|
633
|
+
create_ship_by_id(ship_id) {
|
|
634
|
+
const ret = wasm.fhcore_create_ship_by_id(this.__wbg_ptr, ship_id);
|
|
635
|
+
return ret === 0 ? undefined : Ship.__wrap(ret);
|
|
636
|
+
}
|
|
637
|
+
/**
|
|
638
|
+
* @param {number} ship_id
|
|
639
|
+
* @returns {ShipState | undefined}
|
|
640
|
+
*/
|
|
641
|
+
create_ship_state_by_id(ship_id) {
|
|
642
|
+
const ret = wasm.fhcore_create_ship_state_by_id(this.__wbg_ptr, ship_id);
|
|
643
|
+
if (ret[2]) {
|
|
644
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
645
|
+
}
|
|
646
|
+
return takeFromExternrefTable0(ret[0]);
|
|
647
|
+
}
|
|
797
648
|
/**
|
|
798
649
|
* @param {MasterData} js_master
|
|
799
650
|
*/
|
|
@@ -802,81 +653,62 @@ export class FhCore {
|
|
|
802
653
|
if (ret[2]) {
|
|
803
654
|
throw takeFromExternrefTable0(ret[1]);
|
|
804
655
|
}
|
|
805
|
-
this.__wbg_ptr = ret[0]
|
|
656
|
+
this.__wbg_ptr = ret[0];
|
|
806
657
|
FhCoreFinalization.register(this, this.__wbg_ptr, this);
|
|
807
658
|
return this;
|
|
808
659
|
}
|
|
809
660
|
}
|
|
810
661
|
if (Symbol.dispose) FhCore.prototype[Symbol.dispose] = FhCore.prototype.free;
|
|
811
662
|
|
|
812
|
-
const FleetFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
813
|
-
? { register: () => {}, unregister: () => {} }
|
|
814
|
-
: new FinalizationRegistry(ptr => wasm.__wbg_fleet_free(ptr >>> 0, 1));
|
|
815
|
-
|
|
816
663
|
export class Fleet {
|
|
817
|
-
|
|
818
664
|
static __wrap(ptr) {
|
|
819
|
-
ptr = ptr >>> 0;
|
|
820
665
|
const obj = Object.create(Fleet.prototype);
|
|
821
666
|
obj.__wbg_ptr = ptr;
|
|
822
667
|
FleetFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
823
668
|
return obj;
|
|
824
669
|
}
|
|
825
|
-
|
|
826
670
|
__destroy_into_raw() {
|
|
827
671
|
const ptr = this.__wbg_ptr;
|
|
828
672
|
this.__wbg_ptr = 0;
|
|
829
673
|
FleetFinalization.unregister(this);
|
|
830
674
|
return ptr;
|
|
831
675
|
}
|
|
832
|
-
|
|
833
676
|
free() {
|
|
834
677
|
const ptr = this.__destroy_into_raw();
|
|
835
678
|
wasm.__wbg_fleet_free(ptr, 0);
|
|
836
679
|
}
|
|
837
680
|
/**
|
|
838
|
-
*
|
|
681
|
+
* 航空索敵スコア
|
|
682
|
+
* @returns {number | undefined}
|
|
839
683
|
*/
|
|
840
|
-
|
|
841
|
-
|
|
842
|
-
|
|
843
|
-
try {
|
|
844
|
-
const ret = wasm.__wbg_get_fleet_id(this.__wbg_ptr);
|
|
845
|
-
deferred1_0 = ret[0];
|
|
846
|
-
deferred1_1 = ret[1];
|
|
847
|
-
return getStringFromWasm0(ret[0], ret[1]);
|
|
848
|
-
} finally {
|
|
849
|
-
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
850
|
-
}
|
|
851
|
-
}
|
|
852
|
-
/**
|
|
853
|
-
* @param {string} arg0
|
|
854
|
-
*/
|
|
855
|
-
set id(arg0) {
|
|
856
|
-
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
857
|
-
const len0 = WASM_VECTOR_LEN;
|
|
858
|
-
wasm.__wbg_set_fleet_id(this.__wbg_ptr, ptr0, len0);
|
|
684
|
+
aviation_detection_score() {
|
|
685
|
+
const ret = wasm.fleet_aviation_detection_score(this.__wbg_ptr);
|
|
686
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
859
687
|
}
|
|
860
688
|
/**
|
|
861
|
-
* @returns {
|
|
689
|
+
* @returns {number}
|
|
862
690
|
*/
|
|
863
|
-
|
|
864
|
-
const ret = wasm.
|
|
865
|
-
return
|
|
691
|
+
count_ships() {
|
|
692
|
+
const ret = wasm.fleet_count_ships(this.__wbg_ptr);
|
|
693
|
+
return ret >>> 0;
|
|
866
694
|
}
|
|
867
695
|
/**
|
|
868
|
-
*
|
|
696
|
+
* マップ索敵
|
|
697
|
+
* @param {number} hq_level
|
|
698
|
+
* @param {number} node_divaricated_factor
|
|
699
|
+
* @returns {number | undefined}
|
|
869
700
|
*/
|
|
870
|
-
|
|
871
|
-
const ret = wasm.
|
|
872
|
-
return ret
|
|
701
|
+
elos(hq_level, node_divaricated_factor) {
|
|
702
|
+
const ret = wasm.fleet_elos(this.__wbg_ptr, hq_level, node_divaricated_factor);
|
|
703
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
873
704
|
}
|
|
874
705
|
/**
|
|
706
|
+
* 遠征ボーナス
|
|
875
707
|
* @returns {number}
|
|
876
708
|
*/
|
|
877
|
-
|
|
878
|
-
const ret = wasm.
|
|
879
|
-
return ret
|
|
709
|
+
expedition_bonus() {
|
|
710
|
+
const ret = wasm.fleet_expedition_bonus(this.__wbg_ptr);
|
|
711
|
+
return ret;
|
|
880
712
|
}
|
|
881
713
|
/**
|
|
882
714
|
* @param {AirWaveType} air_type
|
|
@@ -884,7 +716,10 @@ export class Fleet {
|
|
|
884
716
|
*/
|
|
885
717
|
fighter_power(air_type) {
|
|
886
718
|
const ret = wasm.fleet_fighter_power(this.__wbg_ptr, air_type);
|
|
887
|
-
|
|
719
|
+
if (ret[2]) {
|
|
720
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
721
|
+
}
|
|
722
|
+
return ret[0] === Number.MAX_SAFE_INTEGER ? undefined : ret[0];
|
|
888
723
|
}
|
|
889
724
|
/**
|
|
890
725
|
* @returns {number | undefined}
|
|
@@ -893,14 +728,6 @@ export class Fleet {
|
|
|
893
728
|
const ret = wasm.fleet_fleet_los_mod(this.__wbg_ptr);
|
|
894
729
|
return ret[0] === 0 ? undefined : ret[1];
|
|
895
730
|
}
|
|
896
|
-
/**
|
|
897
|
-
* 遠征ボーナス
|
|
898
|
-
* @returns {number}
|
|
899
|
-
*/
|
|
900
|
-
expedition_bonus() {
|
|
901
|
-
const ret = wasm.fleet_expedition_bonus(this.__wbg_ptr);
|
|
902
|
-
return ret;
|
|
903
|
-
}
|
|
904
731
|
/**
|
|
905
732
|
* @param {string} id
|
|
906
733
|
* @param {DamageState} state
|
|
@@ -910,17 +737,28 @@ export class Fleet {
|
|
|
910
737
|
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
911
738
|
const len0 = WASM_VECTOR_LEN;
|
|
912
739
|
const ret = wasm.fleet_get_damage_bound(this.__wbg_ptr, ptr0, len0, state);
|
|
913
|
-
|
|
740
|
+
if (ret[2]) {
|
|
741
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
742
|
+
}
|
|
743
|
+
return ret[0] === 0xFFFFFF ? undefined : ret[0];
|
|
914
744
|
}
|
|
915
745
|
/**
|
|
916
|
-
* @
|
|
917
|
-
* @returns {number | undefined}
|
|
746
|
+
* @returns {string[]}
|
|
918
747
|
*/
|
|
919
|
-
|
|
920
|
-
const
|
|
921
|
-
|
|
922
|
-
|
|
923
|
-
return
|
|
748
|
+
get_gear_ids_by_improvable() {
|
|
749
|
+
const ret = wasm.fleet_get_gear_ids_by_improvable(this.__wbg_ptr);
|
|
750
|
+
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
|
|
751
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
752
|
+
return v1;
|
|
753
|
+
}
|
|
754
|
+
/**
|
|
755
|
+
* @returns {string[]}
|
|
756
|
+
*/
|
|
757
|
+
get_gear_ids_by_proficiency() {
|
|
758
|
+
const ret = wasm.fleet_get_gear_ids_by_proficiency(this.__wbg_ptr);
|
|
759
|
+
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
|
|
760
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
761
|
+
return v1;
|
|
924
762
|
}
|
|
925
763
|
/**
|
|
926
764
|
* @param {string} id
|
|
@@ -946,370 +784,364 @@ export class Fleet {
|
|
|
946
784
|
const ret = wasm.fleet_get_remaining_fuel(this.__wbg_ptr, ptr0, len0, rate, ceil);
|
|
947
785
|
return ret === 0xFFFFFF ? undefined : ret;
|
|
948
786
|
}
|
|
949
|
-
|
|
950
|
-
|
|
787
|
+
/**
|
|
788
|
+
* @param {ShipKey} key
|
|
789
|
+
* @returns {Ship | undefined}
|
|
790
|
+
*/
|
|
791
|
+
get_ship(key) {
|
|
792
|
+
const ret = wasm.fleet_get_ship(this.__wbg_ptr, key);
|
|
793
|
+
if (ret[2]) {
|
|
794
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
795
|
+
}
|
|
796
|
+
return ret[0] === 0 ? undefined : Ship.__wrap(ret[0]);
|
|
951
797
|
}
|
|
952
798
|
/**
|
|
953
|
-
*
|
|
954
|
-
* @returns {number | undefined}
|
|
799
|
+
* @returns {FleetMeta}
|
|
955
800
|
*/
|
|
956
|
-
|
|
957
|
-
const ret = wasm.
|
|
958
|
-
|
|
801
|
+
meta() {
|
|
802
|
+
const ret = wasm.fleet_meta(this.__wbg_ptr);
|
|
803
|
+
if (ret[2]) {
|
|
804
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
805
|
+
}
|
|
806
|
+
return takeFromExternrefTable0(ret[0]);
|
|
807
|
+
}
|
|
808
|
+
reset_battle_state() {
|
|
809
|
+
wasm.fleet_reset_battle_state(this.__wbg_ptr);
|
|
959
810
|
}
|
|
960
811
|
/**
|
|
961
812
|
* @returns {string[]}
|
|
962
813
|
*/
|
|
963
|
-
|
|
964
|
-
const ret = wasm.
|
|
965
|
-
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1])
|
|
814
|
+
ship_ids() {
|
|
815
|
+
const ret = wasm.fleet_ship_ids(this.__wbg_ptr);
|
|
816
|
+
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
|
|
966
817
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
967
818
|
return v1;
|
|
968
819
|
}
|
|
969
820
|
/**
|
|
970
821
|
* @returns {string[]}
|
|
971
822
|
*/
|
|
972
|
-
|
|
973
|
-
const ret = wasm.
|
|
974
|
-
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1])
|
|
823
|
+
ship_keys() {
|
|
824
|
+
const ret = wasm.fleet_ship_keys(this.__wbg_ptr);
|
|
825
|
+
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
|
|
975
826
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
976
827
|
return v1;
|
|
977
828
|
}
|
|
978
829
|
/**
|
|
979
|
-
*
|
|
980
|
-
* @param {number} hq_level
|
|
981
|
-
* @param {number} node_divaricated_factor
|
|
830
|
+
* @param {string} key
|
|
982
831
|
* @returns {number | undefined}
|
|
983
832
|
*/
|
|
984
|
-
|
|
985
|
-
const
|
|
833
|
+
sum_ship_stat_by(key) {
|
|
834
|
+
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
835
|
+
const len0 = WASM_VECTOR_LEN;
|
|
836
|
+
const ret = wasm.fleet_sum_ship_stat_by(this.__wbg_ptr, ptr0, len0);
|
|
986
837
|
return ret[0] === 0 ? undefined : ret[1];
|
|
987
838
|
}
|
|
988
839
|
/**
|
|
989
|
-
* @returns {
|
|
840
|
+
* @returns {bigint}
|
|
990
841
|
*/
|
|
991
|
-
|
|
992
|
-
const ret = wasm.
|
|
993
|
-
return ret;
|
|
842
|
+
get hash() {
|
|
843
|
+
const ret = wasm.__wbg_get_fleet_hash(this.__wbg_ptr);
|
|
844
|
+
return BigInt.asUintN(64, ret);
|
|
994
845
|
}
|
|
995
846
|
/**
|
|
996
|
-
* @
|
|
997
|
-
* @returns {Ship | undefined}
|
|
847
|
+
* @returns {string}
|
|
998
848
|
*/
|
|
999
|
-
|
|
1000
|
-
|
|
1001
|
-
|
|
849
|
+
get id() {
|
|
850
|
+
let deferred1_0;
|
|
851
|
+
let deferred1_1;
|
|
852
|
+
try {
|
|
853
|
+
const ret = wasm.__wbg_get_fleet_id(this.__wbg_ptr);
|
|
854
|
+
deferred1_0 = ret[0];
|
|
855
|
+
deferred1_1 = ret[1];
|
|
856
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
857
|
+
} finally {
|
|
858
|
+
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
859
|
+
}
|
|
1002
860
|
}
|
|
1003
861
|
/**
|
|
1004
|
-
* @returns {
|
|
862
|
+
* @returns {number}
|
|
1005
863
|
*/
|
|
1006
|
-
|
|
1007
|
-
const ret = wasm.
|
|
1008
|
-
|
|
1009
|
-
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
1010
|
-
return v1;
|
|
864
|
+
get len() {
|
|
865
|
+
const ret = wasm.__wbg_get_fleet_len(this.__wbg_ptr);
|
|
866
|
+
return ret >>> 0;
|
|
1011
867
|
}
|
|
1012
868
|
/**
|
|
1013
|
-
* @
|
|
869
|
+
* @param {string} arg0
|
|
1014
870
|
*/
|
|
1015
|
-
|
|
1016
|
-
const
|
|
1017
|
-
|
|
1018
|
-
wasm.
|
|
1019
|
-
return v1;
|
|
871
|
+
set id(arg0) {
|
|
872
|
+
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
873
|
+
const len0 = WASM_VECTOR_LEN;
|
|
874
|
+
wasm.__wbg_set_fleet_id(this.__wbg_ptr, ptr0, len0);
|
|
1020
875
|
}
|
|
1021
876
|
}
|
|
1022
877
|
if (Symbol.dispose) Fleet.prototype[Symbol.dispose] = Fleet.prototype.free;
|
|
1023
878
|
|
|
1024
|
-
const GearFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
1025
|
-
? { register: () => {}, unregister: () => {} }
|
|
1026
|
-
: new FinalizationRegistry(ptr => wasm.__wbg_gear_free(ptr >>> 0, 1));
|
|
1027
|
-
|
|
1028
879
|
export class Gear {
|
|
1029
|
-
|
|
1030
880
|
static __wrap(ptr) {
|
|
1031
|
-
ptr = ptr >>> 0;
|
|
1032
881
|
const obj = Object.create(Gear.prototype);
|
|
1033
882
|
obj.__wbg_ptr = ptr;
|
|
1034
883
|
GearFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1035
884
|
return obj;
|
|
1036
885
|
}
|
|
1037
|
-
|
|
1038
886
|
__destroy_into_raw() {
|
|
1039
887
|
const ptr = this.__wbg_ptr;
|
|
1040
888
|
this.__wbg_ptr = 0;
|
|
1041
889
|
GearFinalization.unregister(this);
|
|
1042
890
|
return ptr;
|
|
1043
891
|
}
|
|
1044
|
-
|
|
1045
892
|
free() {
|
|
1046
893
|
const ptr = this.__destroy_into_raw();
|
|
1047
894
|
wasm.__wbg_gear_free(ptr, 0);
|
|
1048
895
|
}
|
|
1049
896
|
/**
|
|
1050
|
-
* @returns {
|
|
1051
|
-
*/
|
|
1052
|
-
get id() {
|
|
1053
|
-
let deferred1_0;
|
|
1054
|
-
let deferred1_1;
|
|
1055
|
-
try {
|
|
1056
|
-
const ret = wasm.__wbg_get_gear_id(this.__wbg_ptr);
|
|
1057
|
-
deferred1_0 = ret[0];
|
|
1058
|
-
deferred1_1 = ret[1];
|
|
1059
|
-
return getStringFromWasm0(ret[0], ret[1]);
|
|
1060
|
-
} finally {
|
|
1061
|
-
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
1062
|
-
}
|
|
1063
|
-
}
|
|
1064
|
-
/**
|
|
1065
|
-
* @param {string} arg0
|
|
897
|
+
* @returns {number}
|
|
1066
898
|
*/
|
|
1067
|
-
|
|
1068
|
-
const
|
|
1069
|
-
|
|
1070
|
-
wasm.__wbg_set_gear_id(this.__wbg_ptr, ptr0, len0);
|
|
899
|
+
get ace() {
|
|
900
|
+
const ret = wasm.gear_ace(this.__wbg_ptr);
|
|
901
|
+
return ret;
|
|
1071
902
|
}
|
|
1072
903
|
/**
|
|
1073
|
-
* @returns {
|
|
904
|
+
* @returns {number}
|
|
1074
905
|
*/
|
|
1075
|
-
get
|
|
1076
|
-
const ret = wasm.
|
|
1077
|
-
return
|
|
906
|
+
get anti_bomber() {
|
|
907
|
+
const ret = wasm.gear_anti_bomber(this.__wbg_ptr);
|
|
908
|
+
return ret;
|
|
1078
909
|
}
|
|
1079
910
|
/**
|
|
911
|
+
* @param {number} slot_size
|
|
1080
912
|
* @returns {number}
|
|
1081
913
|
*/
|
|
1082
|
-
|
|
1083
|
-
const ret = wasm.
|
|
914
|
+
calc_contact_trigger_factor(slot_size) {
|
|
915
|
+
const ret = wasm.gear_calc_contact_trigger_factor(this.__wbg_ptr, slot_size);
|
|
1084
916
|
return ret;
|
|
1085
917
|
}
|
|
1086
918
|
/**
|
|
919
|
+
* @param {number} slot_size
|
|
1087
920
|
* @returns {number}
|
|
1088
921
|
*/
|
|
1089
|
-
|
|
1090
|
-
const ret = wasm.
|
|
922
|
+
calc_fighter_power(slot_size) {
|
|
923
|
+
const ret = wasm.gear_calc_fighter_power(this.__wbg_ptr, slot_size);
|
|
1091
924
|
return ret;
|
|
1092
925
|
}
|
|
1093
926
|
/**
|
|
927
|
+
* @param {number} slot_size
|
|
1094
928
|
* @returns {number}
|
|
1095
929
|
*/
|
|
1096
|
-
|
|
1097
|
-
const ret = wasm.
|
|
930
|
+
calc_interception_power(slot_size) {
|
|
931
|
+
const ret = wasm.gear_calc_interception_power(this.__wbg_ptr, slot_size);
|
|
1098
932
|
return ret;
|
|
1099
933
|
}
|
|
1100
934
|
/**
|
|
1101
|
-
* @returns {
|
|
935
|
+
* @returns {boolean}
|
|
1102
936
|
*/
|
|
1103
|
-
|
|
1104
|
-
const ret = wasm.
|
|
1105
|
-
return ret;
|
|
937
|
+
can_be_deployed_to_land_base() {
|
|
938
|
+
const ret = wasm.gear_can_be_deployed_to_land_base(this.__wbg_ptr);
|
|
939
|
+
return ret !== 0;
|
|
1106
940
|
}
|
|
1107
941
|
/**
|
|
1108
|
-
* @returns {
|
|
942
|
+
* @returns {GearCategory}
|
|
1109
943
|
*/
|
|
1110
|
-
|
|
1111
|
-
|
|
1112
|
-
|
|
1113
|
-
|
|
1114
|
-
const ret = wasm.__wbg_get_gear_name(this.__wbg_ptr);
|
|
1115
|
-
deferred1_0 = ret[0];
|
|
1116
|
-
deferred1_1 = ret[1];
|
|
1117
|
-
return getStringFromWasm0(ret[0], ret[1]);
|
|
1118
|
-
} finally {
|
|
1119
|
-
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
944
|
+
category() {
|
|
945
|
+
const ret = wasm.gear_category(this.__wbg_ptr);
|
|
946
|
+
if (ret[2]) {
|
|
947
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1120
948
|
}
|
|
949
|
+
return takeFromExternrefTable0(ret[0]);
|
|
1121
950
|
}
|
|
1122
951
|
/**
|
|
1123
|
-
* @param {
|
|
952
|
+
* @param {AirStateRank} rank
|
|
953
|
+
* @returns {number}
|
|
1124
954
|
*/
|
|
1125
|
-
|
|
1126
|
-
const
|
|
1127
|
-
|
|
1128
|
-
|
|
955
|
+
contact_selection_rate(rank) {
|
|
956
|
+
const ret = wasm.gear_contact_selection_rate(this.__wbg_ptr, rank);
|
|
957
|
+
if (ret[2]) {
|
|
958
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
959
|
+
}
|
|
960
|
+
return ret[0];
|
|
1129
961
|
}
|
|
1130
962
|
/**
|
|
1131
|
-
* @returns {
|
|
963
|
+
* @returns {Gear}
|
|
1132
964
|
*/
|
|
1133
|
-
|
|
1134
|
-
const ret = wasm.
|
|
1135
|
-
|
|
1136
|
-
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
1137
|
-
return v1;
|
|
1138
|
-
}
|
|
1139
|
-
/**
|
|
1140
|
-
* @param {Uint8Array} arg0
|
|
1141
|
-
*/
|
|
1142
|
-
set types(arg0) {
|
|
1143
|
-
const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
|
|
1144
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1145
|
-
wasm.__wbg_set_gear_types(this.__wbg_ptr, ptr0, len0);
|
|
965
|
+
static default() {
|
|
966
|
+
const ret = wasm.gear_default();
|
|
967
|
+
return Gear.__wrap(ret);
|
|
1146
968
|
}
|
|
1147
969
|
/**
|
|
1148
|
-
* @returns {
|
|
970
|
+
* @returns {number}
|
|
1149
971
|
*/
|
|
1150
|
-
|
|
1151
|
-
const ret = wasm.
|
|
972
|
+
elos() {
|
|
973
|
+
const ret = wasm.gear_elos(this.__wbg_ptr);
|
|
1152
974
|
return ret;
|
|
1153
975
|
}
|
|
1154
976
|
/**
|
|
1155
977
|
* @returns {number}
|
|
1156
978
|
*/
|
|
1157
|
-
|
|
1158
|
-
const ret = wasm.
|
|
979
|
+
expedition_bonus() {
|
|
980
|
+
const ret = wasm.gear_expedition_bonus(this.__wbg_ptr);
|
|
1159
981
|
return ret;
|
|
1160
982
|
}
|
|
1161
983
|
/**
|
|
1162
984
|
* @returns {number}
|
|
1163
985
|
*/
|
|
1164
|
-
|
|
1165
|
-
const ret = wasm.
|
|
986
|
+
fleet_anti_air_mod() {
|
|
987
|
+
const ret = wasm.gear_fleet_anti_air_mod(this.__wbg_ptr);
|
|
1166
988
|
return ret;
|
|
1167
989
|
}
|
|
1168
990
|
/**
|
|
1169
991
|
* @returns {number}
|
|
1170
992
|
*/
|
|
1171
|
-
get
|
|
1172
|
-
const ret = wasm.
|
|
993
|
+
get gear_type_id() {
|
|
994
|
+
const ret = wasm.gear_gear_type_id(this.__wbg_ptr);
|
|
1173
995
|
return ret;
|
|
1174
996
|
}
|
|
1175
997
|
/**
|
|
1176
|
-
* @returns {
|
|
998
|
+
* @returns {GearType}
|
|
1177
999
|
*/
|
|
1178
|
-
get
|
|
1179
|
-
const ret = wasm.
|
|
1180
|
-
|
|
1000
|
+
get gear_type() {
|
|
1001
|
+
const ret = wasm.gear_gear_type_js(this.__wbg_ptr);
|
|
1002
|
+
if (ret[2]) {
|
|
1003
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1004
|
+
}
|
|
1005
|
+
return takeFromExternrefTable0(ret[0]);
|
|
1181
1006
|
}
|
|
1182
1007
|
/**
|
|
1183
|
-
* @
|
|
1008
|
+
* @param {GearAttr} attr
|
|
1009
|
+
* @returns {boolean}
|
|
1184
1010
|
*/
|
|
1185
|
-
|
|
1186
|
-
const ret = wasm.
|
|
1187
|
-
|
|
1011
|
+
has_attr(attr) {
|
|
1012
|
+
const ret = wasm.gear_has_attr(this.__wbg_ptr, attr);
|
|
1013
|
+
if (ret[2]) {
|
|
1014
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1015
|
+
}
|
|
1016
|
+
return ret[0] !== 0;
|
|
1188
1017
|
}
|
|
1189
1018
|
/**
|
|
1190
|
-
* @returns {
|
|
1019
|
+
* @returns {boolean}
|
|
1191
1020
|
*/
|
|
1192
|
-
|
|
1193
|
-
const ret = wasm.
|
|
1194
|
-
return ret;
|
|
1021
|
+
has_proficiency() {
|
|
1022
|
+
const ret = wasm.gear_has_proficiency(this.__wbg_ptr);
|
|
1023
|
+
return ret !== 0;
|
|
1195
1024
|
}
|
|
1196
1025
|
/**
|
|
1197
1026
|
* @returns {number}
|
|
1198
1027
|
*/
|
|
1199
|
-
get
|
|
1200
|
-
const ret = wasm.
|
|
1028
|
+
get icon_id() {
|
|
1029
|
+
const ret = wasm.gear_icon_id(this.__wbg_ptr);
|
|
1201
1030
|
return ret;
|
|
1202
1031
|
}
|
|
1203
1032
|
/**
|
|
1204
1033
|
* @returns {number}
|
|
1205
1034
|
*/
|
|
1206
|
-
get
|
|
1207
|
-
const ret = wasm.
|
|
1035
|
+
get interception() {
|
|
1036
|
+
const ret = wasm.gear_interception(this.__wbg_ptr);
|
|
1208
1037
|
return ret;
|
|
1209
1038
|
}
|
|
1210
1039
|
/**
|
|
1211
|
-
* @returns {
|
|
1040
|
+
* @returns {boolean}
|
|
1212
1041
|
*/
|
|
1213
|
-
|
|
1214
|
-
const ret = wasm.
|
|
1215
|
-
return ret;
|
|
1042
|
+
is_abyssal() {
|
|
1043
|
+
const ret = wasm.gear_is_abyssal(this.__wbg_ptr);
|
|
1044
|
+
return ret !== 0;
|
|
1216
1045
|
}
|
|
1217
1046
|
/**
|
|
1218
|
-
* @returns {
|
|
1047
|
+
* @returns {boolean}
|
|
1219
1048
|
*/
|
|
1220
|
-
|
|
1221
|
-
const ret = wasm.
|
|
1222
|
-
return ret;
|
|
1049
|
+
is_abyssal_cuttlefish_torpedo() {
|
|
1050
|
+
const ret = wasm.gear_is_abyssal_cuttlefish_torpedo(this.__wbg_ptr);
|
|
1051
|
+
return ret !== 0;
|
|
1223
1052
|
}
|
|
1224
1053
|
/**
|
|
1225
|
-
* @returns {
|
|
1054
|
+
* @returns {boolean}
|
|
1226
1055
|
*/
|
|
1227
|
-
|
|
1228
|
-
const ret = wasm.
|
|
1229
|
-
return ret;
|
|
1056
|
+
is_abyssal_patrolling_attack_hawk() {
|
|
1057
|
+
const ret = wasm.gear_is_abyssal_patrolling_attack_hawk(this.__wbg_ptr);
|
|
1058
|
+
return ret !== 0;
|
|
1230
1059
|
}
|
|
1231
1060
|
/**
|
|
1232
|
-
* @returns {
|
|
1061
|
+
* @returns {boolean}
|
|
1233
1062
|
*/
|
|
1234
|
-
|
|
1235
|
-
const ret = wasm.
|
|
1236
|
-
return ret;
|
|
1063
|
+
is_balloon() {
|
|
1064
|
+
const ret = wasm.gear_is_balloon(this.__wbg_ptr);
|
|
1065
|
+
return ret !== 0;
|
|
1237
1066
|
}
|
|
1238
1067
|
/**
|
|
1239
|
-
* @returns {
|
|
1068
|
+
* @returns {boolean}
|
|
1240
1069
|
*/
|
|
1241
|
-
|
|
1242
|
-
const ret = wasm.
|
|
1243
|
-
return ret;
|
|
1070
|
+
is_carrier_shelling_plane() {
|
|
1071
|
+
const ret = wasm.gear_is_carrier_shelling_plane(this.__wbg_ptr);
|
|
1072
|
+
return ret !== 0;
|
|
1244
1073
|
}
|
|
1245
1074
|
/**
|
|
1246
|
-
* @returns {
|
|
1075
|
+
* @returns {boolean}
|
|
1247
1076
|
*/
|
|
1248
|
-
|
|
1249
|
-
const ret = wasm.
|
|
1250
|
-
return ret;
|
|
1077
|
+
is_hayabusa_20th_squadron() {
|
|
1078
|
+
const ret = wasm.gear_is_hayabusa_20th_squadron(this.__wbg_ptr);
|
|
1079
|
+
return ret !== 0;
|
|
1251
1080
|
}
|
|
1252
1081
|
/**
|
|
1253
|
-
* @returns {
|
|
1082
|
+
* @returns {boolean}
|
|
1254
1083
|
*/
|
|
1255
|
-
|
|
1256
|
-
const ret = wasm.
|
|
1257
|
-
return ret;
|
|
1084
|
+
is_high_angle_mount() {
|
|
1085
|
+
const ret = wasm.gear_is_high_angle_mount(this.__wbg_ptr);
|
|
1086
|
+
return ret !== 0;
|
|
1258
1087
|
}
|
|
1259
1088
|
/**
|
|
1260
1089
|
* @returns {boolean}
|
|
1261
1090
|
*/
|
|
1262
|
-
|
|
1263
|
-
const ret = wasm.
|
|
1091
|
+
is_night_attacker() {
|
|
1092
|
+
const ret = wasm.gear_is_night_attacker(this.__wbg_ptr);
|
|
1264
1093
|
return ret !== 0;
|
|
1265
1094
|
}
|
|
1266
1095
|
/**
|
|
1267
|
-
* @returns {
|
|
1096
|
+
* @returns {boolean}
|
|
1268
1097
|
*/
|
|
1269
|
-
|
|
1270
|
-
const ret = wasm.
|
|
1271
|
-
return ret;
|
|
1098
|
+
is_night_bomber() {
|
|
1099
|
+
const ret = wasm.gear_is_night_bomber(this.__wbg_ptr);
|
|
1100
|
+
return ret !== 0;
|
|
1272
1101
|
}
|
|
1273
1102
|
/**
|
|
1274
|
-
* @returns {
|
|
1103
|
+
* @returns {boolean}
|
|
1275
1104
|
*/
|
|
1276
|
-
|
|
1277
|
-
const ret = wasm.
|
|
1278
|
-
return ret;
|
|
1105
|
+
is_night_fighter() {
|
|
1106
|
+
const ret = wasm.gear_is_night_fighter(this.__wbg_ptr);
|
|
1107
|
+
return ret !== 0;
|
|
1279
1108
|
}
|
|
1280
1109
|
/**
|
|
1281
1110
|
* @returns {boolean}
|
|
1282
1111
|
*/
|
|
1283
|
-
|
|
1284
|
-
const ret = wasm.
|
|
1112
|
+
is_night_plane() {
|
|
1113
|
+
const ret = wasm.gear_is_night_plane(this.__wbg_ptr);
|
|
1285
1114
|
return ret !== 0;
|
|
1286
1115
|
}
|
|
1287
1116
|
/**
|
|
1288
1117
|
* @returns {boolean}
|
|
1289
1118
|
*/
|
|
1290
|
-
|
|
1291
|
-
const ret = wasm.
|
|
1119
|
+
max_exp_eq_120() {
|
|
1120
|
+
const ret = wasm.gear_max_exp_eq_120(this.__wbg_ptr);
|
|
1292
1121
|
return ret !== 0;
|
|
1293
1122
|
}
|
|
1294
1123
|
/**
|
|
1124
|
+
* @param {number} level
|
|
1295
1125
|
* @returns {number}
|
|
1296
1126
|
*/
|
|
1297
|
-
|
|
1298
|
-
const ret = wasm.
|
|
1127
|
+
night_contact_rate(level) {
|
|
1128
|
+
const ret = wasm.gear_night_contact_rate(this.__wbg_ptr, level);
|
|
1299
1129
|
return ret;
|
|
1300
1130
|
}
|
|
1301
1131
|
/**
|
|
1132
|
+
* @param {number} slot_size
|
|
1133
|
+
* @param {boolean} anti_inst
|
|
1302
1134
|
* @returns {number}
|
|
1303
1135
|
*/
|
|
1304
|
-
|
|
1305
|
-
const ret = wasm.
|
|
1136
|
+
night_plane_power(slot_size, anti_inst) {
|
|
1137
|
+
const ret = wasm.gear_night_plane_power(this.__wbg_ptr, slot_size, anti_inst);
|
|
1306
1138
|
return ret;
|
|
1307
1139
|
}
|
|
1308
1140
|
/**
|
|
1309
1141
|
* @returns {number}
|
|
1310
1142
|
*/
|
|
1311
|
-
|
|
1312
|
-
const ret = wasm.
|
|
1143
|
+
ship_anti_air_mod() {
|
|
1144
|
+
const ret = wasm.gear_ship_anti_air_mod(this.__wbg_ptr);
|
|
1313
1145
|
return ret;
|
|
1314
1146
|
}
|
|
1315
1147
|
/**
|
|
@@ -1320,258 +1152,254 @@ export class Gear {
|
|
|
1320
1152
|
return ret;
|
|
1321
1153
|
}
|
|
1322
1154
|
/**
|
|
1323
|
-
* @returns {
|
|
1324
|
-
*/
|
|
1325
|
-
is_night_plane() {
|
|
1326
|
-
const ret = wasm.gear_is_night_plane(this.__wbg_ptr);
|
|
1327
|
-
return ret !== 0;
|
|
1328
|
-
}
|
|
1329
|
-
/**
|
|
1330
|
-
* @returns {boolean}
|
|
1331
|
-
*/
|
|
1332
|
-
max_exp_eq_120() {
|
|
1333
|
-
const ret = wasm.gear_max_exp_eq_120(this.__wbg_ptr);
|
|
1334
|
-
return ret !== 0;
|
|
1335
|
-
}
|
|
1336
|
-
/**
|
|
1337
|
-
* @returns {boolean}
|
|
1338
|
-
*/
|
|
1339
|
-
has_proficiency() {
|
|
1340
|
-
const ret = wasm.gear_can_be_deployed_to_land_base(this.__wbg_ptr);
|
|
1341
|
-
return ret !== 0;
|
|
1342
|
-
}
|
|
1343
|
-
/**
|
|
1344
|
-
* @returns {boolean}
|
|
1155
|
+
* @returns {number}
|
|
1345
1156
|
*/
|
|
1346
|
-
|
|
1347
|
-
const ret = wasm.
|
|
1348
|
-
return ret
|
|
1157
|
+
get accuracy() {
|
|
1158
|
+
const ret = wasm.__wbg_get_gear_accuracy(this.__wbg_ptr);
|
|
1159
|
+
return ret;
|
|
1349
1160
|
}
|
|
1350
1161
|
/**
|
|
1351
1162
|
* @returns {number}
|
|
1352
1163
|
*/
|
|
1353
|
-
|
|
1354
|
-
const ret = wasm.
|
|
1164
|
+
get anti_air() {
|
|
1165
|
+
const ret = wasm.__wbg_get_gear_anti_air(this.__wbg_ptr);
|
|
1355
1166
|
return ret;
|
|
1356
1167
|
}
|
|
1357
1168
|
/**
|
|
1358
|
-
* @returns {
|
|
1169
|
+
* @returns {number}
|
|
1359
1170
|
*/
|
|
1360
|
-
|
|
1361
|
-
const ret = wasm.
|
|
1362
|
-
return ret
|
|
1171
|
+
get armor() {
|
|
1172
|
+
const ret = wasm.__wbg_get_gear_armor(this.__wbg_ptr);
|
|
1173
|
+
return ret;
|
|
1363
1174
|
}
|
|
1364
1175
|
/**
|
|
1365
|
-
* @returns {
|
|
1176
|
+
* @returns {number}
|
|
1366
1177
|
*/
|
|
1367
|
-
|
|
1368
|
-
const ret = wasm.
|
|
1369
|
-
return ret
|
|
1178
|
+
get asw() {
|
|
1179
|
+
const ret = wasm.__wbg_get_gear_asw(this.__wbg_ptr);
|
|
1180
|
+
return ret;
|
|
1370
1181
|
}
|
|
1371
1182
|
/**
|
|
1372
|
-
* @param {number} slot_size
|
|
1373
|
-
* @param {boolean} anti_inst
|
|
1374
1183
|
* @returns {number}
|
|
1375
1184
|
*/
|
|
1376
|
-
|
|
1377
|
-
const ret = wasm.
|
|
1185
|
+
get bombing() {
|
|
1186
|
+
const ret = wasm.__wbg_get_gear_bombing(this.__wbg_ptr);
|
|
1378
1187
|
return ret;
|
|
1379
1188
|
}
|
|
1380
1189
|
/**
|
|
1381
1190
|
* @returns {number}
|
|
1382
1191
|
*/
|
|
1383
|
-
|
|
1384
|
-
const ret = wasm.
|
|
1192
|
+
get cost() {
|
|
1193
|
+
const ret = wasm.__wbg_get_gear_cost(this.__wbg_ptr);
|
|
1385
1194
|
return ret;
|
|
1386
1195
|
}
|
|
1387
1196
|
/**
|
|
1388
|
-
* @param {number} slot_size
|
|
1389
1197
|
* @returns {number}
|
|
1390
1198
|
*/
|
|
1391
|
-
|
|
1392
|
-
const ret = wasm.
|
|
1199
|
+
get default_exp() {
|
|
1200
|
+
const ret = wasm.__wbg_get_gear_default_exp(this.__wbg_ptr);
|
|
1393
1201
|
return ret;
|
|
1394
1202
|
}
|
|
1395
1203
|
/**
|
|
1396
1204
|
* @returns {number}
|
|
1397
1205
|
*/
|
|
1398
|
-
|
|
1399
|
-
const ret = wasm.
|
|
1206
|
+
get evasion() {
|
|
1207
|
+
const ret = wasm.__wbg_get_gear_evasion(this.__wbg_ptr);
|
|
1400
1208
|
return ret;
|
|
1401
1209
|
}
|
|
1402
1210
|
/**
|
|
1403
|
-
* @param {number} level
|
|
1404
1211
|
* @returns {number}
|
|
1405
1212
|
*/
|
|
1406
|
-
|
|
1407
|
-
const ret = wasm.
|
|
1213
|
+
get exp() {
|
|
1214
|
+
const ret = wasm.__wbg_get_gear_exp(this.__wbg_ptr);
|
|
1408
1215
|
return ret;
|
|
1409
1216
|
}
|
|
1410
1217
|
/**
|
|
1411
|
-
* @returns {
|
|
1218
|
+
* @returns {number}
|
|
1412
1219
|
*/
|
|
1413
|
-
|
|
1414
|
-
const ret = wasm.
|
|
1415
|
-
return ret
|
|
1220
|
+
get firepower() {
|
|
1221
|
+
const ret = wasm.__wbg_get_gear_firepower(this.__wbg_ptr);
|
|
1222
|
+
return ret;
|
|
1416
1223
|
}
|
|
1417
1224
|
/**
|
|
1418
|
-
* @param {AirStateRank} rank
|
|
1419
1225
|
* @returns {number}
|
|
1420
1226
|
*/
|
|
1421
|
-
|
|
1422
|
-
const ret = wasm.
|
|
1227
|
+
get fleet_anti_air_resist() {
|
|
1228
|
+
const ret = wasm.__wbg_get_gear_fleet_anti_air_resist(this.__wbg_ptr);
|
|
1423
1229
|
return ret;
|
|
1424
1230
|
}
|
|
1425
1231
|
/**
|
|
1426
|
-
* @param {number} slot_size
|
|
1427
1232
|
* @returns {number}
|
|
1428
1233
|
*/
|
|
1429
|
-
|
|
1430
|
-
const ret = wasm.
|
|
1234
|
+
get gear_id() {
|
|
1235
|
+
const ret = wasm.__wbg_get_gear_gear_id(this.__wbg_ptr);
|
|
1431
1236
|
return ret;
|
|
1432
1237
|
}
|
|
1433
1238
|
/**
|
|
1434
|
-
* @returns {
|
|
1239
|
+
* @returns {bigint}
|
|
1435
1240
|
*/
|
|
1436
|
-
|
|
1437
|
-
const ret = wasm.
|
|
1438
|
-
return ret
|
|
1241
|
+
get hash() {
|
|
1242
|
+
const ret = wasm.__wbg_get_gear_hash(this.__wbg_ptr);
|
|
1243
|
+
return BigInt.asUintN(64, ret);
|
|
1244
|
+
}
|
|
1245
|
+
/**
|
|
1246
|
+
* @returns {string}
|
|
1247
|
+
*/
|
|
1248
|
+
get id() {
|
|
1249
|
+
let deferred1_0;
|
|
1250
|
+
let deferred1_1;
|
|
1251
|
+
try {
|
|
1252
|
+
const ret = wasm.__wbg_get_gear_id(this.__wbg_ptr);
|
|
1253
|
+
deferred1_0 = ret[0];
|
|
1254
|
+
deferred1_1 = ret[1];
|
|
1255
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
1256
|
+
} finally {
|
|
1257
|
+
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
1258
|
+
}
|
|
1439
1259
|
}
|
|
1440
1260
|
/**
|
|
1441
1261
|
* @returns {boolean}
|
|
1442
1262
|
*/
|
|
1443
|
-
|
|
1444
|
-
const ret = wasm.
|
|
1263
|
+
get improvable() {
|
|
1264
|
+
const ret = wasm.__wbg_get_gear_improvable(this.__wbg_ptr);
|
|
1445
1265
|
return ret !== 0;
|
|
1446
1266
|
}
|
|
1447
1267
|
/**
|
|
1448
|
-
* @param {number} slot_size
|
|
1449
1268
|
* @returns {number}
|
|
1450
1269
|
*/
|
|
1451
|
-
|
|
1452
|
-
const ret = wasm.
|
|
1270
|
+
get los() {
|
|
1271
|
+
const ret = wasm.__wbg_get_gear_los(this.__wbg_ptr);
|
|
1453
1272
|
return ret;
|
|
1454
1273
|
}
|
|
1455
1274
|
/**
|
|
1456
|
-
* @returns {
|
|
1275
|
+
* @returns {number}
|
|
1457
1276
|
*/
|
|
1458
|
-
|
|
1459
|
-
const ret = wasm.
|
|
1460
|
-
return ret
|
|
1277
|
+
get luck() {
|
|
1278
|
+
const ret = wasm.__wbg_get_gear_luck(this.__wbg_ptr);
|
|
1279
|
+
return ret;
|
|
1461
1280
|
}
|
|
1462
1281
|
/**
|
|
1463
|
-
* @returns {
|
|
1282
|
+
* @returns {number}
|
|
1464
1283
|
*/
|
|
1465
|
-
|
|
1466
|
-
const ret = wasm.
|
|
1467
|
-
return ret
|
|
1284
|
+
get max_hp() {
|
|
1285
|
+
const ret = wasm.__wbg_get_gear_max_hp(this.__wbg_ptr);
|
|
1286
|
+
return ret;
|
|
1468
1287
|
}
|
|
1469
1288
|
/**
|
|
1470
|
-
* @returns {
|
|
1289
|
+
* @returns {string}
|
|
1471
1290
|
*/
|
|
1472
|
-
|
|
1473
|
-
|
|
1474
|
-
|
|
1291
|
+
get name() {
|
|
1292
|
+
let deferred1_0;
|
|
1293
|
+
let deferred1_1;
|
|
1294
|
+
try {
|
|
1295
|
+
const ret = wasm.__wbg_get_gear_name(this.__wbg_ptr);
|
|
1296
|
+
deferred1_0 = ret[0];
|
|
1297
|
+
deferred1_1 = ret[1];
|
|
1298
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
1299
|
+
} finally {
|
|
1300
|
+
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
1301
|
+
}
|
|
1475
1302
|
}
|
|
1476
1303
|
/**
|
|
1477
1304
|
* @returns {number}
|
|
1478
1305
|
*/
|
|
1479
|
-
get
|
|
1480
|
-
const ret = wasm.
|
|
1306
|
+
get radius() {
|
|
1307
|
+
const ret = wasm.__wbg_get_gear_radius(this.__wbg_ptr);
|
|
1481
1308
|
return ret;
|
|
1482
1309
|
}
|
|
1483
1310
|
/**
|
|
1484
1311
|
* @returns {number}
|
|
1485
1312
|
*/
|
|
1486
|
-
|
|
1487
|
-
const ret = wasm.
|
|
1313
|
+
get range() {
|
|
1314
|
+
const ret = wasm.__wbg_get_gear_range(this.__wbg_ptr);
|
|
1488
1315
|
return ret;
|
|
1489
1316
|
}
|
|
1490
1317
|
/**
|
|
1491
|
-
* @returns {
|
|
1318
|
+
* @returns {number}
|
|
1492
1319
|
*/
|
|
1493
|
-
|
|
1494
|
-
const ret = wasm.
|
|
1495
|
-
return
|
|
1320
|
+
get ship_anti_air_resist() {
|
|
1321
|
+
const ret = wasm.__wbg_get_gear_ship_anti_air_resist(this.__wbg_ptr);
|
|
1322
|
+
return ret;
|
|
1496
1323
|
}
|
|
1497
1324
|
/**
|
|
1498
1325
|
* @returns {number}
|
|
1499
1326
|
*/
|
|
1500
|
-
get
|
|
1501
|
-
const ret = wasm.
|
|
1327
|
+
get speed() {
|
|
1328
|
+
const ret = wasm.__wbg_get_gear_speed(this.__wbg_ptr);
|
|
1502
1329
|
return ret;
|
|
1503
1330
|
}
|
|
1504
1331
|
/**
|
|
1505
|
-
* @returns {
|
|
1332
|
+
* @returns {number}
|
|
1506
1333
|
*/
|
|
1507
|
-
|
|
1508
|
-
const ret = wasm.
|
|
1334
|
+
get stars() {
|
|
1335
|
+
const ret = wasm.__wbg_get_gear_stars(this.__wbg_ptr);
|
|
1509
1336
|
return ret;
|
|
1510
1337
|
}
|
|
1511
1338
|
/**
|
|
1512
|
-
* @
|
|
1513
|
-
* @returns {boolean}
|
|
1339
|
+
* @returns {number}
|
|
1514
1340
|
*/
|
|
1515
|
-
|
|
1516
|
-
const ret = wasm.
|
|
1517
|
-
return ret
|
|
1341
|
+
get torpedo() {
|
|
1342
|
+
const ret = wasm.__wbg_get_gear_torpedo(this.__wbg_ptr);
|
|
1343
|
+
return ret;
|
|
1344
|
+
}
|
|
1345
|
+
/**
|
|
1346
|
+
* @returns {Uint8Array}
|
|
1347
|
+
*/
|
|
1348
|
+
get types() {
|
|
1349
|
+
const ret = wasm.__wbg_get_gear_types(this.__wbg_ptr);
|
|
1350
|
+
var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
|
|
1351
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
1352
|
+
return v1;
|
|
1353
|
+
}
|
|
1354
|
+
/**
|
|
1355
|
+
* @param {string} arg0
|
|
1356
|
+
*/
|
|
1357
|
+
set id(arg0) {
|
|
1358
|
+
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1359
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1360
|
+
wasm.__wbg_set_gear_id(this.__wbg_ptr, ptr0, len0);
|
|
1361
|
+
}
|
|
1362
|
+
/**
|
|
1363
|
+
* @param {string} arg0
|
|
1364
|
+
*/
|
|
1365
|
+
set name(arg0) {
|
|
1366
|
+
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1367
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1368
|
+
wasm.__wbg_set_gear_name(this.__wbg_ptr, ptr0, len0);
|
|
1369
|
+
}
|
|
1370
|
+
/**
|
|
1371
|
+
* @param {Uint8Array} arg0
|
|
1372
|
+
*/
|
|
1373
|
+
set types(arg0) {
|
|
1374
|
+
const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
|
|
1375
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1376
|
+
wasm.__wbg_set_gear_types(this.__wbg_ptr, ptr0, len0);
|
|
1518
1377
|
}
|
|
1519
1378
|
}
|
|
1520
1379
|
if (Symbol.dispose) Gear.prototype[Symbol.dispose] = Gear.prototype.free;
|
|
1521
1380
|
|
|
1522
|
-
const OrgFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
1523
|
-
? { register: () => {}, unregister: () => {} }
|
|
1524
|
-
: new FinalizationRegistry(ptr => wasm.__wbg_org_free(ptr >>> 0, 1));
|
|
1525
|
-
|
|
1526
1381
|
export class Org {
|
|
1527
|
-
|
|
1528
1382
|
static __wrap(ptr) {
|
|
1529
|
-
ptr = ptr >>> 0;
|
|
1530
1383
|
const obj = Object.create(Org.prototype);
|
|
1531
1384
|
obj.__wbg_ptr = ptr;
|
|
1532
1385
|
OrgFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1533
1386
|
return obj;
|
|
1534
1387
|
}
|
|
1535
|
-
|
|
1536
1388
|
__destroy_into_raw() {
|
|
1537
1389
|
const ptr = this.__wbg_ptr;
|
|
1538
1390
|
this.__wbg_ptr = 0;
|
|
1539
1391
|
OrgFinalization.unregister(this);
|
|
1540
1392
|
return ptr;
|
|
1541
1393
|
}
|
|
1542
|
-
|
|
1543
1394
|
free() {
|
|
1544
1395
|
const ptr = this.__destroy_into_raw();
|
|
1545
1396
|
wasm.__wbg_org_free(ptr, 0);
|
|
1546
1397
|
}
|
|
1547
|
-
/**
|
|
1548
|
-
* @returns {string}
|
|
1549
|
-
*/
|
|
1550
|
-
get id() {
|
|
1551
|
-
let deferred1_0;
|
|
1552
|
-
let deferred1_1;
|
|
1553
|
-
try {
|
|
1554
|
-
const ret = wasm.__wbg_get_org_id(this.__wbg_ptr);
|
|
1555
|
-
deferred1_0 = ret[0];
|
|
1556
|
-
deferred1_1 = ret[1];
|
|
1557
|
-
return getStringFromWasm0(ret[0], ret[1]);
|
|
1558
|
-
} finally {
|
|
1559
|
-
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
1560
|
-
}
|
|
1561
|
-
}
|
|
1562
|
-
/**
|
|
1563
|
-
* @param {string} arg0
|
|
1564
|
-
*/
|
|
1565
|
-
set id(arg0) {
|
|
1566
|
-
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1567
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1568
|
-
wasm.__wbg_set_org_id(this.__wbg_ptr, ptr0, len0);
|
|
1569
|
-
}
|
|
1570
1398
|
/**
|
|
1571
1399
|
* @returns {bigint}
|
|
1572
1400
|
*/
|
|
1573
1401
|
get hash() {
|
|
1574
|
-
const ret = wasm.
|
|
1402
|
+
const ret = wasm.__wbg_get_org_hash(this.__wbg_ptr);
|
|
1575
1403
|
return BigInt.asUintN(64, ret);
|
|
1576
1404
|
}
|
|
1577
1405
|
/**
|
|
@@ -1582,32 +1410,49 @@ export class Org {
|
|
|
1582
1410
|
return ret;
|
|
1583
1411
|
}
|
|
1584
1412
|
/**
|
|
1585
|
-
* @returns {
|
|
1413
|
+
* @returns {string}
|
|
1586
1414
|
*/
|
|
1587
|
-
get
|
|
1588
|
-
|
|
1589
|
-
|
|
1415
|
+
get id() {
|
|
1416
|
+
let deferred1_0;
|
|
1417
|
+
let deferred1_1;
|
|
1418
|
+
try {
|
|
1419
|
+
const ret = wasm.__wbg_get_org_id(this.__wbg_ptr);
|
|
1420
|
+
deferred1_0 = ret[0];
|
|
1421
|
+
deferred1_1 = ret[1];
|
|
1422
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
1423
|
+
} finally {
|
|
1424
|
+
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
1425
|
+
}
|
|
1590
1426
|
}
|
|
1591
1427
|
/**
|
|
1592
|
-
* @returns {
|
|
1428
|
+
* @returns {string[]}
|
|
1593
1429
|
*/
|
|
1594
|
-
|
|
1595
|
-
const ret = wasm.
|
|
1596
|
-
|
|
1430
|
+
air_squadron_ids() {
|
|
1431
|
+
const ret = wasm.org_air_squadron_ids(this.__wbg_ptr);
|
|
1432
|
+
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
|
|
1433
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
1434
|
+
return v1;
|
|
1597
1435
|
}
|
|
1598
1436
|
/**
|
|
1599
1437
|
* @returns {FleetKey | undefined}
|
|
1600
1438
|
*/
|
|
1601
|
-
get
|
|
1602
|
-
const ret = wasm.
|
|
1603
|
-
|
|
1439
|
+
get boss_sup() {
|
|
1440
|
+
const ret = wasm.org_boss_sup(this.__wbg_ptr);
|
|
1441
|
+
if (ret[2]) {
|
|
1442
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1443
|
+
}
|
|
1444
|
+
return takeFromExternrefTable0(ret[0]);
|
|
1604
1445
|
}
|
|
1605
1446
|
/**
|
|
1606
|
-
* @
|
|
1447
|
+
* @param {FleetKey} key
|
|
1448
|
+
* @returns {Fleet}
|
|
1607
1449
|
*/
|
|
1608
|
-
|
|
1609
|
-
const ret = wasm.
|
|
1610
|
-
|
|
1450
|
+
clone_fleet(key) {
|
|
1451
|
+
const ret = wasm.org_clone_fleet(this.__wbg_ptr, key);
|
|
1452
|
+
if (ret[2]) {
|
|
1453
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1454
|
+
}
|
|
1455
|
+
return Fleet.__wrap(ret[0]);
|
|
1611
1456
|
}
|
|
1612
1457
|
/**
|
|
1613
1458
|
* @param {FleetKey} fleet_key
|
|
@@ -1616,15 +1461,10 @@ export class Org {
|
|
|
1616
1461
|
*/
|
|
1617
1462
|
clone_ship(fleet_key, ship_key) {
|
|
1618
1463
|
const ret = wasm.org_clone_ship(this.__wbg_ptr, fleet_key, ship_key);
|
|
1619
|
-
|
|
1620
|
-
|
|
1621
|
-
|
|
1622
|
-
|
|
1623
|
-
* @returns {Fleet}
|
|
1624
|
-
*/
|
|
1625
|
-
clone_fleet(key) {
|
|
1626
|
-
const ret = wasm.org_clone_fleet(this.__wbg_ptr, key);
|
|
1627
|
-
return Fleet.__wrap(ret);
|
|
1464
|
+
if (ret[2]) {
|
|
1465
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1466
|
+
}
|
|
1467
|
+
return ret[0] === 0 ? undefined : Ship.__wrap(ret[0]);
|
|
1628
1468
|
}
|
|
1629
1469
|
/**
|
|
1630
1470
|
* @returns {Comp}
|
|
@@ -1633,51 +1473,40 @@ export class Org {
|
|
|
1633
1473
|
const ret = wasm.org_create_comp(this.__wbg_ptr);
|
|
1634
1474
|
return Comp.__wrap(ret);
|
|
1635
1475
|
}
|
|
1636
|
-
/**
|
|
1637
|
-
* @returns {boolean}
|
|
1638
|
-
*/
|
|
1639
|
-
is_combined() {
|
|
1640
|
-
const ret = wasm.org_is_combined(this.__wbg_ptr);
|
|
1641
|
-
return ret !== 0;
|
|
1642
|
-
}
|
|
1643
1476
|
/**
|
|
1644
1477
|
* @param {FleetKey} key
|
|
1645
|
-
* @returns {
|
|
1478
|
+
* @returns {Comp}
|
|
1646
1479
|
*/
|
|
1647
|
-
|
|
1648
|
-
|
|
1649
|
-
|
|
1650
|
-
|
|
1651
|
-
const ret = wasm.org_get_fleet_id(this.__wbg_ptr, key);
|
|
1652
|
-
deferred1_0 = ret[0];
|
|
1653
|
-
deferred1_1 = ret[1];
|
|
1654
|
-
return getStringFromWasm0(ret[0], ret[1]);
|
|
1655
|
-
} finally {
|
|
1656
|
-
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
1480
|
+
create_comp_by_key(key) {
|
|
1481
|
+
const ret = wasm.org_create_comp_by_key(this.__wbg_ptr, key);
|
|
1482
|
+
if (ret[2]) {
|
|
1483
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1657
1484
|
}
|
|
1485
|
+
return Comp.__wrap(ret[0]);
|
|
1658
1486
|
}
|
|
1659
1487
|
/**
|
|
1660
|
-
* @param {
|
|
1661
|
-
* @param {
|
|
1662
|
-
* @
|
|
1488
|
+
* @param {string} id
|
|
1489
|
+
* @param {number} x
|
|
1490
|
+
* @param {number} y
|
|
1491
|
+
* @returns {MoveShipPayload | undefined}
|
|
1663
1492
|
*/
|
|
1664
|
-
|
|
1665
|
-
const
|
|
1666
|
-
|
|
1667
|
-
|
|
1668
|
-
|
|
1669
|
-
|
|
1493
|
+
create_move_ship_payload(id, x, y) {
|
|
1494
|
+
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1495
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1496
|
+
const ret = wasm.org_create_move_ship_payload(this.__wbg_ptr, ptr0, len0, x, y);
|
|
1497
|
+
if (ret[2]) {
|
|
1498
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1670
1499
|
}
|
|
1671
|
-
return
|
|
1500
|
+
return takeFromExternrefTable0(ret[0]);
|
|
1672
1501
|
}
|
|
1673
1502
|
/**
|
|
1674
|
-
* @
|
|
1675
|
-
* @param {ShipKey} ship_key
|
|
1676
|
-
* @returns {number | undefined}
|
|
1503
|
+
* @returns {Uint16Array}
|
|
1677
1504
|
*/
|
|
1678
|
-
|
|
1679
|
-
const ret = wasm.
|
|
1680
|
-
|
|
1505
|
+
escort_ship_ids() {
|
|
1506
|
+
const ret = wasm.org_escort_ship_ids(this.__wbg_ptr);
|
|
1507
|
+
var v1 = getArrayU16FromWasm0(ret[0], ret[1]).slice();
|
|
1508
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 2, 2);
|
|
1509
|
+
return v1;
|
|
1681
1510
|
}
|
|
1682
1511
|
/**
|
|
1683
1512
|
* @returns {string | undefined}
|
|
@@ -1686,27 +1515,74 @@ export class Org {
|
|
|
1686
1515
|
const ret = wasm.org_first_ship_id(this.__wbg_ptr);
|
|
1687
1516
|
let v1;
|
|
1688
1517
|
if (ret[0] !== 0) {
|
|
1689
|
-
v1 = getStringFromWasm0(ret[0], ret[1])
|
|
1518
|
+
v1 = getStringFromWasm0(ret[0], ret[1]);
|
|
1690
1519
|
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
1691
1520
|
}
|
|
1692
1521
|
return v1;
|
|
1693
1522
|
}
|
|
1694
1523
|
/**
|
|
1695
|
-
* @
|
|
1524
|
+
* @param {string} key
|
|
1525
|
+
* @returns {AirSquadron}
|
|
1696
1526
|
*/
|
|
1697
|
-
|
|
1698
|
-
const
|
|
1699
|
-
|
|
1700
|
-
wasm.
|
|
1527
|
+
get_air_squadron(key) {
|
|
1528
|
+
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1529
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1530
|
+
const ret = wasm.org_get_air_squadron(this.__wbg_ptr, ptr0, len0);
|
|
1531
|
+
if (ret[2]) {
|
|
1532
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1533
|
+
}
|
|
1534
|
+
return AirSquadron.__wrap(ret[0]);
|
|
1535
|
+
}
|
|
1536
|
+
/**
|
|
1537
|
+
* @returns {string[]}
|
|
1538
|
+
*/
|
|
1539
|
+
get_air_squadron_gear_ids_by_improvable() {
|
|
1540
|
+
const ret = wasm.org_get_air_squadron_gear_ids_by_improvable(this.__wbg_ptr);
|
|
1541
|
+
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
|
|
1542
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
1543
|
+
return v1;
|
|
1544
|
+
}
|
|
1545
|
+
/**
|
|
1546
|
+
* @returns {string[]}
|
|
1547
|
+
*/
|
|
1548
|
+
get_air_squadron_gear_ids_by_proficiency() {
|
|
1549
|
+
const ret = wasm.org_get_air_squadron_gear_ids_by_proficiency(this.__wbg_ptr);
|
|
1550
|
+
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
|
|
1551
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
1701
1552
|
return v1;
|
|
1702
1553
|
}
|
|
1554
|
+
/**
|
|
1555
|
+
* @param {FleetKey} key
|
|
1556
|
+
* @returns {string}
|
|
1557
|
+
*/
|
|
1558
|
+
get_fleet_id(key) {
|
|
1559
|
+
let deferred2_0;
|
|
1560
|
+
let deferred2_1;
|
|
1561
|
+
try {
|
|
1562
|
+
const ret = wasm.org_get_fleet_id(this.__wbg_ptr, key);
|
|
1563
|
+
var ptr1 = ret[0];
|
|
1564
|
+
var len1 = ret[1];
|
|
1565
|
+
if (ret[3]) {
|
|
1566
|
+
ptr1 = 0; len1 = 0;
|
|
1567
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1568
|
+
}
|
|
1569
|
+
deferred2_0 = ptr1;
|
|
1570
|
+
deferred2_1 = len1;
|
|
1571
|
+
return getStringFromWasm0(ptr1, len1);
|
|
1572
|
+
} finally {
|
|
1573
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1574
|
+
}
|
|
1575
|
+
}
|
|
1703
1576
|
/**
|
|
1704
1577
|
* @param {FleetKey} key
|
|
1705
1578
|
* @returns {FleetType | undefined}
|
|
1706
1579
|
*/
|
|
1707
1580
|
get_fleet_type(key) {
|
|
1708
1581
|
const ret = wasm.org_get_fleet_type(this.__wbg_ptr, key);
|
|
1709
|
-
|
|
1582
|
+
if (ret[2]) {
|
|
1583
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1584
|
+
}
|
|
1585
|
+
return takeFromExternrefTable0(ret[0]);
|
|
1710
1586
|
}
|
|
1711
1587
|
/**
|
|
1712
1588
|
* @param {string} id
|
|
@@ -1719,63 +1595,33 @@ export class Org {
|
|
|
1719
1595
|
return ret === 0 ? undefined : Ship.__wrap(ret);
|
|
1720
1596
|
}
|
|
1721
1597
|
/**
|
|
1722
|
-
* @
|
|
1723
|
-
|
|
1724
|
-
|
|
1725
|
-
const ret = wasm.org_escort_ship_ids(this.__wbg_ptr);
|
|
1726
|
-
var v1 = getArrayU16FromWasm0(ret[0], ret[1]).slice();
|
|
1727
|
-
wasm.__wbindgen_free(ret[0], ret[1] * 2, 2);
|
|
1728
|
-
return v1;
|
|
1729
|
-
}
|
|
1730
|
-
/**
|
|
1731
|
-
* @returns {string[]}
|
|
1598
|
+
* @param {FleetKey} fleet_key
|
|
1599
|
+
* @param {ShipKey} ship_key
|
|
1600
|
+
* @returns {string | undefined}
|
|
1732
1601
|
*/
|
|
1733
|
-
|
|
1734
|
-
const ret = wasm.
|
|
1735
|
-
|
|
1736
|
-
|
|
1602
|
+
get_ship_eid(fleet_key, ship_key) {
|
|
1603
|
+
const ret = wasm.org_get_ship_eid(this.__wbg_ptr, fleet_key, ship_key);
|
|
1604
|
+
if (ret[3]) {
|
|
1605
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1606
|
+
}
|
|
1607
|
+
let v1;
|
|
1608
|
+
if (ret[0] !== 0) {
|
|
1609
|
+
v1 = getStringFromWasm0(ret[0], ret[1]);
|
|
1610
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
1611
|
+
}
|
|
1737
1612
|
return v1;
|
|
1738
1613
|
}
|
|
1739
1614
|
/**
|
|
1740
|
-
* @param {
|
|
1741
|
-
* @
|
|
1615
|
+
* @param {FleetKey} fleet_key
|
|
1616
|
+
* @param {ShipKey} ship_key
|
|
1617
|
+
* @returns {number | undefined}
|
|
1742
1618
|
*/
|
|
1743
|
-
|
|
1744
|
-
const
|
|
1745
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1746
|
-
const ret = wasm.org_get_air_squadron(this.__wbg_ptr, ptr0, len0);
|
|
1619
|
+
get_ship_mid(fleet_key, ship_key) {
|
|
1620
|
+
const ret = wasm.org_get_ship_mid(this.__wbg_ptr, fleet_key, ship_key);
|
|
1747
1621
|
if (ret[2]) {
|
|
1748
1622
|
throw takeFromExternrefTable0(ret[1]);
|
|
1749
1623
|
}
|
|
1750
|
-
return
|
|
1751
|
-
}
|
|
1752
|
-
/**
|
|
1753
|
-
* @param {FleetKey} key
|
|
1754
|
-
* @returns {Comp}
|
|
1755
|
-
*/
|
|
1756
|
-
create_comp_by_key(key) {
|
|
1757
|
-
const ret = wasm.org_create_comp_by_key(this.__wbg_ptr, key);
|
|
1758
|
-
return Comp.__wrap(ret);
|
|
1759
|
-
}
|
|
1760
|
-
/**
|
|
1761
|
-
* 防空時の基地制空値
|
|
1762
|
-
* @returns {number}
|
|
1763
|
-
*/
|
|
1764
|
-
interception_power() {
|
|
1765
|
-
const ret = wasm.org_interception_power(this.__wbg_ptr);
|
|
1766
|
-
return ret;
|
|
1767
|
-
}
|
|
1768
|
-
/**
|
|
1769
|
-
* @param {string} id
|
|
1770
|
-
* @param {number} x
|
|
1771
|
-
* @param {number} y
|
|
1772
|
-
* @returns {MoveShipPayload | undefined}
|
|
1773
|
-
*/
|
|
1774
|
-
create_move_ship_payload(id, x, y) {
|
|
1775
|
-
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1776
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1777
|
-
const ret = wasm.org_create_move_ship_payload(this.__wbg_ptr, ptr0, len0, x, y);
|
|
1778
|
-
return ret;
|
|
1624
|
+
return ret[0] === 0xFFFFFF ? undefined : ret[0];
|
|
1779
1625
|
}
|
|
1780
1626
|
/**
|
|
1781
1627
|
* 高高度迎撃時の基地制空値
|
|
@@ -1786,29 +1632,19 @@ export class Org {
|
|
|
1786
1632
|
return ret;
|
|
1787
1633
|
}
|
|
1788
1634
|
/**
|
|
1789
|
-
*
|
|
1790
|
-
|
|
1791
|
-
get_air_squadron_gear_ids_by_improvable() {
|
|
1792
|
-
const ret = wasm.org_get_air_squadron_gear_ids_by_improvable(this.__wbg_ptr);
|
|
1793
|
-
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
|
|
1794
|
-
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
1795
|
-
return v1;
|
|
1796
|
-
}
|
|
1797
|
-
/**
|
|
1798
|
-
* @returns {string[]}
|
|
1635
|
+
* 防空時の基地制空値
|
|
1636
|
+
* @returns {number}
|
|
1799
1637
|
*/
|
|
1800
|
-
|
|
1801
|
-
const ret = wasm.
|
|
1802
|
-
|
|
1803
|
-
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
1804
|
-
return v1;
|
|
1638
|
+
interception_power() {
|
|
1639
|
+
const ret = wasm.org_interception_power(this.__wbg_ptr);
|
|
1640
|
+
return ret;
|
|
1805
1641
|
}
|
|
1806
1642
|
/**
|
|
1807
|
-
* @returns {
|
|
1643
|
+
* @returns {boolean}
|
|
1808
1644
|
*/
|
|
1809
|
-
|
|
1810
|
-
const ret = wasm.
|
|
1811
|
-
return ret;
|
|
1645
|
+
is_combined() {
|
|
1646
|
+
const ret = wasm.org_is_combined(this.__wbg_ptr);
|
|
1647
|
+
return ret !== 0;
|
|
1812
1648
|
}
|
|
1813
1649
|
/**
|
|
1814
1650
|
* @returns {boolean}
|
|
@@ -1831,66 +1667,130 @@ export class Org {
|
|
|
1831
1667
|
const ret = wasm.org_is_single(this.__wbg_ptr);
|
|
1832
1668
|
return ret !== 0;
|
|
1833
1669
|
}
|
|
1670
|
+
/**
|
|
1671
|
+
* @returns {Uint16Array}
|
|
1672
|
+
*/
|
|
1673
|
+
main_ship_ids() {
|
|
1674
|
+
const ret = wasm.org_main_ship_ids(this.__wbg_ptr);
|
|
1675
|
+
var v1 = getArrayU16FromWasm0(ret[0], ret[1]).slice();
|
|
1676
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 2, 2);
|
|
1677
|
+
return v1;
|
|
1678
|
+
}
|
|
1679
|
+
/**
|
|
1680
|
+
* @returns {OrgType}
|
|
1681
|
+
*/
|
|
1682
|
+
get org_type() {
|
|
1683
|
+
const ret = wasm.org_org_type(this.__wbg_ptr);
|
|
1684
|
+
if (ret[2]) {
|
|
1685
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1686
|
+
}
|
|
1687
|
+
return takeFromExternrefTable0(ret[0]);
|
|
1688
|
+
}
|
|
1689
|
+
/**
|
|
1690
|
+
* @returns {FleetKey | undefined}
|
|
1691
|
+
*/
|
|
1692
|
+
get route_sup() {
|
|
1693
|
+
const ret = wasm.org_route_sup(this.__wbg_ptr);
|
|
1694
|
+
if (ret[2]) {
|
|
1695
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1696
|
+
}
|
|
1697
|
+
return takeFromExternrefTable0(ret[0]);
|
|
1698
|
+
}
|
|
1834
1699
|
/**
|
|
1835
1700
|
* @param {FleetKey} key
|
|
1836
1701
|
* @returns {string[]}
|
|
1837
1702
|
*/
|
|
1838
1703
|
ship_keys(key) {
|
|
1839
1704
|
const ret = wasm.org_ship_keys(this.__wbg_ptr, key);
|
|
1840
|
-
|
|
1705
|
+
if (ret[3]) {
|
|
1706
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1707
|
+
}
|
|
1708
|
+
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
|
|
1841
1709
|
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
1842
1710
|
return v1;
|
|
1843
1711
|
}
|
|
1712
|
+
/**
|
|
1713
|
+
* @returns {Side}
|
|
1714
|
+
*/
|
|
1715
|
+
side() {
|
|
1716
|
+
const ret = wasm.org_side(this.__wbg_ptr);
|
|
1717
|
+
if (ret[2]) {
|
|
1718
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1719
|
+
}
|
|
1720
|
+
return takeFromExternrefTable0(ret[0]);
|
|
1721
|
+
}
|
|
1722
|
+
/**
|
|
1723
|
+
* @returns {FleetKey}
|
|
1724
|
+
*/
|
|
1725
|
+
get sortie() {
|
|
1726
|
+
const ret = wasm.org_sortie(this.__wbg_ptr);
|
|
1727
|
+
if (ret[2]) {
|
|
1728
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1729
|
+
}
|
|
1730
|
+
return takeFromExternrefTable0(ret[0]);
|
|
1731
|
+
}
|
|
1732
|
+
/**
|
|
1733
|
+
* @param {string} arg0
|
|
1734
|
+
*/
|
|
1735
|
+
set id(arg0) {
|
|
1736
|
+
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1737
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1738
|
+
wasm.__wbg_set_org_id(this.__wbg_ptr, ptr0, len0);
|
|
1739
|
+
}
|
|
1844
1740
|
}
|
|
1845
1741
|
if (Symbol.dispose) Org.prototype[Symbol.dispose] = Org.prototype.free;
|
|
1846
1742
|
|
|
1847
|
-
const ShipFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
1848
|
-
? { register: () => {}, unregister: () => {} }
|
|
1849
|
-
: new FinalizationRegistry(ptr => wasm.__wbg_ship_free(ptr >>> 0, 1));
|
|
1850
|
-
|
|
1851
1743
|
export class Ship {
|
|
1852
|
-
|
|
1853
1744
|
static __wrap(ptr) {
|
|
1854
|
-
ptr = ptr >>> 0;
|
|
1855
1745
|
const obj = Object.create(Ship.prototype);
|
|
1856
1746
|
obj.__wbg_ptr = ptr;
|
|
1857
1747
|
ShipFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1858
1748
|
return obj;
|
|
1859
1749
|
}
|
|
1860
|
-
|
|
1861
1750
|
__destroy_into_raw() {
|
|
1862
1751
|
const ptr = this.__wbg_ptr;
|
|
1863
1752
|
this.__wbg_ptr = 0;
|
|
1864
1753
|
ShipFinalization.unregister(this);
|
|
1865
1754
|
return ptr;
|
|
1866
1755
|
}
|
|
1867
|
-
|
|
1868
1756
|
free() {
|
|
1869
1757
|
const ptr = this.__destroy_into_raw();
|
|
1870
1758
|
wasm.__wbg_ship_free(ptr, 0);
|
|
1871
1759
|
}
|
|
1872
1760
|
/**
|
|
1873
|
-
* フィット砲補正
|
|
1874
|
-
* @param {boolean} is_night
|
|
1875
1761
|
* @returns {number}
|
|
1876
1762
|
*/
|
|
1877
|
-
|
|
1878
|
-
const ret = wasm.
|
|
1763
|
+
get ammo() {
|
|
1764
|
+
const ret = wasm.__wbg_get_ship_ammo(this.__wbg_ptr);
|
|
1879
1765
|
return ret;
|
|
1880
1766
|
}
|
|
1881
1767
|
/**
|
|
1882
|
-
* @returns {number
|
|
1768
|
+
* @returns {number}
|
|
1883
1769
|
*/
|
|
1884
|
-
|
|
1885
|
-
const ret = wasm.
|
|
1886
|
-
return ret
|
|
1770
|
+
get ctype() {
|
|
1771
|
+
const ret = wasm.__wbg_get_ship_ctype(this.__wbg_ptr);
|
|
1772
|
+
return ret;
|
|
1887
1773
|
}
|
|
1888
1774
|
/**
|
|
1889
|
-
* @returns {number
|
|
1775
|
+
* @returns {number}
|
|
1890
1776
|
*/
|
|
1891
|
-
|
|
1892
|
-
const ret = wasm.
|
|
1893
|
-
return ret
|
|
1777
|
+
get current_hp() {
|
|
1778
|
+
const ret = wasm.__wbg_get_ship_current_hp(this.__wbg_ptr);
|
|
1779
|
+
return ret;
|
|
1780
|
+
}
|
|
1781
|
+
/**
|
|
1782
|
+
* @returns {number}
|
|
1783
|
+
*/
|
|
1784
|
+
get fuel() {
|
|
1785
|
+
const ret = wasm.__wbg_get_ship_fuel(this.__wbg_ptr);
|
|
1786
|
+
return ret;
|
|
1787
|
+
}
|
|
1788
|
+
/**
|
|
1789
|
+
* @returns {bigint}
|
|
1790
|
+
*/
|
|
1791
|
+
get hash() {
|
|
1792
|
+
const ret = wasm.__wbg_get_ship_hash(this.__wbg_ptr);
|
|
1793
|
+
return BigInt.asUintN(64, ret);
|
|
1894
1794
|
}
|
|
1895
1795
|
/**
|
|
1896
1796
|
* @returns {string}
|
|
@@ -1908,19 +1808,18 @@ export class Ship {
|
|
|
1908
1808
|
}
|
|
1909
1809
|
}
|
|
1910
1810
|
/**
|
|
1911
|
-
* @
|
|
1811
|
+
* @returns {number}
|
|
1912
1812
|
*/
|
|
1913
|
-
|
|
1914
|
-
const
|
|
1915
|
-
|
|
1916
|
-
wasm.__wbg_set_ship_id(this.__wbg_ptr, ptr0, len0);
|
|
1813
|
+
get level() {
|
|
1814
|
+
const ret = wasm.__wbg_get_ship_level(this.__wbg_ptr);
|
|
1815
|
+
return ret;
|
|
1917
1816
|
}
|
|
1918
1817
|
/**
|
|
1919
|
-
* @returns {
|
|
1818
|
+
* @returns {number}
|
|
1920
1819
|
*/
|
|
1921
|
-
get
|
|
1922
|
-
const ret = wasm.
|
|
1923
|
-
return
|
|
1820
|
+
get morale() {
|
|
1821
|
+
const ret = wasm.__wbg_get_ship_morale(this.__wbg_ptr);
|
|
1822
|
+
return ret;
|
|
1924
1823
|
}
|
|
1925
1824
|
/**
|
|
1926
1825
|
* @returns {number}
|
|
@@ -1930,126 +1829,143 @@ export class Ship {
|
|
|
1930
1829
|
return ret;
|
|
1931
1830
|
}
|
|
1932
1831
|
/**
|
|
1933
|
-
* @
|
|
1934
|
-
*/
|
|
1935
|
-
get level() {
|
|
1936
|
-
const ret = wasm.__wbg_get_ship_level(this.__wbg_ptr);
|
|
1937
|
-
return ret;
|
|
1938
|
-
}
|
|
1939
|
-
/**
|
|
1940
|
-
* @returns {number}
|
|
1832
|
+
* @param {string} arg0
|
|
1941
1833
|
*/
|
|
1942
|
-
|
|
1943
|
-
const
|
|
1944
|
-
|
|
1834
|
+
set id(arg0) {
|
|
1835
|
+
const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1836
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1837
|
+
wasm.__wbg_set_ship_id(this.__wbg_ptr, ptr0, len0);
|
|
1945
1838
|
}
|
|
1946
1839
|
/**
|
|
1947
1840
|
* @returns {number}
|
|
1948
1841
|
*/
|
|
1949
|
-
get
|
|
1950
|
-
const ret = wasm.
|
|
1842
|
+
get accuracy() {
|
|
1843
|
+
const ret = wasm.ship_accuracy(this.__wbg_ptr);
|
|
1951
1844
|
return ret;
|
|
1952
1845
|
}
|
|
1953
1846
|
/**
|
|
1954
|
-
* @returns {number}
|
|
1847
|
+
* @returns {number | undefined}
|
|
1955
1848
|
*/
|
|
1956
|
-
get
|
|
1957
|
-
const ret = wasm.
|
|
1958
|
-
return ret;
|
|
1849
|
+
get anti_air() {
|
|
1850
|
+
const ret = wasm.ship_anti_air(this.__wbg_ptr);
|
|
1851
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
1959
1852
|
}
|
|
1960
1853
|
/**
|
|
1961
|
-
* @returns {number}
|
|
1854
|
+
* @returns {number | undefined}
|
|
1962
1855
|
*/
|
|
1963
|
-
get
|
|
1964
|
-
const ret = wasm.
|
|
1965
|
-
return ret;
|
|
1856
|
+
get armor() {
|
|
1857
|
+
const ret = wasm.ship_armor(this.__wbg_ptr);
|
|
1858
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
1966
1859
|
}
|
|
1967
1860
|
/**
|
|
1968
|
-
* @returns {
|
|
1861
|
+
* @returns {number | undefined}
|
|
1969
1862
|
*/
|
|
1970
|
-
get
|
|
1971
|
-
const ret = wasm.
|
|
1972
|
-
return ret;
|
|
1863
|
+
get asw() {
|
|
1864
|
+
const ret = wasm.ship_asw(this.__wbg_ptr);
|
|
1865
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
1973
1866
|
}
|
|
1974
1867
|
/**
|
|
1975
|
-
* @returns {number}
|
|
1868
|
+
* @returns {number | undefined}
|
|
1976
1869
|
*/
|
|
1977
|
-
|
|
1978
|
-
const ret = wasm.
|
|
1979
|
-
return ret;
|
|
1870
|
+
basic_accuracy_term() {
|
|
1871
|
+
const ret = wasm.ship_basic_accuracy_term(this.__wbg_ptr);
|
|
1872
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
1980
1873
|
}
|
|
1981
1874
|
/**
|
|
1982
|
-
* @
|
|
1875
|
+
* @param {number} armor_penetration
|
|
1876
|
+
* @returns {number | undefined}
|
|
1983
1877
|
*/
|
|
1984
|
-
|
|
1985
|
-
const ret = wasm.
|
|
1986
|
-
return ret;
|
|
1878
|
+
basic_defense_power(armor_penetration) {
|
|
1879
|
+
const ret = wasm.ship_basic_defense_power(this.__wbg_ptr, armor_penetration);
|
|
1880
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
1987
1881
|
}
|
|
1988
1882
|
/**
|
|
1989
|
-
* @
|
|
1883
|
+
* @returns {number | undefined}
|
|
1990
1884
|
*/
|
|
1991
|
-
|
|
1992
|
-
wasm.
|
|
1885
|
+
basic_evasion_term() {
|
|
1886
|
+
const ret = wasm.ship_basic_evasion_term(this.__wbg_ptr);
|
|
1887
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
1993
1888
|
}
|
|
1994
1889
|
/**
|
|
1890
|
+
* @param {Gear} gear
|
|
1995
1891
|
* @param {string} key
|
|
1996
|
-
* @returns {
|
|
1892
|
+
* @returns {boolean}
|
|
1997
1893
|
*/
|
|
1998
|
-
|
|
1894
|
+
can_equip(gear, key) {
|
|
1895
|
+
_assertClass(gear, Gear);
|
|
1999
1896
|
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2000
1897
|
const len0 = WASM_VECTOR_LEN;
|
|
2001
|
-
const ret = wasm.
|
|
2002
|
-
return ret;
|
|
1898
|
+
const ret = wasm.ship_can_equip(this.__wbg_ptr, gear.__wbg_ptr, ptr0, len0);
|
|
1899
|
+
return ret !== 0;
|
|
2003
1900
|
}
|
|
2004
1901
|
/**
|
|
2005
|
-
* @returns {
|
|
1902
|
+
* @returns {ShipCategory}
|
|
2006
1903
|
*/
|
|
2007
|
-
|
|
2008
|
-
const ret = wasm.
|
|
2009
|
-
|
|
1904
|
+
category() {
|
|
1905
|
+
const ret = wasm.ship_category(this.__wbg_ptr);
|
|
1906
|
+
if (ret[2]) {
|
|
1907
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1908
|
+
}
|
|
1909
|
+
return takeFromExternrefTable0(ret[0]);
|
|
2010
1910
|
}
|
|
2011
1911
|
/**
|
|
2012
|
-
* @returns {
|
|
1912
|
+
* @returns {number}
|
|
2013
1913
|
*/
|
|
2014
|
-
|
|
2015
|
-
const ret = wasm.
|
|
2016
|
-
return ret
|
|
1914
|
+
cruiser_fit_bonus() {
|
|
1915
|
+
const ret = wasm.ship_cruiser_fit_bonus(this.__wbg_ptr);
|
|
1916
|
+
return ret;
|
|
2017
1917
|
}
|
|
2018
1918
|
/**
|
|
2019
|
-
*
|
|
2020
|
-
* @returns {number | undefined}
|
|
1919
|
+
* @returns {CustomPowerModifiers}
|
|
2021
1920
|
*/
|
|
2022
|
-
|
|
2023
|
-
const ret = wasm.
|
|
2024
|
-
|
|
1921
|
+
custom_power_mods() {
|
|
1922
|
+
const ret = wasm.ship_custom_power_mods(this.__wbg_ptr);
|
|
1923
|
+
if (ret[2]) {
|
|
1924
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1925
|
+
}
|
|
1926
|
+
return takeFromExternrefTable0(ret[0]);
|
|
2025
1927
|
}
|
|
2026
1928
|
/**
|
|
2027
|
-
* @returns {
|
|
1929
|
+
* @returns {DamageState}
|
|
2028
1930
|
*/
|
|
2029
|
-
|
|
2030
|
-
const ret = wasm.
|
|
2031
|
-
|
|
1931
|
+
damage_state() {
|
|
1932
|
+
const ret = wasm.ship_damage_state(this.__wbg_ptr);
|
|
1933
|
+
if (ret[2]) {
|
|
1934
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1935
|
+
}
|
|
1936
|
+
return takeFromExternrefTable0(ret[0]);
|
|
1937
|
+
}
|
|
1938
|
+
/**
|
|
1939
|
+
* @returns {Ship}
|
|
1940
|
+
*/
|
|
1941
|
+
static default() {
|
|
1942
|
+
const ret = wasm.ship_default();
|
|
1943
|
+
return Ship.__wrap(ret);
|
|
2032
1944
|
}
|
|
2033
1945
|
/**
|
|
1946
|
+
* @param {number} node_divaricated_factor
|
|
2034
1947
|
* @returns {number | undefined}
|
|
2035
1948
|
*/
|
|
2036
|
-
|
|
2037
|
-
const ret = wasm.
|
|
2038
|
-
return ret ===
|
|
1949
|
+
elos(node_divaricated_factor) {
|
|
1950
|
+
const ret = wasm.ship_elos(this.__wbg_ptr, node_divaricated_factor);
|
|
1951
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
2039
1952
|
}
|
|
2040
1953
|
/**
|
|
2041
|
-
* @
|
|
1954
|
+
* @param {string} id
|
|
1955
|
+
* @returns {boolean}
|
|
2042
1956
|
*/
|
|
2043
|
-
|
|
2044
|
-
const
|
|
2045
|
-
|
|
1957
|
+
eq_id(id) {
|
|
1958
|
+
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1959
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1960
|
+
const ret = wasm.ship_eq_id(this.__wbg_ptr, ptr0, len0);
|
|
1961
|
+
return ret !== 0;
|
|
2046
1962
|
}
|
|
2047
1963
|
/**
|
|
2048
|
-
* @returns {
|
|
1964
|
+
* @returns {number | undefined}
|
|
2049
1965
|
*/
|
|
2050
|
-
|
|
2051
|
-
const ret = wasm.
|
|
2052
|
-
return ret;
|
|
1966
|
+
get evasion() {
|
|
1967
|
+
const ret = wasm.ship_evasion(this.__wbg_ptr);
|
|
1968
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
2053
1969
|
}
|
|
2054
1970
|
/**
|
|
2055
1971
|
* @param {number} formation_mod
|
|
@@ -2062,74 +1978,94 @@ export class Ship {
|
|
|
2062
1978
|
return ret[0] === 0 ? undefined : ret[1];
|
|
2063
1979
|
}
|
|
2064
1980
|
/**
|
|
2065
|
-
* @param {
|
|
1981
|
+
* @param {AirWaveType} air_type
|
|
2066
1982
|
* @returns {number | undefined}
|
|
2067
1983
|
*/
|
|
2068
|
-
|
|
2069
|
-
const
|
|
2070
|
-
|
|
2071
|
-
|
|
2072
|
-
|
|
1984
|
+
fighter_power(air_type) {
|
|
1985
|
+
const ret = wasm.ship_fighter_power(this.__wbg_ptr, air_type);
|
|
1986
|
+
if (ret[2]) {
|
|
1987
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
1988
|
+
}
|
|
1989
|
+
return ret[0] === Number.MAX_SAFE_INTEGER ? undefined : ret[0];
|
|
2073
1990
|
}
|
|
2074
1991
|
/**
|
|
2075
|
-
* @returns {
|
|
1992
|
+
* @returns {number | undefined}
|
|
2076
1993
|
*/
|
|
2077
|
-
|
|
2078
|
-
const ret = wasm.
|
|
2079
|
-
return ret
|
|
1994
|
+
get firepower() {
|
|
1995
|
+
const ret = wasm.ship_firepower(this.__wbg_ptr);
|
|
1996
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
2080
1997
|
}
|
|
2081
1998
|
/**
|
|
2082
|
-
*
|
|
1999
|
+
* 艦隊対空補正
|
|
2000
|
+
* @returns {number}
|
|
2083
2001
|
*/
|
|
2084
|
-
|
|
2085
|
-
const ret = wasm.
|
|
2002
|
+
fleet_anti_air_mod() {
|
|
2003
|
+
const ret = wasm.ship_fleet_anti_air_mod(this.__wbg_ptr);
|
|
2086
2004
|
return ret;
|
|
2087
2005
|
}
|
|
2088
2006
|
/**
|
|
2089
|
-
* @returns {number}
|
|
2007
|
+
* @returns {number | undefined}
|
|
2090
2008
|
*/
|
|
2091
|
-
|
|
2092
|
-
const ret = wasm.
|
|
2093
|
-
return ret;
|
|
2009
|
+
fleet_los_factor() {
|
|
2010
|
+
const ret = wasm.ship_fleet_los_factor(this.__wbg_ptr);
|
|
2011
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
2094
2012
|
}
|
|
2095
2013
|
/**
|
|
2096
|
-
* @
|
|
2014
|
+
* @returns {string[]}
|
|
2015
|
+
*/
|
|
2016
|
+
gear_keys() {
|
|
2017
|
+
const ret = wasm.ship_gear_keys(this.__wbg_ptr);
|
|
2018
|
+
var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
|
|
2019
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
2020
|
+
return v1;
|
|
2021
|
+
}
|
|
2022
|
+
/**
|
|
2023
|
+
* @param {DamageState} state
|
|
2097
2024
|
* @returns {number | undefined}
|
|
2098
2025
|
*/
|
|
2099
|
-
|
|
2100
|
-
const ret = wasm.
|
|
2101
|
-
|
|
2026
|
+
get_damage_bound(state) {
|
|
2027
|
+
const ret = wasm.ship_get_damage_bound(this.__wbg_ptr, state);
|
|
2028
|
+
if (ret[2]) {
|
|
2029
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2030
|
+
}
|
|
2031
|
+
return ret[0] === 0xFFFFFF ? undefined : ret[0];
|
|
2102
2032
|
}
|
|
2103
2033
|
/**
|
|
2104
2034
|
* @param {string} key
|
|
2105
2035
|
* @returns {number}
|
|
2106
2036
|
*/
|
|
2107
|
-
|
|
2037
|
+
get_ebonus(key) {
|
|
2108
2038
|
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2109
2039
|
const len0 = WASM_VECTOR_LEN;
|
|
2110
|
-
const ret = wasm.
|
|
2040
|
+
const ret = wasm.ship_get_ebonus(this.__wbg_ptr, ptr0, len0);
|
|
2111
2041
|
return ret;
|
|
2112
2042
|
}
|
|
2113
2043
|
/**
|
|
2114
|
-
* @param {
|
|
2115
|
-
* @returns {
|
|
2044
|
+
* @param {string} key
|
|
2045
|
+
* @returns {Gear | undefined}
|
|
2116
2046
|
*/
|
|
2117
|
-
|
|
2118
|
-
const
|
|
2119
|
-
|
|
2047
|
+
get_gear(key) {
|
|
2048
|
+
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2049
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2050
|
+
const ret = wasm.ship_get_gear(this.__wbg_ptr, ptr0, len0);
|
|
2051
|
+
return ret === 0 ? undefined : Gear.__wrap(ret);
|
|
2120
2052
|
}
|
|
2121
2053
|
/**
|
|
2122
|
-
* @
|
|
2054
|
+
* @param {string} key
|
|
2055
|
+
* @returns {number}
|
|
2123
2056
|
*/
|
|
2124
|
-
|
|
2125
|
-
const
|
|
2126
|
-
|
|
2057
|
+
get_gear_stat(key) {
|
|
2058
|
+
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2059
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2060
|
+
const ret = wasm.ship_get_gear_stat(this.__wbg_ptr, ptr0, len0);
|
|
2061
|
+
return ret;
|
|
2127
2062
|
}
|
|
2128
2063
|
/**
|
|
2064
|
+
* @param {number} index
|
|
2129
2065
|
* @returns {number | undefined}
|
|
2130
2066
|
*/
|
|
2131
|
-
|
|
2132
|
-
const ret = wasm.
|
|
2067
|
+
get_max_slot_size(index) {
|
|
2068
|
+
const ret = wasm.ship_get_max_slot_size(this.__wbg_ptr, index);
|
|
2133
2069
|
return ret === 0xFFFFFF ? undefined : ret;
|
|
2134
2070
|
}
|
|
2135
2071
|
/**
|
|
@@ -2143,48 +2079,81 @@ export class Ship {
|
|
|
2143
2079
|
return ret === 0xFFFFFF ? undefined : ret;
|
|
2144
2080
|
}
|
|
2145
2081
|
/**
|
|
2146
|
-
* @
|
|
2082
|
+
* @param {number} rate
|
|
2083
|
+
* @param {boolean} ceil
|
|
2084
|
+
* @returns {number}
|
|
2147
2085
|
*/
|
|
2148
|
-
|
|
2149
|
-
const ret = wasm.
|
|
2150
|
-
return ret
|
|
2086
|
+
get_remaining_ammo(rate, ceil) {
|
|
2087
|
+
const ret = wasm.ship_get_remaining_ammo(this.__wbg_ptr, rate, ceil);
|
|
2088
|
+
return ret;
|
|
2151
2089
|
}
|
|
2152
2090
|
/**
|
|
2153
|
-
* @
|
|
2091
|
+
* @param {number} rate
|
|
2092
|
+
* @param {boolean} ceil
|
|
2093
|
+
* @returns {number}
|
|
2154
2094
|
*/
|
|
2155
|
-
|
|
2156
|
-
const ret = wasm.
|
|
2157
|
-
return ret
|
|
2095
|
+
get_remaining_fuel(rate, ceil) {
|
|
2096
|
+
const ret = wasm.ship_get_remaining_fuel(this.__wbg_ptr, rate, ceil);
|
|
2097
|
+
return ret;
|
|
2158
2098
|
}
|
|
2159
2099
|
/**
|
|
2100
|
+
* @param {number} index
|
|
2160
2101
|
* @returns {number | undefined}
|
|
2161
2102
|
*/
|
|
2162
|
-
|
|
2163
|
-
const ret = wasm.
|
|
2103
|
+
get_slot_size(index) {
|
|
2104
|
+
const ret = wasm.ship_get_slot_size(this.__wbg_ptr, index);
|
|
2164
2105
|
return ret === 0xFFFFFF ? undefined : ret;
|
|
2165
2106
|
}
|
|
2166
2107
|
/**
|
|
2167
|
-
* @
|
|
2108
|
+
* @param {string} key
|
|
2109
|
+
* @returns {number | undefined}
|
|
2168
2110
|
*/
|
|
2169
|
-
|
|
2170
|
-
const
|
|
2171
|
-
|
|
2111
|
+
get_stat_interval_left(key) {
|
|
2112
|
+
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2113
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2114
|
+
const ret = wasm.ship_get_stat_interval_left(this.__wbg_ptr, ptr0, len0);
|
|
2115
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
2172
2116
|
}
|
|
2173
2117
|
/**
|
|
2118
|
+
* @param {string} key
|
|
2174
2119
|
* @returns {number | undefined}
|
|
2175
2120
|
*/
|
|
2176
|
-
|
|
2177
|
-
const
|
|
2178
|
-
|
|
2121
|
+
get_stat_interval_right(key) {
|
|
2122
|
+
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2123
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2124
|
+
const ret = wasm.ship_get_stat_interval_right(this.__wbg_ptr, ptr0, len0);
|
|
2125
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
2179
2126
|
}
|
|
2180
2127
|
/**
|
|
2181
|
-
* @param {
|
|
2128
|
+
* @param {string} key
|
|
2182
2129
|
* @returns {number | undefined}
|
|
2183
2130
|
*/
|
|
2184
|
-
|
|
2185
|
-
const
|
|
2131
|
+
get_stat_mod(key) {
|
|
2132
|
+
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2133
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2134
|
+
const ret = wasm.ship_get_stat_mod(this.__wbg_ptr, ptr0, len0);
|
|
2186
2135
|
return ret === 0xFFFFFF ? undefined : ret;
|
|
2187
2136
|
}
|
|
2137
|
+
/**
|
|
2138
|
+
* フィット砲補正
|
|
2139
|
+
* @param {boolean} is_night
|
|
2140
|
+
* @returns {number}
|
|
2141
|
+
*/
|
|
2142
|
+
gunfit_accuracy(is_night) {
|
|
2143
|
+
const ret = wasm.ship_gunfit_accuracy(this.__wbg_ptr, is_night);
|
|
2144
|
+
return ret;
|
|
2145
|
+
}
|
|
2146
|
+
/**
|
|
2147
|
+
* @param {ShipAttr} attr
|
|
2148
|
+
* @returns {boolean}
|
|
2149
|
+
*/
|
|
2150
|
+
has_attr(attr) {
|
|
2151
|
+
const ret = wasm.ship_has_attr(this.__wbg_ptr, attr);
|
|
2152
|
+
if (ret[2]) {
|
|
2153
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2154
|
+
}
|
|
2155
|
+
return ret[0] !== 0;
|
|
2156
|
+
}
|
|
2188
2157
|
/**
|
|
2189
2158
|
* @param {string} key
|
|
2190
2159
|
* @returns {boolean}
|
|
@@ -2198,173 +2167,170 @@ export class Ship {
|
|
|
2198
2167
|
/**
|
|
2199
2168
|
* @returns {number}
|
|
2200
2169
|
*/
|
|
2201
|
-
|
|
2202
|
-
const ret = wasm.
|
|
2170
|
+
get innate_torpedo_accuracy() {
|
|
2171
|
+
const ret = wasm.ship_innate_torpedo_accuracy(this.__wbg_ptr);
|
|
2203
2172
|
return ret;
|
|
2204
2173
|
}
|
|
2205
2174
|
/**
|
|
2206
|
-
* @returns {
|
|
2175
|
+
* @returns {boolean}
|
|
2207
2176
|
*/
|
|
2208
|
-
|
|
2209
|
-
const ret = wasm.
|
|
2210
|
-
return ret;
|
|
2177
|
+
is_abyssal() {
|
|
2178
|
+
const ret = wasm.ship_is_abyssal(this.__wbg_ptr);
|
|
2179
|
+
return ret !== 0;
|
|
2211
2180
|
}
|
|
2212
2181
|
/**
|
|
2213
|
-
* @
|
|
2214
|
-
* @returns {number | undefined}
|
|
2182
|
+
* @returns {boolean}
|
|
2215
2183
|
*/
|
|
2216
|
-
|
|
2217
|
-
const ret = wasm.
|
|
2218
|
-
return ret
|
|
2184
|
+
is_amagiri() {
|
|
2185
|
+
const ret = wasm.ship_is_amagiri(this.__wbg_ptr);
|
|
2186
|
+
return ret !== 0;
|
|
2219
2187
|
}
|
|
2220
2188
|
/**
|
|
2221
|
-
* @returns {
|
|
2189
|
+
* @returns {boolean}
|
|
2222
2190
|
*/
|
|
2223
|
-
|
|
2224
|
-
const ret = wasm.
|
|
2225
|
-
return ret
|
|
2191
|
+
is_attackable_by_torpedo() {
|
|
2192
|
+
const ret = wasm.ship_is_attackable_by_torpedo(this.__wbg_ptr);
|
|
2193
|
+
return ret !== 0;
|
|
2226
2194
|
}
|
|
2227
2195
|
/**
|
|
2228
|
-
*
|
|
2229
|
-
* @returns {number}
|
|
2196
|
+
* @returns {boolean}
|
|
2230
2197
|
*/
|
|
2231
|
-
|
|
2232
|
-
const ret = wasm.
|
|
2233
|
-
return ret;
|
|
2198
|
+
is_installation() {
|
|
2199
|
+
const ret = wasm.ship_is_installation(this.__wbg_ptr);
|
|
2200
|
+
return ret !== 0;
|
|
2234
2201
|
}
|
|
2235
2202
|
/**
|
|
2236
|
-
* @
|
|
2237
|
-
* @param {boolean} ceil
|
|
2238
|
-
* @returns {number}
|
|
2203
|
+
* @returns {boolean}
|
|
2239
2204
|
*/
|
|
2240
|
-
|
|
2241
|
-
const ret = wasm.
|
|
2242
|
-
return ret;
|
|
2205
|
+
is_pt_imp() {
|
|
2206
|
+
const ret = wasm.ship_is_pt_imp(this.__wbg_ptr);
|
|
2207
|
+
return ret !== 0;
|
|
2243
2208
|
}
|
|
2244
2209
|
/**
|
|
2245
|
-
* @
|
|
2246
|
-
* @param {boolean} ceil
|
|
2247
|
-
* @returns {number}
|
|
2210
|
+
* @returns {boolean}
|
|
2248
2211
|
*/
|
|
2249
|
-
|
|
2250
|
-
const ret = wasm.
|
|
2251
|
-
return ret;
|
|
2212
|
+
is_submarine() {
|
|
2213
|
+
const ret = wasm.ship_is_submarine(this.__wbg_ptr);
|
|
2214
|
+
return ret !== 0;
|
|
2252
2215
|
}
|
|
2253
2216
|
/**
|
|
2254
|
-
* @returns {number}
|
|
2217
|
+
* @returns {number | undefined}
|
|
2255
2218
|
*/
|
|
2256
|
-
|
|
2257
|
-
const ret = wasm.
|
|
2258
|
-
return ret;
|
|
2219
|
+
get los() {
|
|
2220
|
+
const ret = wasm.ship_los(this.__wbg_ptr);
|
|
2221
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
2259
2222
|
}
|
|
2260
2223
|
/**
|
|
2261
|
-
* @returns {number}
|
|
2224
|
+
* @returns {number | undefined}
|
|
2262
2225
|
*/
|
|
2263
|
-
|
|
2264
|
-
const ret = wasm.
|
|
2265
|
-
return ret;
|
|
2226
|
+
get luck() {
|
|
2227
|
+
const ret = wasm.ship_luck(this.__wbg_ptr);
|
|
2228
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
2266
2229
|
}
|
|
2267
2230
|
/**
|
|
2268
|
-
* @returns {
|
|
2231
|
+
* @returns {number}
|
|
2269
2232
|
*/
|
|
2270
|
-
|
|
2271
|
-
const ret = wasm.
|
|
2233
|
+
get max_ammo() {
|
|
2234
|
+
const ret = wasm.ship_max_ammo(this.__wbg_ptr);
|
|
2272
2235
|
return ret;
|
|
2273
2236
|
}
|
|
2274
2237
|
/**
|
|
2275
|
-
* @returns {number
|
|
2238
|
+
* @returns {number}
|
|
2276
2239
|
*/
|
|
2277
|
-
|
|
2278
|
-
const ret = wasm.
|
|
2279
|
-
return ret
|
|
2240
|
+
get max_fuel() {
|
|
2241
|
+
const ret = wasm.ship_max_fuel(this.__wbg_ptr);
|
|
2242
|
+
return ret;
|
|
2280
2243
|
}
|
|
2281
2244
|
/**
|
|
2282
|
-
* @param {number} armor_penetration
|
|
2283
2245
|
* @returns {number | undefined}
|
|
2284
2246
|
*/
|
|
2285
|
-
|
|
2286
|
-
const ret = wasm.
|
|
2287
|
-
return ret
|
|
2247
|
+
get max_hp() {
|
|
2248
|
+
const ret = wasm.ship_max_hp(this.__wbg_ptr);
|
|
2249
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
2288
2250
|
}
|
|
2289
2251
|
/**
|
|
2290
|
-
* @
|
|
2291
|
-
* @returns {number | undefined}
|
|
2252
|
+
* @returns {ShipMeta}
|
|
2292
2253
|
*/
|
|
2293
|
-
|
|
2294
|
-
const
|
|
2295
|
-
|
|
2296
|
-
|
|
2297
|
-
|
|
2254
|
+
meta() {
|
|
2255
|
+
const ret = wasm.ship_meta(this.__wbg_ptr);
|
|
2256
|
+
if (ret[2]) {
|
|
2257
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2258
|
+
}
|
|
2259
|
+
return takeFromExternrefTable0(ret[0]);
|
|
2298
2260
|
}
|
|
2299
2261
|
/**
|
|
2300
|
-
*
|
|
2301
|
-
* @param {Side} side
|
|
2302
|
-
* @returns {number | undefined}
|
|
2262
|
+
* @returns {MoraleState}
|
|
2303
2263
|
*/
|
|
2304
|
-
|
|
2305
|
-
const ret = wasm.
|
|
2306
|
-
|
|
2264
|
+
morale_state() {
|
|
2265
|
+
const ret = wasm.ship_morale_state(this.__wbg_ptr);
|
|
2266
|
+
if (ret[2]) {
|
|
2267
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2268
|
+
}
|
|
2269
|
+
return takeFromExternrefTable0(ret[0]);
|
|
2307
2270
|
}
|
|
2308
2271
|
/**
|
|
2309
|
-
* @param {string} key
|
|
2310
2272
|
* @returns {number | undefined}
|
|
2311
2273
|
*/
|
|
2312
|
-
|
|
2313
|
-
const
|
|
2314
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2315
|
-
const ret = wasm.ship_get_stat_interval_right(this.__wbg_ptr, ptr0, len0);
|
|
2274
|
+
get naked_anti_air() {
|
|
2275
|
+
const ret = wasm.ship_naked_anti_air(this.__wbg_ptr);
|
|
2316
2276
|
return ret === 0xFFFFFF ? undefined : ret;
|
|
2317
2277
|
}
|
|
2318
2278
|
/**
|
|
2319
|
-
* @returns {number}
|
|
2279
|
+
* @returns {number | undefined}
|
|
2320
2280
|
*/
|
|
2321
|
-
get
|
|
2322
|
-
const ret = wasm.
|
|
2323
|
-
return ret;
|
|
2281
|
+
get naked_armor() {
|
|
2282
|
+
const ret = wasm.ship_naked_armor(this.__wbg_ptr);
|
|
2283
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
2324
2284
|
}
|
|
2325
2285
|
/**
|
|
2326
|
-
* @returns {
|
|
2286
|
+
* @returns {number | undefined}
|
|
2327
2287
|
*/
|
|
2328
|
-
|
|
2329
|
-
const ret = wasm.
|
|
2330
|
-
return ret
|
|
2288
|
+
get naked_asw() {
|
|
2289
|
+
const ret = wasm.ship_naked_asw(this.__wbg_ptr);
|
|
2290
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
2331
2291
|
}
|
|
2332
2292
|
/**
|
|
2333
2293
|
* @returns {number | undefined}
|
|
2334
2294
|
*/
|
|
2335
|
-
get
|
|
2336
|
-
const ret = wasm.
|
|
2295
|
+
get naked_evasion() {
|
|
2296
|
+
const ret = wasm.ship_naked_evasion(this.__wbg_ptr);
|
|
2337
2297
|
return ret === 0xFFFFFF ? undefined : ret;
|
|
2338
2298
|
}
|
|
2339
2299
|
/**
|
|
2340
2300
|
* @returns {number | undefined}
|
|
2341
2301
|
*/
|
|
2342
|
-
get
|
|
2343
|
-
const ret = wasm.
|
|
2302
|
+
get naked_firepower() {
|
|
2303
|
+
const ret = wasm.ship_naked_firepower(this.__wbg_ptr);
|
|
2344
2304
|
return ret === 0xFFFFFF ? undefined : ret;
|
|
2345
2305
|
}
|
|
2346
2306
|
/**
|
|
2347
|
-
* @param {number} node_divaricated_factor
|
|
2348
2307
|
* @returns {number | undefined}
|
|
2349
2308
|
*/
|
|
2350
|
-
|
|
2351
|
-
const ret = wasm.
|
|
2352
|
-
return ret
|
|
2309
|
+
get naked_los() {
|
|
2310
|
+
const ret = wasm.ship_naked_los(this.__wbg_ptr);
|
|
2311
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
2353
2312
|
}
|
|
2354
2313
|
/**
|
|
2355
2314
|
* @returns {number | undefined}
|
|
2356
2315
|
*/
|
|
2357
|
-
get
|
|
2358
|
-
const ret = wasm.
|
|
2316
|
+
get naked_range() {
|
|
2317
|
+
const ret = wasm.ship_naked_range(this.__wbg_ptr);
|
|
2359
2318
|
return ret === 0xFFFFFF ? undefined : ret;
|
|
2360
2319
|
}
|
|
2361
2320
|
/**
|
|
2362
|
-
* @returns {
|
|
2321
|
+
* @returns {number}
|
|
2363
2322
|
*/
|
|
2364
|
-
|
|
2365
|
-
const ret = wasm.
|
|
2323
|
+
get naked_speed() {
|
|
2324
|
+
const ret = wasm.ship_naked_speed(this.__wbg_ptr);
|
|
2366
2325
|
return ret;
|
|
2367
2326
|
}
|
|
2327
|
+
/**
|
|
2328
|
+
* @returns {number | undefined}
|
|
2329
|
+
*/
|
|
2330
|
+
get naked_torpedo() {
|
|
2331
|
+
const ret = wasm.ship_naked_torpedo(this.__wbg_ptr);
|
|
2332
|
+
return ret === 0xFFFFFF ? undefined : ret;
|
|
2333
|
+
}
|
|
2368
2334
|
/**
|
|
2369
2335
|
* @returns {string}
|
|
2370
2336
|
*/
|
|
@@ -2381,39 +2347,22 @@ export class Ship {
|
|
|
2381
2347
|
}
|
|
2382
2348
|
}
|
|
2383
2349
|
/**
|
|
2384
|
-
* @returns {
|
|
2350
|
+
* @returns {number}
|
|
2385
2351
|
*/
|
|
2386
|
-
get
|
|
2387
|
-
|
|
2388
|
-
|
|
2389
|
-
try {
|
|
2390
|
-
const ret = wasm.ship_yomi(this.__wbg_ptr);
|
|
2391
|
-
deferred1_0 = ret[0];
|
|
2392
|
-
deferred1_1 = ret[1];
|
|
2393
|
-
return getStringFromWasm0(ret[0], ret[1]);
|
|
2394
|
-
} finally {
|
|
2395
|
-
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
2396
|
-
}
|
|
2352
|
+
get next_id() {
|
|
2353
|
+
const ret = wasm.ship_next_id(this.__wbg_ptr);
|
|
2354
|
+
return ret;
|
|
2397
2355
|
}
|
|
2398
2356
|
/**
|
|
2357
|
+
* 確殺攻撃力
|
|
2399
2358
|
* @returns {number | undefined}
|
|
2400
2359
|
*/
|
|
2401
|
-
|
|
2402
|
-
const ret = wasm.
|
|
2403
|
-
return ret ===
|
|
2360
|
+
ohko_power() {
|
|
2361
|
+
const ret = wasm.ship_ohko_power(this.__wbg_ptr);
|
|
2362
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
2404
2363
|
}
|
|
2405
2364
|
/**
|
|
2406
|
-
* @
|
|
2407
|
-
* @returns {boolean}
|
|
2408
|
-
*/
|
|
2409
|
-
eq_id(id) {
|
|
2410
|
-
const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2411
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2412
|
-
const ret = wasm.ship_eq_id(this.__wbg_ptr, ptr0, len0);
|
|
2413
|
-
return ret !== 0;
|
|
2414
|
-
}
|
|
2415
|
-
/**
|
|
2416
|
-
* @returns {number | undefined}
|
|
2365
|
+
* @returns {number | undefined}
|
|
2417
2366
|
*/
|
|
2418
2367
|
get range() {
|
|
2419
2368
|
const ret = wasm.ship_range(this.__wbg_ptr);
|
|
@@ -2422,58 +2371,54 @@ export class Ship {
|
|
|
2422
2371
|
/**
|
|
2423
2372
|
* @returns {number}
|
|
2424
2373
|
*/
|
|
2425
|
-
|
|
2426
|
-
const ret = wasm.
|
|
2374
|
+
remaining_ammo_mod() {
|
|
2375
|
+
const ret = wasm.ship_remaining_ammo_mod(this.__wbg_ptr);
|
|
2427
2376
|
return ret;
|
|
2428
2377
|
}
|
|
2429
2378
|
/**
|
|
2430
|
-
* @returns {
|
|
2379
|
+
* @returns {number}
|
|
2431
2380
|
*/
|
|
2432
|
-
|
|
2433
|
-
const ret = wasm.
|
|
2381
|
+
remaining_fuel_mod() {
|
|
2382
|
+
const ret = wasm.ship_remaining_fuel_mod(this.__wbg_ptr);
|
|
2434
2383
|
return ret;
|
|
2435
2384
|
}
|
|
2436
2385
|
/**
|
|
2437
2386
|
* @returns {number}
|
|
2438
2387
|
*/
|
|
2439
|
-
get
|
|
2440
|
-
const ret = wasm.
|
|
2388
|
+
get remodel_rank() {
|
|
2389
|
+
const ret = wasm.ship_remodel_rank(this.__wbg_ptr);
|
|
2441
2390
|
return ret;
|
|
2442
2391
|
}
|
|
2443
2392
|
/**
|
|
2444
|
-
* @
|
|
2445
|
-
*/
|
|
2446
|
-
get max_hp() {
|
|
2447
|
-
const ret = wasm.ship_max_hp(this.__wbg_ptr);
|
|
2448
|
-
return ret === 0xFFFFFF ? undefined : ret;
|
|
2449
|
-
}
|
|
2450
|
-
/**
|
|
2451
|
-
* @returns {boolean}
|
|
2452
|
-
*/
|
|
2453
|
-
get useful() {
|
|
2454
|
-
const ret = wasm.ship_useful(this.__wbg_ptr);
|
|
2455
|
-
return ret !== 0;
|
|
2456
|
-
}
|
|
2457
|
-
/**
|
|
2458
|
-
* @returns {Ship}
|
|
2393
|
+
* @param {SlotSizeVec} slots
|
|
2459
2394
|
*/
|
|
2460
|
-
|
|
2461
|
-
const ret = wasm.
|
|
2462
|
-
|
|
2395
|
+
set slots(slots) {
|
|
2396
|
+
const ret = wasm.ship_set_slots_js(this.__wbg_ptr, slots);
|
|
2397
|
+
if (ret[1]) {
|
|
2398
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
2399
|
+
}
|
|
2463
2400
|
}
|
|
2464
2401
|
/**
|
|
2402
|
+
* 加重対空
|
|
2403
|
+
* @param {Side} side
|
|
2465
2404
|
* @returns {number | undefined}
|
|
2466
2405
|
*/
|
|
2467
|
-
|
|
2468
|
-
const ret = wasm.
|
|
2469
|
-
|
|
2406
|
+
ship_adjusted_anti_air(side) {
|
|
2407
|
+
const ret = wasm.ship_ship_adjusted_anti_air(this.__wbg_ptr, side);
|
|
2408
|
+
if (ret[3]) {
|
|
2409
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2410
|
+
}
|
|
2411
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
2470
2412
|
}
|
|
2471
2413
|
/**
|
|
2472
|
-
* @returns {
|
|
2414
|
+
* @returns {ShipType}
|
|
2473
2415
|
*/
|
|
2474
|
-
get
|
|
2475
|
-
const ret = wasm.
|
|
2476
|
-
|
|
2416
|
+
get ship_type() {
|
|
2417
|
+
const ret = wasm.ship_ship_type_js(this.__wbg_ptr);
|
|
2418
|
+
if (ret[2]) {
|
|
2419
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2420
|
+
}
|
|
2421
|
+
return takeFromExternrefTable0(ret[0]);
|
|
2477
2422
|
}
|
|
2478
2423
|
/**
|
|
2479
2424
|
* @returns {number}
|
|
@@ -2483,140 +2428,155 @@ export class Ship {
|
|
|
2483
2428
|
return ret >>> 0;
|
|
2484
2429
|
}
|
|
2485
2430
|
/**
|
|
2486
|
-
* @returns {
|
|
2487
|
-
*/
|
|
2488
|
-
get sort_id() {
|
|
2489
|
-
const ret = wasm.ship_sort_id(this.__wbg_ptr);
|
|
2490
|
-
return ret;
|
|
2491
|
-
}
|
|
2492
|
-
/**
|
|
2493
|
-
* @returns {number | undefined}
|
|
2431
|
+
* @returns {SlotSizeVec}
|
|
2494
2432
|
*/
|
|
2495
|
-
get
|
|
2496
|
-
const ret = wasm.
|
|
2497
|
-
|
|
2433
|
+
get slots() {
|
|
2434
|
+
const ret = wasm.ship_slots_js(this.__wbg_ptr);
|
|
2435
|
+
if (ret[2]) {
|
|
2436
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2437
|
+
}
|
|
2438
|
+
return takeFromExternrefTable0(ret[0]);
|
|
2498
2439
|
}
|
|
2499
2440
|
/**
|
|
2500
2441
|
* @returns {number}
|
|
2501
2442
|
*/
|
|
2502
|
-
get
|
|
2503
|
-
const ret = wasm.
|
|
2443
|
+
get sort_id() {
|
|
2444
|
+
const ret = wasm.ship_sort_id(this.__wbg_ptr);
|
|
2504
2445
|
return ret;
|
|
2505
2446
|
}
|
|
2506
2447
|
/**
|
|
2507
|
-
* @returns {
|
|
2448
|
+
* @returns {SpecialEnemyType}
|
|
2508
2449
|
*/
|
|
2509
|
-
|
|
2510
|
-
const ret = wasm.
|
|
2511
|
-
|
|
2450
|
+
special_enemy_type() {
|
|
2451
|
+
const ret = wasm.ship_special_enemy_type(this.__wbg_ptr);
|
|
2452
|
+
if (ret[2]) {
|
|
2453
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2454
|
+
}
|
|
2455
|
+
return takeFromExternrefTable0(ret[0]);
|
|
2512
2456
|
}
|
|
2513
2457
|
/**
|
|
2514
|
-
* @returns {
|
|
2458
|
+
* @returns {number}
|
|
2515
2459
|
*/
|
|
2516
|
-
|
|
2517
|
-
const ret = wasm.
|
|
2460
|
+
get speed() {
|
|
2461
|
+
const ret = wasm.ship_speed(this.__wbg_ptr);
|
|
2518
2462
|
return ret;
|
|
2519
2463
|
}
|
|
2520
2464
|
/**
|
|
2521
|
-
* @
|
|
2522
|
-
* @returns {Gear | undefined}
|
|
2465
|
+
* @returns {ShipState}
|
|
2523
2466
|
*/
|
|
2524
|
-
|
|
2525
|
-
const
|
|
2526
|
-
|
|
2527
|
-
|
|
2528
|
-
|
|
2467
|
+
state() {
|
|
2468
|
+
const ret = wasm.ship_state(this.__wbg_ptr);
|
|
2469
|
+
if (ret[2]) {
|
|
2470
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2471
|
+
}
|
|
2472
|
+
return takeFromExternrefTable0(ret[0]);
|
|
2529
2473
|
}
|
|
2530
2474
|
/**
|
|
2531
|
-
* @
|
|
2532
|
-
* @returns {boolean}
|
|
2475
|
+
* @returns {number | undefined}
|
|
2533
2476
|
*/
|
|
2534
|
-
|
|
2535
|
-
const ret = wasm.
|
|
2536
|
-
return ret
|
|
2477
|
+
state_day_gunfit_accuracy() {
|
|
2478
|
+
const ret = wasm.ship_state_day_gunfit_accuracy(this.__wbg_ptr);
|
|
2479
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
2537
2480
|
}
|
|
2538
2481
|
/**
|
|
2539
|
-
* @returns {number}
|
|
2482
|
+
* @returns {number | undefined}
|
|
2540
2483
|
*/
|
|
2541
|
-
|
|
2542
|
-
const ret = wasm.
|
|
2543
|
-
return ret;
|
|
2484
|
+
state_night_gunfit_accuracy() {
|
|
2485
|
+
const ret = wasm.ship_state_night_gunfit_accuracy(this.__wbg_ptr);
|
|
2486
|
+
return ret[0] === 0 ? undefined : ret[1];
|
|
2544
2487
|
}
|
|
2545
2488
|
/**
|
|
2546
2489
|
* @returns {number}
|
|
2547
2490
|
*/
|
|
2548
|
-
get
|
|
2549
|
-
const ret = wasm.
|
|
2491
|
+
get stype() {
|
|
2492
|
+
const ret = wasm.ship_stype(this.__wbg_ptr);
|
|
2550
2493
|
return ret;
|
|
2551
2494
|
}
|
|
2552
|
-
/**
|
|
2553
|
-
* @param {Gear} gear
|
|
2554
|
-
* @param {string} key
|
|
2555
|
-
* @returns {boolean}
|
|
2556
|
-
*/
|
|
2557
|
-
can_equip(gear, key) {
|
|
2558
|
-
_assertClass(gear, Gear);
|
|
2559
|
-
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2560
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2561
|
-
const ret = wasm.ship_can_equip(this.__wbg_ptr, gear.__wbg_ptr, ptr0, len0);
|
|
2562
|
-
return ret !== 0;
|
|
2563
|
-
}
|
|
2564
2495
|
/**
|
|
2565
2496
|
* @returns {number | undefined}
|
|
2566
2497
|
*/
|
|
2567
|
-
get
|
|
2568
|
-
const ret = wasm.
|
|
2498
|
+
get torpedo() {
|
|
2499
|
+
const ret = wasm.ship_torpedo(this.__wbg_ptr);
|
|
2569
2500
|
return ret === 0xFFFFFF ? undefined : ret;
|
|
2570
2501
|
}
|
|
2571
2502
|
/**
|
|
2572
|
-
* @returns {
|
|
2503
|
+
* @returns {number}
|
|
2573
2504
|
*/
|
|
2574
|
-
|
|
2575
|
-
const ret = wasm.
|
|
2576
|
-
|
|
2577
|
-
wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
|
|
2578
|
-
return v1;
|
|
2505
|
+
transport_point() {
|
|
2506
|
+
const ret = wasm.ship_transport_point(this.__wbg_ptr);
|
|
2507
|
+
return ret;
|
|
2579
2508
|
}
|
|
2580
2509
|
/**
|
|
2581
2510
|
* @returns {boolean}
|
|
2582
2511
|
*/
|
|
2583
|
-
|
|
2584
|
-
const ret = wasm.
|
|
2512
|
+
get useful() {
|
|
2513
|
+
const ret = wasm.ship_useful(this.__wbg_ptr);
|
|
2585
2514
|
return ret !== 0;
|
|
2586
2515
|
}
|
|
2587
2516
|
/**
|
|
2588
|
-
* @returns {
|
|
2589
|
-
*/
|
|
2590
|
-
get naked_asw() {
|
|
2591
|
-
const ret = wasm.ship_naked_asw(this.__wbg_ptr);
|
|
2592
|
-
return ret === 0xFFFFFF ? undefined : ret;
|
|
2593
|
-
}
|
|
2594
|
-
/**
|
|
2595
|
-
* @returns {number | undefined}
|
|
2517
|
+
* @returns {string}
|
|
2596
2518
|
*/
|
|
2597
|
-
get
|
|
2598
|
-
|
|
2599
|
-
|
|
2519
|
+
get yomi() {
|
|
2520
|
+
let deferred1_0;
|
|
2521
|
+
let deferred1_1;
|
|
2522
|
+
try {
|
|
2523
|
+
const ret = wasm.ship_yomi(this.__wbg_ptr);
|
|
2524
|
+
deferred1_0 = ret[0];
|
|
2525
|
+
deferred1_1 = ret[1];
|
|
2526
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
2527
|
+
} finally {
|
|
2528
|
+
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
2529
|
+
}
|
|
2600
2530
|
}
|
|
2601
2531
|
}
|
|
2602
2532
|
if (Symbol.dispose) Ship.prototype[Symbol.dispose] = Ship.prototype.free;
|
|
2603
2533
|
|
|
2604
|
-
|
|
2605
|
-
|
|
2606
|
-
|
|
2607
|
-
|
|
2534
|
+
/**
|
|
2535
|
+
* @param {ShipConditions} value
|
|
2536
|
+
* @returns {ShipConditions}
|
|
2537
|
+
*/
|
|
2538
|
+
export function parse_ship_conditions(value) {
|
|
2539
|
+
const ret = wasm.parse_ship_conditions(value);
|
|
2540
|
+
if (ret[2]) {
|
|
2541
|
+
throw takeFromExternrefTable0(ret[1]);
|
|
2542
|
+
}
|
|
2543
|
+
return takeFromExternrefTable0(ret[0]);
|
|
2544
|
+
}
|
|
2608
2545
|
|
|
2609
|
-
export function
|
|
2610
|
-
|
|
2546
|
+
export function set_panic_hook() {
|
|
2547
|
+
wasm.set_panic_hook();
|
|
2548
|
+
}
|
|
2549
|
+
export function __wbg_Error_30c8987f7c2ed4e2(arg0, arg1) {
|
|
2550
|
+
const ret = Error(getStringFromWasm0(arg0, arg1));
|
|
2611
2551
|
return ret;
|
|
2612
|
-
}
|
|
2613
|
-
|
|
2614
|
-
|
|
2615
|
-
const
|
|
2552
|
+
}
|
|
2553
|
+
export function __wbg___wbindgen_debug_string_4687d8d8c2017d52(arg0, arg1) {
|
|
2554
|
+
const ret = debugString(arg1);
|
|
2555
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2556
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2557
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
2558
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
2559
|
+
}
|
|
2560
|
+
export function __wbg___wbindgen_is_undefined_8865fb403f8fe9d8(arg0) {
|
|
2561
|
+
const ret = arg0 === undefined;
|
|
2616
2562
|
return ret;
|
|
2617
|
-
}
|
|
2618
|
-
|
|
2619
|
-
|
|
2563
|
+
}
|
|
2564
|
+
export function __wbg___wbindgen_string_get_0380ccaa2f57f0d9(arg0, arg1) {
|
|
2565
|
+
const obj = arg1;
|
|
2566
|
+
const ret = typeof(obj) === 'string' ? obj : undefined;
|
|
2567
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2568
|
+
var len1 = WASM_VECTOR_LEN;
|
|
2569
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
2570
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
2571
|
+
}
|
|
2572
|
+
export function __wbg___wbindgen_throw_41e9ee4f547fc59a(arg0, arg1) {
|
|
2573
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
2574
|
+
}
|
|
2575
|
+
export function __wbg_createEquipmentBonuses_a2c75928d6e342a7() { return handleError(function (arg0, arg1) {
|
|
2576
|
+
const ret = createEquipmentBonuses(arg0, arg1);
|
|
2577
|
+
return ret;
|
|
2578
|
+
}, arguments); }
|
|
2579
|
+
export function __wbg_error_757e9472f8410341(arg0, arg1) {
|
|
2620
2580
|
let deferred0_0;
|
|
2621
2581
|
let deferred0_1;
|
|
2622
2582
|
try {
|
|
@@ -2626,177 +2586,307 @@ export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
|
|
|
2626
2586
|
} finally {
|
|
2627
2587
|
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
2628
2588
|
}
|
|
2629
|
-
}
|
|
2630
|
-
|
|
2631
|
-
|
|
2632
|
-
|
|
2633
|
-
|
|
2634
|
-
|
|
2635
|
-
export function __wbg_length_6bb7e81f9d7713e4(arg0) {
|
|
2636
|
-
const ret = arg0.length;
|
|
2637
|
-
return ret;
|
|
2638
|
-
};
|
|
2639
|
-
|
|
2640
|
-
export function __wbg_msCrypto_0a36e2ec3a343d26(arg0) {
|
|
2641
|
-
const ret = arg0.msCrypto;
|
|
2642
|
-
return ret;
|
|
2643
|
-
};
|
|
2644
|
-
|
|
2645
|
-
export function __wbg_new_1f3a344cf3123716() {
|
|
2646
|
-
const ret = new Array();
|
|
2647
|
-
return ret;
|
|
2648
|
-
};
|
|
2649
|
-
|
|
2650
|
-
export function __wbg_new_8a6f238a6ece86ea() {
|
|
2589
|
+
}
|
|
2590
|
+
export function __wbg_getRandomValues_436a51d0629d84e1() { return handleError(function (arg0, arg1) {
|
|
2591
|
+
globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
|
|
2592
|
+
}, arguments); }
|
|
2593
|
+
export function __wbg_new_227d7c05414eb861() {
|
|
2651
2594
|
const ret = new Error();
|
|
2652
2595
|
return ret;
|
|
2653
|
-
}
|
|
2654
|
-
|
|
2655
|
-
|
|
2656
|
-
const ret = new Function(getStringFromWasm0(arg0, arg1));
|
|
2657
|
-
return ret;
|
|
2658
|
-
};
|
|
2659
|
-
|
|
2660
|
-
export function __wbg_newwithlength_a167dcc7aaa3ba77(arg0) {
|
|
2661
|
-
const ret = new Uint8Array(arg0 >>> 0);
|
|
2662
|
-
return ret;
|
|
2663
|
-
};
|
|
2664
|
-
|
|
2665
|
-
export function __wbg_node_02999533c4ea02e3(arg0) {
|
|
2666
|
-
const ret = arg0.node;
|
|
2596
|
+
}
|
|
2597
|
+
export function __wbg_new_ee2291f50781bf1d() {
|
|
2598
|
+
const ret = new Array();
|
|
2667
2599
|
return ret;
|
|
2668
|
-
}
|
|
2669
|
-
|
|
2670
|
-
export function __wbg_parse_442f5ba02e5eaf8b() { return handleError(function (arg0, arg1) {
|
|
2600
|
+
}
|
|
2601
|
+
export function __wbg_parse_0fc53dead14b3b42() { return handleError(function (arg0, arg1) {
|
|
2671
2602
|
const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
|
|
2672
2603
|
return ret;
|
|
2673
|
-
}, arguments) }
|
|
2674
|
-
|
|
2675
|
-
export function __wbg_process_5c1d670bc53614b8(arg0) {
|
|
2676
|
-
const ret = arg0.process;
|
|
2677
|
-
return ret;
|
|
2678
|
-
};
|
|
2679
|
-
|
|
2680
|
-
export function __wbg_prototypesetcall_3d4a26c1ed734349(arg0, arg1, arg2) {
|
|
2681
|
-
Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
|
|
2682
|
-
};
|
|
2683
|
-
|
|
2684
|
-
export function __wbg_push_330b2eb93e4e1212(arg0, arg1) {
|
|
2604
|
+
}, arguments); }
|
|
2605
|
+
export function __wbg_push_2baf45db356cf468(arg0, arg1) {
|
|
2685
2606
|
const ret = arg0.push(arg1);
|
|
2686
2607
|
return ret;
|
|
2687
|
-
}
|
|
2688
|
-
|
|
2689
|
-
export function __wbg_randomFillSync_ab2cfe79ebbf2740() { return handleError(function (arg0, arg1) {
|
|
2690
|
-
arg0.randomFillSync(arg1);
|
|
2691
|
-
}, arguments) };
|
|
2692
|
-
|
|
2693
|
-
export function __wbg_require_79b1e9274cde3c87() { return handleError(function () {
|
|
2694
|
-
const ret = module.require;
|
|
2695
|
-
return ret;
|
|
2696
|
-
}, arguments) };
|
|
2697
|
-
|
|
2608
|
+
}
|
|
2698
2609
|
export function __wbg_ship_new(arg0) {
|
|
2699
2610
|
const ret = Ship.__wrap(arg0);
|
|
2700
2611
|
return ret;
|
|
2701
|
-
}
|
|
2702
|
-
|
|
2703
|
-
export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
|
|
2612
|
+
}
|
|
2613
|
+
export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
|
|
2704
2614
|
const ret = arg1.stack;
|
|
2705
2615
|
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2706
2616
|
const len1 = WASM_VECTOR_LEN;
|
|
2707
2617
|
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
2708
2618
|
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
2709
|
-
}
|
|
2619
|
+
}
|
|
2620
|
+
export function __wbg_stringify_52ff602c1cc4fbb6() { return handleError(function (arg0) {
|
|
2621
|
+
const ret = JSON.stringify(arg0);
|
|
2622
|
+
return ret;
|
|
2623
|
+
}, arguments); }
|
|
2624
|
+
export function __wbindgen_generic_0000000000000001(arg0, arg1) {
|
|
2625
|
+
// Cast intrinsic for `Ref(String) -> Externref`.
|
|
2626
|
+
const ret = getStringFromWasm0(arg0, arg1);
|
|
2627
|
+
return ret;
|
|
2628
|
+
}
|
|
2629
|
+
export function __wbindgen_init_externref_table() {
|
|
2630
|
+
const table = wasm.__wbindgen_externrefs;
|
|
2631
|
+
const offset = table.grow(4);
|
|
2632
|
+
table.set(0, undefined);
|
|
2633
|
+
table.set(offset + 0, undefined);
|
|
2634
|
+
table.set(offset + 1, null);
|
|
2635
|
+
table.set(offset + 2, true);
|
|
2636
|
+
table.set(offset + 3, false);
|
|
2637
|
+
}
|
|
2638
|
+
const AirSquadronFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
2639
|
+
? { register: () => {}, unregister: () => {} }
|
|
2640
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_airsquadron_free(ptr, 1));
|
|
2641
|
+
const AnalyzerFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
2642
|
+
? { register: () => {}, unregister: () => {} }
|
|
2643
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_analyzer_free(ptr, 1));
|
|
2644
|
+
const CompFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
2645
|
+
? { register: () => {}, unregister: () => {} }
|
|
2646
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_comp_free(ptr, 1));
|
|
2647
|
+
const FhCoreFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
2648
|
+
? { register: () => {}, unregister: () => {} }
|
|
2649
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_fhcore_free(ptr, 1));
|
|
2650
|
+
const FleetFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
2651
|
+
? { register: () => {}, unregister: () => {} }
|
|
2652
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_fleet_free(ptr, 1));
|
|
2653
|
+
const GearFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
2654
|
+
? { register: () => {}, unregister: () => {} }
|
|
2655
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_gear_free(ptr, 1));
|
|
2656
|
+
const OrgFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
2657
|
+
? { register: () => {}, unregister: () => {} }
|
|
2658
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_org_free(ptr, 1));
|
|
2659
|
+
const ShipFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
2660
|
+
? { register: () => {}, unregister: () => {} }
|
|
2661
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_ship_free(ptr, 1));
|
|
2710
2662
|
|
|
2711
|
-
|
|
2712
|
-
const
|
|
2713
|
-
|
|
2714
|
-
|
|
2663
|
+
function addToExternrefTable0(obj) {
|
|
2664
|
+
const idx = wasm.__externref_table_alloc();
|
|
2665
|
+
wasm.__wbindgen_externrefs.set(idx, obj);
|
|
2666
|
+
return idx;
|
|
2667
|
+
}
|
|
2715
2668
|
|
|
2716
|
-
|
|
2717
|
-
|
|
2718
|
-
|
|
2719
|
-
}
|
|
2669
|
+
function _assertClass(instance, klass) {
|
|
2670
|
+
if (!(instance instanceof klass)) {
|
|
2671
|
+
throw new Error(`expected instance of ${klass.name}`);
|
|
2672
|
+
}
|
|
2673
|
+
}
|
|
2720
2674
|
|
|
2721
|
-
|
|
2722
|
-
|
|
2723
|
-
|
|
2724
|
-
|
|
2675
|
+
function debugString(val) {
|
|
2676
|
+
// primitive types
|
|
2677
|
+
const type = typeof val;
|
|
2678
|
+
if (type == 'number' || type == 'boolean' || val == null) {
|
|
2679
|
+
return `${val}`;
|
|
2680
|
+
}
|
|
2681
|
+
if (type == 'string') {
|
|
2682
|
+
return `"${val}"`;
|
|
2683
|
+
}
|
|
2684
|
+
if (type == 'symbol') {
|
|
2685
|
+
const description = val.description;
|
|
2686
|
+
if (description == null) {
|
|
2687
|
+
return 'Symbol';
|
|
2688
|
+
} else {
|
|
2689
|
+
return `Symbol(${description})`;
|
|
2690
|
+
}
|
|
2691
|
+
}
|
|
2692
|
+
if (type == 'function') {
|
|
2693
|
+
const name = val.name;
|
|
2694
|
+
if (typeof name == 'string' && name.length > 0) {
|
|
2695
|
+
return `Function(${name})`;
|
|
2696
|
+
} else {
|
|
2697
|
+
return 'Function';
|
|
2698
|
+
}
|
|
2699
|
+
}
|
|
2700
|
+
// objects
|
|
2701
|
+
if (Array.isArray(val)) {
|
|
2702
|
+
const length = val.length;
|
|
2703
|
+
let debug = '[';
|
|
2704
|
+
if (length > 0) {
|
|
2705
|
+
debug += debugString(val[0]);
|
|
2706
|
+
}
|
|
2707
|
+
for(let i = 1; i < length; i++) {
|
|
2708
|
+
debug += ', ' + debugString(val[i]);
|
|
2709
|
+
}
|
|
2710
|
+
debug += ']';
|
|
2711
|
+
return debug;
|
|
2712
|
+
}
|
|
2713
|
+
// Test for built-in
|
|
2714
|
+
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
|
2715
|
+
let className;
|
|
2716
|
+
if (builtInMatches && builtInMatches.length > 1) {
|
|
2717
|
+
className = builtInMatches[1];
|
|
2718
|
+
} else {
|
|
2719
|
+
// Failed to match the standard '[object ClassName]'
|
|
2720
|
+
return toString.call(val);
|
|
2721
|
+
}
|
|
2722
|
+
if (className == 'Object') {
|
|
2723
|
+
// we're a user defined class or Object
|
|
2724
|
+
// JSON.stringify avoids problems with cycles, and is generally much
|
|
2725
|
+
// easier than looping through ownProperties of `val`.
|
|
2726
|
+
try {
|
|
2727
|
+
return 'Object(' + JSON.stringify(val) + ')';
|
|
2728
|
+
} catch (_) {
|
|
2729
|
+
return 'Object';
|
|
2730
|
+
}
|
|
2731
|
+
}
|
|
2732
|
+
// errors
|
|
2733
|
+
if (val instanceof Error) {
|
|
2734
|
+
return `${val.name}: ${val.message}\n${val.stack}`;
|
|
2735
|
+
}
|
|
2736
|
+
// TODO we could test for more things here, like `Set`s and `Map`s.
|
|
2737
|
+
return className;
|
|
2738
|
+
}
|
|
2725
2739
|
|
|
2726
|
-
|
|
2727
|
-
|
|
2728
|
-
|
|
2729
|
-
|
|
2740
|
+
function getArrayJsValueFromWasm0(ptr, len) {
|
|
2741
|
+
ptr = ptr >>> 0;
|
|
2742
|
+
const mem = getDataViewMemory0();
|
|
2743
|
+
const result = [];
|
|
2744
|
+
for (let i = ptr; i < ptr + 4 * len; i += 4) {
|
|
2745
|
+
result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
|
|
2746
|
+
}
|
|
2747
|
+
wasm.__externref_drop_slice(ptr, len);
|
|
2748
|
+
return result;
|
|
2749
|
+
}
|
|
2730
2750
|
|
|
2731
|
-
|
|
2732
|
-
|
|
2733
|
-
return
|
|
2734
|
-
}
|
|
2751
|
+
function getArrayU16FromWasm0(ptr, len) {
|
|
2752
|
+
ptr = ptr >>> 0;
|
|
2753
|
+
return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
|
|
2754
|
+
}
|
|
2735
2755
|
|
|
2736
|
-
|
|
2737
|
-
|
|
2738
|
-
return
|
|
2739
|
-
}
|
|
2756
|
+
function getArrayU8FromWasm0(ptr, len) {
|
|
2757
|
+
ptr = ptr >>> 0;
|
|
2758
|
+
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
2759
|
+
}
|
|
2740
2760
|
|
|
2741
|
-
|
|
2742
|
-
|
|
2743
|
-
|
|
2744
|
-
|
|
2761
|
+
let cachedDataViewMemory0 = null;
|
|
2762
|
+
function getDataViewMemory0() {
|
|
2763
|
+
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
|
|
2764
|
+
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
2765
|
+
}
|
|
2766
|
+
return cachedDataViewMemory0;
|
|
2767
|
+
}
|
|
2745
2768
|
|
|
2746
|
-
|
|
2747
|
-
|
|
2748
|
-
|
|
2749
|
-
};
|
|
2769
|
+
function getStringFromWasm0(ptr, len) {
|
|
2770
|
+
return decodeText(ptr >>> 0, len);
|
|
2771
|
+
}
|
|
2750
2772
|
|
|
2751
|
-
|
|
2752
|
-
|
|
2753
|
-
|
|
2754
|
-
|
|
2755
|
-
}
|
|
2773
|
+
let cachedUint16ArrayMemory0 = null;
|
|
2774
|
+
function getUint16ArrayMemory0() {
|
|
2775
|
+
if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
|
|
2776
|
+
cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
|
|
2777
|
+
}
|
|
2778
|
+
return cachedUint16ArrayMemory0;
|
|
2779
|
+
}
|
|
2756
2780
|
|
|
2757
|
-
|
|
2758
|
-
|
|
2759
|
-
|
|
2760
|
-
|
|
2781
|
+
let cachedUint8ArrayMemory0 = null;
|
|
2782
|
+
function getUint8ArrayMemory0() {
|
|
2783
|
+
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
2784
|
+
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
|
|
2785
|
+
}
|
|
2786
|
+
return cachedUint8ArrayMemory0;
|
|
2787
|
+
}
|
|
2761
2788
|
|
|
2762
|
-
|
|
2763
|
-
|
|
2764
|
-
|
|
2765
|
-
}
|
|
2789
|
+
function handleError(f, args) {
|
|
2790
|
+
try {
|
|
2791
|
+
return f.apply(this, args);
|
|
2792
|
+
} catch (e) {
|
|
2793
|
+
const idx = addToExternrefTable0(e);
|
|
2794
|
+
wasm.__wbindgen_exn_store(idx);
|
|
2795
|
+
}
|
|
2796
|
+
}
|
|
2766
2797
|
|
|
2767
|
-
|
|
2768
|
-
|
|
2769
|
-
|
|
2770
|
-
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2771
|
-
var len1 = WASM_VECTOR_LEN;
|
|
2772
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
2773
|
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
2774
|
-
};
|
|
2798
|
+
function isLikeNone(x) {
|
|
2799
|
+
return x === undefined || x === null;
|
|
2800
|
+
}
|
|
2775
2801
|
|
|
2776
|
-
|
|
2777
|
-
|
|
2778
|
-
|
|
2802
|
+
function passArray16ToWasm0(arg, malloc) {
|
|
2803
|
+
const ptr = malloc(arg.length * 2, 2) >>> 0;
|
|
2804
|
+
getUint16ArrayMemory0().set(arg, ptr / 2);
|
|
2805
|
+
WASM_VECTOR_LEN = arg.length;
|
|
2806
|
+
return ptr;
|
|
2807
|
+
}
|
|
2779
2808
|
|
|
2780
|
-
|
|
2781
|
-
|
|
2782
|
-
|
|
2783
|
-
|
|
2784
|
-
|
|
2809
|
+
function passArray8ToWasm0(arg, malloc) {
|
|
2810
|
+
const ptr = malloc(arg.length * 1, 1) >>> 0;
|
|
2811
|
+
getUint8ArrayMemory0().set(arg, ptr / 1);
|
|
2812
|
+
WASM_VECTOR_LEN = arg.length;
|
|
2813
|
+
return ptr;
|
|
2814
|
+
}
|
|
2785
2815
|
|
|
2786
|
-
|
|
2787
|
-
|
|
2788
|
-
|
|
2789
|
-
|
|
2790
|
-
|
|
2816
|
+
function passStringToWasm0(arg, malloc, realloc) {
|
|
2817
|
+
if (realloc === undefined) {
|
|
2818
|
+
const buf = cachedTextEncoder.encode(arg);
|
|
2819
|
+
const ptr = malloc(buf.length, 1) >>> 0;
|
|
2820
|
+
getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
|
|
2821
|
+
WASM_VECTOR_LEN = buf.length;
|
|
2822
|
+
return ptr;
|
|
2823
|
+
}
|
|
2791
2824
|
|
|
2792
|
-
|
|
2793
|
-
|
|
2794
|
-
|
|
2795
|
-
|
|
2796
|
-
table.set(offset + 0, undefined);
|
|
2797
|
-
table.set(offset + 1, null);
|
|
2798
|
-
table.set(offset + 2, true);
|
|
2799
|
-
table.set(offset + 3, false);
|
|
2800
|
-
;
|
|
2801
|
-
};
|
|
2825
|
+
let len = arg.length;
|
|
2826
|
+
let ptr = malloc(len, 1) >>> 0;
|
|
2827
|
+
|
|
2828
|
+
const mem = getUint8ArrayMemory0();
|
|
2802
2829
|
|
|
2830
|
+
let offset = 0;
|
|
2831
|
+
|
|
2832
|
+
for (; offset < len; offset++) {
|
|
2833
|
+
const code = arg.charCodeAt(offset);
|
|
2834
|
+
if (code > 0x7F) break;
|
|
2835
|
+
mem[ptr + offset] = code;
|
|
2836
|
+
}
|
|
2837
|
+
if (offset !== len) {
|
|
2838
|
+
if (offset !== 0) {
|
|
2839
|
+
arg = arg.slice(offset);
|
|
2840
|
+
}
|
|
2841
|
+
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
|
|
2842
|
+
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
|
|
2843
|
+
const ret = cachedTextEncoder.encodeInto(arg, view);
|
|
2844
|
+
|
|
2845
|
+
offset += ret.written;
|
|
2846
|
+
ptr = realloc(ptr, len, offset, 1) >>> 0;
|
|
2847
|
+
}
|
|
2848
|
+
|
|
2849
|
+
WASM_VECTOR_LEN = offset;
|
|
2850
|
+
return ptr;
|
|
2851
|
+
}
|
|
2852
|
+
|
|
2853
|
+
function takeFromExternrefTable0(idx) {
|
|
2854
|
+
const value = wasm.__wbindgen_externrefs.get(idx);
|
|
2855
|
+
wasm.__externref_table_dealloc(idx);
|
|
2856
|
+
return value;
|
|
2857
|
+
}
|
|
2858
|
+
|
|
2859
|
+
let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
|
2860
|
+
cachedTextDecoder.decode();
|
|
2861
|
+
const MAX_SAFARI_DECODE_BYTES = 2146435072;
|
|
2862
|
+
let numBytesDecoded = 0;
|
|
2863
|
+
function decodeText(ptr, len) {
|
|
2864
|
+
numBytesDecoded += len;
|
|
2865
|
+
if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
|
|
2866
|
+
cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
|
2867
|
+
cachedTextDecoder.decode();
|
|
2868
|
+
numBytesDecoded = len;
|
|
2869
|
+
}
|
|
2870
|
+
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
|
|
2871
|
+
}
|
|
2872
|
+
|
|
2873
|
+
const cachedTextEncoder = new TextEncoder();
|
|
2874
|
+
|
|
2875
|
+
if (!('encodeInto' in cachedTextEncoder)) {
|
|
2876
|
+
cachedTextEncoder.encodeInto = function (arg, view) {
|
|
2877
|
+
const buf = cachedTextEncoder.encode(arg);
|
|
2878
|
+
view.set(buf);
|
|
2879
|
+
return {
|
|
2880
|
+
read: arg.length,
|
|
2881
|
+
written: buf.length
|
|
2882
|
+
};
|
|
2883
|
+
};
|
|
2884
|
+
}
|
|
2885
|
+
|
|
2886
|
+
let WASM_VECTOR_LEN = 0;
|
|
2887
|
+
|
|
2888
|
+
|
|
2889
|
+
let wasm;
|
|
2890
|
+
export function __wbg_set_wasm(val) {
|
|
2891
|
+
wasm = val;
|
|
2892
|
+
}
|