-
-
Notifications
You must be signed in to change notification settings - Fork 3
/
index.d.ts
8486 lines (7006 loc) · 267 KB
/
index.d.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/** @noSelfInFile */
/// <reference types="lua-types/5.1" />
/// <reference types="@typescript-to-lua/language-extensions" />
// DEFOLD. stable version 1.9.3 (e4aaff11f49c941fde1dd93883cf69c6b8abebe4)
// =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= //
declare type hash = {
}
declare type url = {
socket: hash,
path: hash,
fragment: hash,
}
declare type node = {
}
declare type buffer = {
}
declare type bufferstream = Array<number> & LuaUserdata & {
}
declare namespace vmath {
export type vector3 = number & {
x: number,
y: number,
z: number,
}
export type vector4 = number & {
x: number,
y: number,
z: number,
w: number,
}
export type matrix4 = number & {
c0: vmath.vector4,
c1: vmath.vector4,
c2: vmath.vector4,
c3: vmath.vector4,
m01: number,
m02: number,
m03: number,
m04: number,
m11: number,
m12: number,
m13: number,
m14: number,
m21: number,
m22: number,
m23: number,
m24: number,
m31: number,
m32: number,
m33: number,
m34: number,
}
export type quaternion = number & {
x: number,
y: number,
z: number,
w: number,
}
}
// =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= //
/**
* All ids in the engine are represented as hashes, so a string needs to be hashed
* before it can be compared with an id.
* @param s string to hash
* @return hash a hashed string
*/
declare function hash(s: string): hash
/**
* Returns a hexadecimal representation of a hash value.
* The returned string is always padded with leading zeros.
* @param h hash value to get hex string for
* @return hex hex representation of the hash
*/
declare function hash_to_hex(h: hash): string
/**
* Pretty printing of Lua values. This function prints Lua values
* in a manner similar to +print()+, but will also recurse into tables
* and pretty print them. There is a limit to how deep the function
* will recurse.
* @param v value to print
*/
declare function pprint(v: any): void
// =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= //
declare namespace socket {
/**
* max numbers of sockets the select function can handle
*/
export let _SETSIZE: any
/**
* the current LuaSocket version
*/
export let _VERSION: any
/**
* This function is a shortcut that creates and returns a TCP client object connected to a remote
* address at a given port. Optionally, the user can also specify the local address and port to
* bind (`locaddr` and `locport`), or restrict the socket family to `"inet"` or `"inet6"`.
* Without specifying family to connect, whether a tcp or tcp6 connection is created depends on
* your system configuration.
* @param address the address to connect to.
* @param port the port to connect to.
* @param locaddr optional local address to bind to.
* @param locport optional local port to bind to.
* @param family optional socket family to use, `"inet"` or `"inet6"`.
* @return tcp_client a new IPv6 TCP client object, or `nil` in case of error.
* @return error the error message, or `nil` if no error occurred.
*/
export function connect(address: string, port: number, locaddr?: string, locport?: number, family?: string): LuaMultiReturn<[any, any, string, any]>
/**
* Returns the time in seconds, relative to the system epoch (Unix epoch time since January 1, 1970 (UTC) or Windows file time since January 1, 1601 (UTC)).
* You should use the values returned by this function for relative measurements only.
* @return seconds the number of seconds elapsed.
*/
export function gettime(): number
/**
* This function creates and returns a clean try function that allows for cleanup before the exception is raised.
* The `finalizer` function will be called in protected mode (see protect).
* @param finalizer a function that will be called before the try throws the exception.
* @return try the customized try function.
*/
export function newtry(finalizer: any): any
/**
* Converts a function that throws exceptions into a safe function. This function only catches exceptions thrown by try functions. It does not catch normal Lua errors.
* ⚠ Beware that if your function performs some illegal operation that raises an error, the protected function will catch the error and return it as a string. This is because try functions uses errors as the mechanism to throw exceptions.
* @param func a function that calls a try function (or assert, or error) to throw exceptions.
* @return safe_func an equivalent function that instead of throwing exceptions, returns `nil` followed by an error message.
*/
export function protect(func: any): any
/**
* The function returns a list with the sockets ready for reading, a list with the sockets ready for writing and an error message. The error message is "timeout" if a timeout condition was met and nil otherwise. The returned tables are doubly keyed both by integers and also by the sockets themselves, to simplify the test if a specific socket has changed status.
* `Recvt` and `sendt` parameters can be empty tables or `nil`. Non-socket values (or values with non-numeric indices) in these arrays will be silently ignored.
* The returned tables are doubly keyed both by integers and also by the sockets themselves, to simplify the test if a specific socket has changed status.
* ⚠ This function can monitor a limited number of sockets, as defined by the constant socket._SETSIZE. This number may be as high as 1024 or as low as 64 by default, depending on the system. It is usually possible to change this at compile time. Invoking select with a larger number of sockets will raise an error.
* ⚠ A known bug in WinSock causes select to fail on non-blocking TCP sockets. The function may return a socket as writable even though the socket is not ready for sending.
* ⚠ Calling select with a server socket in the receive parameter before a call to accept does not guarantee accept will return immediately. Use the settimeout method or accept might block forever.
* ⚠ If you close a socket and pass it to select, it will be ignored.
* (Using select with non-socket objects: Any object that implements `getfd` and `dirty` can be used with select, allowing objects from other libraries to be used within a socket.select driven loop.)
* @param recvt array with the sockets to test for characters available for reading.
* @param sendt array with sockets that are watched to see if it is OK to immediately write on them.
* @param timeout the maximum amount of time (in seconds) to wait for a change in status. Nil, negative or omitted timeout value allows the function to block indefinitely.
* @return sockets_r a list with the sockets ready for reading.
* @return sockets_w a list with the sockets ready for writing.
* @return error an error message. "timeout" if a timeout condition was met, otherwise `nil`.
*/
export function select(recvt: any, sendt: any, timeout?: number): LuaMultiReturn<[any, any, string, any]>
/**
* This function drops a number of arguments and returns the remaining.
* It is useful to avoid creation of dummy variables:
* `D` is the number of arguments to drop. `Ret1` to `retN` are the arguments.
* The function returns `retD+1` to `retN`.
* @param d the number of arguments to drop.
* @param ret1 argument 1.
* @param ret2 argument 2.
* @param retN argument N.
* @return retD_1 argument D+1.
* @return retD_2 argument D+2.
* @return retN argument N.
*/
export function skip(d: number, ret1?: any, ret2?: any, retN?: any): any
export function skip(d: number, ret1?: any, ret2?: any, retN?: any): any
/**
* Freezes the program execution during a given amount of time.
* @param time the number of seconds to sleep for.
*/
export function sleep(time: number): void
/**
* Creates and returns an IPv4 TCP master object. A master object can be transformed into a server object with the method `listen` (after a call to `bind`) or into a client object with the method `connect`. The only other method supported by a master object is the `close` method.
* @return tcp_master a new IPv4 TCP master object, or `nil` in case of error.
* @return error the error message, or `nil` if no error occurred.
*/
export function tcp(): LuaMultiReturn<[any, any, string, any]>
/**
* Creates and returns an IPv6 TCP master object. A master object can be transformed into a server object with the method `listen` (after a call to `bind`) or into a client object with the method connect. The only other method supported by a master object is the close method.
* Note: The TCP object returned will have the option "ipv6-v6only" set to true.
* @return tcp_master a new IPv6 TCP master object, or `nil` in case of error.
* @return error the error message, or `nil` if no error occurred.
*/
export function tcp6(): LuaMultiReturn<[any, any, string, any]>
/**
* Creates and returns an unconnected IPv4 UDP object. Unconnected objects support the `sendto`, `receive`, `receivefrom`, `getoption`, `getsockname`, `setoption`, `settimeout`, `setpeername`, `setsockname`, and `close` methods. The `setpeername` method is used to connect the object.
* @return udp_unconnected a new unconnected IPv4 UDP object, or `nil` in case of error.
* @return error the error message, or `nil` if no error occurred.
*/
export function udp(): LuaMultiReturn<[any, any, string, any]>
/**
* Creates and returns an unconnected IPv6 UDP object. Unconnected objects support the `sendto`, `receive`, `receivefrom`, `getoption`, `getsockname`, `setoption`, `settimeout`, `setpeername`, `setsockname`, and `close` methods. The `setpeername` method is used to connect the object.
* Note: The UDP object returned will have the option "ipv6-v6only" set to true.
* @return udp_unconnected a new unconnected IPv6 UDP object, or `nil` in case of error.
* @return error the error message, or `nil` if no error occurred.
*/
export function udp6(): LuaMultiReturn<[any, any, string, any]>
}
// =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= //
declare namespace b2d {
/**
* Get the Box2D body from a collision object
* @param url the url to the game object collision component
* @return body the body if successful. Otherwise `nil`.
*/
export function get_body(url: string | hash | url): any
/**
* Get the Box2D world from the current collection
* @return world the world if successful. Otherwise `nil`.
*/
export function get_world(): any
}
// =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= //
declare namespace b2d.body {
/**
* Dynamic body
*/
export let B2_DYNAMIC_BODY: any
/**
* Kinematic body
*/
export let B2_KINEMATIC_BODY: any
/**
* Static (immovable) body
*/
export let B2_STATIC_BODY: any
/**
* Apply an angular impulse.
* @param body body
* @param impulse impulse the angular impulse in units of kg*m*m/s
*/
export function apply_angular_impulse(body: any, impulse: number): void
/**
* Apply a force at a world point. If the force is not
* applied at the center of mass, it will generate a torque and
* affect the angular velocity. This wakes up the body.
* @param body body
* @param force the world force vector, usually in Newtons (N).
* @param point the world position of the point of application.
*/
export function apply_force(body: any, force: vmath.vector3, point: vmath.vector3): void
/**
* Apply a force to the center of mass. This wakes up the body.
* @param body body
* @param force the world force vector, usually in Newtons (N).
*/
export function apply_force_to_center(body: any, force: vmath.vector3): void
/**
* Apply an impulse at a point. This immediately modifies the velocity.
* It also modifies the angular velocity if the point of application
* is not at the center of mass. This wakes up the body.
* @param body body
* @param impulse the world impulse vector, usually in N-seconds or kg-m/s.
* @param point the world position of the point of application.
*/
export function apply_linear_impulse(body: any, impulse: vmath.vector3, point: vmath.vector3): void
/**
* Apply a torque. This affects the angular velocity
* without affecting the linear velocity of the center of mass.
* This wakes up the body.
* @param body body
* @param torque torque about the z-axis (out of the screen), usually in N-m.
*/
export function apply_torque(body: any, torque: number): void
/**
* Print the body representation to the log output
* @param body body
*/
export function dump(body: any): void
/**
* Get the angular damping of the body.
* @param body body
* @return damping the damping
*/
export function get_angular_damping(body: any): number
/**
* Get the angular velocity.
* @param body body
* @return velocity the angular velocity in radians/second.
*/
export function get_angular_velocity(body: any): number
/**
* Get the gravity scale of the body.
* @param body body
* @return scale the scale
*/
export function get_gravity_scale(body: any): number
/**
* Get the rotational inertia of the body about the local origin.
* @param body body
* @return inertia the rotational inertia, usually in kg-m^2.
*/
export function get_inertia(body: any): number
/**
* Get the linear damping of the body.
* @param body body
* @return damping the damping
*/
export function get_linear_damping(body: any): number
/**
* Get the linear velocity of the center of mass.
* @param body body
* @return velocity the linear velocity of the center of mass.
*/
export function get_linear_velocity(body: any): vmath.vector3
/**
* Get the world velocity of a local point.
* @param body body
* @param local_point a point in local coordinates.
* @return velocity the world velocity of a point.
*/
export function get_linear_velocity_from_local_point(body: any, local_point: vmath.vector3): vmath.vector3
/**
* Get the world linear velocity of a world point attached to this body.
* @param body body
* @param world_point a point in world coordinates.
* @return velocity the world velocity of a point.
*/
export function get_linear_velocity_from_world_point(body: any, world_point: vmath.vector3): vmath.vector3
/**
* Get the local position of the center of mass.
* @param body body
* @return center Get the local position of the center of mass.
*/
export function get_local_center(body: any): vmath.vector3
/**
* Gets a local point relative to the body's origin given a world point.
* @param body body
* @param world_point a point in world coordinates.
* @return vector the corresponding local point relative to the body's origin.
*/
export function get_local_point(body: any, world_point: vmath.vector3): vmath.vector3
/**
* Gets a local vector given a world vector.
* @param body body
* @param world_vector a vector in world coordinates.
* @return vector the corresponding local vector.
*/
export function get_local_vector(body: any, world_vector: vmath.vector3): vmath.vector3
/**
* Get the total mass of the body.
* @param body body
* @return mass the mass, usually in kilograms (kg).
*/
export function get_mass(body: any): number
/**
* Get the next body in the world's body list.
* @param body body
* @return body the next body
*/
export function get_next(body: any): any
/**
* Get the world body origin position.
* @param body body
* @return position the world position of the body's origin.
*/
export function get_position(body: any): vmath.vector3
/**
* Get the type of this body.
* @param body body
* @return type the body type
*/
export function get_type(body: any): any
/**
* Get the parent world of this body.
* @param body body
* @return world
*/
export function get_world(body: any): any
/**
* Get the angle in radians.
* @param body body
* @return angle the current world rotation angle in radians.
*/
export function get_world_center(body: any): number
/**
* Get the world position of the center of mass.
* @param body body
* @return center Get the world position of the center of mass.
*/
export function get_world_center(body: any): vmath.vector3
/**
* Get the world coordinates of a point given the local coordinates.
* @param body body
* @param local_vector localPoint a point on the body measured relative the the body's origin.
* @return vector the same point expressed in world coordinates.
*/
export function get_world_point(body: any, local_vector: vmath.vector3): vmath.vector3
/**
* Get the world coordinates of a vector given the local coordinates.
* @param body body
* @param local_vector a vector fixed in the body.
* @return vector the same vector expressed in world coordinates.
*/
export function get_world_vector(body: any, local_vector: vmath.vector3): vmath.vector3
/**
* Get the active state of the body.
* @param body body
* @return enabled is the body active
*/
export function is_active(body: any): any
/**
* Get the sleeping state of this body.
* @param body body
* @return enabled true if the body is awake, false if it's sleeping.
*/
export function is_awake(body: any): any
/**
* Is this body in bullet mode
* @param body body
* @return enabled true if the body is in bullet mode
*/
export function is_bullet(body: any): any
/**
* Does this body have fixed rotation?
* @param body body
* @return enabled is the rotation fixed
*/
export function is_fixed_rotation(body: any): any
/**
* Is this body allowed to sleep
* @param body body
* @return enabled true if the body is allowed to sleep
*/
export function is_sleeping_allowed(body: any): any
/**
* This resets the mass properties to the sum of the mass properties of the fixtures.
* This normally does not need to be called unless you called SetMassData to override
* @param body body
*/
export function reset_mass_data(body: any): void
/**
* Set the active state of the body. An inactive body is not
* simulated and cannot be collided with or woken up.
* If you pass a flag of true, all fixtures will be added to the
* broad-phase.
* If you pass a flag of false, all fixtures will be removed from
* the broad-phase and all contacts will be destroyed.
* Fixtures and joints are otherwise unaffected. You may continue
* to create/destroy fixtures and joints on inactive bodies.
* Fixtures on an inactive body are implicitly inactive and will
* not participate in collisions, ray-casts, or queries.
* Joints connected to an inactive body are implicitly inactive.
* An inactive body is still owned by a b2World object and remains
* in the body list.
* @param body body
* @param enable true if the body should be active
*/
export function set_active(body: any, enable: any): void
/**
* Set the angular damping of the body.
* @param body body
* @param damping the damping
*/
export function set_angular_damping(body: any, damping: number): void
/**
* Set the angular velocity.
* @param body body
* @param omega the new angular velocity in radians/second.
*/
export function set_angular_velocity(body: any, omega: number): void
/**
* Set the sleep state of the body. A sleeping body has very low CPU cost.
* @param body body
* @param enable flag set to false to put body to sleep, true to wake it.
*/
export function set_awake(body: any, enable: any): void
/**
* Should this body be treated like a bullet for continuous collision detection?
* @param body body
* @param enable if true, the body will be in bullet mode
*/
export function set_bullet(body: any, enable: any): void
/**
* Set this body to have fixed rotation. This causes the mass to be reset.
* @param body body
* @param enable true if the rotation should be fixed
*/
export function set_fixed_rotation(body: any, enable: any): void
/**
* Set the gravity scale of the body.
* @param body body
* @param scale the scale
*/
export function set_gravity_scale(body: any, scale: number): void
/**
* Set the linear damping of the body.
* @param body body
* @param damping the damping
*/
export function set_linear_damping(body: any, damping: number): void
/**
* Set the linear velocity of the center of mass.
* @param body body
* @param velocity the new linear velocity of the center of mass.
*/
export function set_linear_velocity(body: any, velocity: vmath.vector3): void
/**
* You can disable sleeping on this body. If you disable sleeping, the body will be woken.
* @param body body
* @param enable if false, the body will never sleep, and consume more CPU
*/
export function set_sleeping_allowed(body: any, enable: any): void
/**
* Set the position of the body's origin and rotation.
* This breaks any contacts and wakes the other bodies.
* Manipulating a body's transform may cause non-physical behavior.
* @param body body
* @param position the world position of the body's local origin.
* @param angle the world position of the body's local origin.
*/
export function set_transform(body: any, position: vmath.vector3, angle: number): void
/**
* Set the type of this body. This may alter the mass and velocity.
* @param body body
* @param type the body type
*/
export function set_type(body: any, type: any): void
}
// =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= //
declare namespace crash {
/**
* android build fingerprint
*/
export let SYSFIELD_ANDROID_BUILD_FINGERPRINT: any
/**
* system device language as reported by sys.get_sys_info
*/
export let SYSFIELD_DEVICE_LANGUAGE: any
/**
* device model as reported by sys.get_sys_info
*/
export let SYSFIELD_DEVICE_MODEL: any
/**
* engine version as hash
*/
export let SYSFIELD_ENGINE_HASH: any
/**
* engine version as release number
*/
export let SYSFIELD_ENGINE_VERSION: any
/**
* system language as reported by sys.get_sys_info
*/
export let SYSFIELD_LANGUAGE: any
/**
* device manufacturer as reported by sys.get_sys_info
*/
export let SYSFIELD_MANUFACTURER: any
/**
* The max number of sysfields.
*/
export let SYSFIELD_MAX: any
/**
* system name as reported by sys.get_sys_info
*/
export let SYSFIELD_SYSTEM_NAME: any
/**
* system version as reported by sys.get_sys_info
*/
export let SYSFIELD_SYSTEM_VERSION: any
/**
* system territory as reported by sys.get_sys_info
*/
export let SYSFIELD_TERRITORY: any
/**
* The max number of user fields.
*/
export let USERFIELD_MAX: any
/**
* The max size of a single user field.
*/
export let USERFIELD_SIZE: any
/**
* A table is returned containing the addresses of the call stack.
* @param handle crash dump handle
* @return backtrace table containing the backtrace
*/
export function get_backtrace(handle: number): any
/**
* The format of read text blob is platform specific
* and not guaranteed
* but can be useful for manual inspection.
* @param handle crash dump handle
* @return blob string with the platform specific data
*/
export function get_extra_data(handle: number): string
/**
* The function returns a table containing entries with sub-tables that
* have fields 'name' and 'address' set for all loaded modules.
* @param handle crash dump handle
* @return modules module table
*/
export function get_modules(handle: number): any
/**
* read signal number from a crash report
* @param handle crash dump handle
* @return signal signal number
*/
export function get_signum(handle: number): number
/**
* reads a system field from a loaded crash dump
* @param handle crash dump handle
* @param index system field enum. Must be less than crash.SYSFIELD_MAX
* @return value value recorded in the crash dump, or `nil` if it didn't exist
*/
export function get_sys_field(handle: number, index: number): LuaMultiReturn<[string, any]>
/**
* reads user field from a loaded crash dump
* @param handle crash dump handle
* @param index user data slot index
* @return value user data value recorded in the crash dump
*/
export function get_user_field(handle: number, index: number): string
/**
* The crash dump will be removed from disk upon a successful
* load, so loading is one-shot.
* @return handle handle to the loaded dump, or `nil` if no dump was found
*/
export function load_previous(): LuaMultiReturn<[number, any]>
/**
* releases a previously loaded crash dump
* @param handle handle to loaded crash dump
*/
export function release(handle: number): void
/**
* Crashes occuring before the path is set will be stored to a default engine location.
* @param path file path to use
*/
export function set_file_path(path: string): void
/**
* Store a user value that will get written to a crash dump when
* a crash occurs. This can be user id:s, breadcrumb data etc.
* There are 32 slots indexed from 0. Each slot stores at most 255 characters.
* @param index slot index. 0-indexed
* @param value string value to store
*/
export function set_user_field(index: number, value: string): void
/**
* Performs the same steps as if a crash had just occured but
* allows the program to continue.
* The generated dump can be read by crash.load_previous
*/
export function write_dump(): void
}
// =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= =^..^= //
declare namespace go {
/**
* Post this message to a game object instance to make that instance acquire the user input focus.
* User input is distributed by the engine to every instance that has
* requested it. The last instance to request focus will receive it first.
* This means that the scripts in the instance will have first-hand-chance
* at reacting on user input, possibly consuming it (by returning
* `true` from `on_input`) so that no other instances
* can react on it. The most common case is for a script to send this message
* to itself when it needs to respond to user input.
* A script belonging to an instance which has the user input focus will
* receive the input actions in its `on_input` callback function.
* See on_input for more information on how user input can be
* handled.
*/
export type acquire_input_focus = "acquire_input_focus"
/**
* This message disables the receiving component. All components are enabled by default, which means they will receive input, updates
* and be a part of the simulation. A component is disabled when it receives the `disable` message.
* undefined Components that currently supports this message are:
*
* - Camera
* - Collection Proxy
* - Collision Object
* - Gui
* - Label
* - Spine Model
* - Sprite
* - Tile Grid
* - Model
* - Mesh
*
*/
export type disable = "disable"
/**
* This message enables the receiving component. All components are enabled by default, which means they will receive input, updates
* and be a part of the simulation. A component is disabled when it receives the `disable` message.
* undefined Components that currently supports this message are:
*
* - Camera
* - Collection Proxy
* - Collision Object
* - Gui
* - Label
* - Spine Model
* - Sprite
* - Tile Grid
* - Model
* - Mesh
*
*/
export type enable = "enable"
/**
* The rotation of the game object expressed in Euler angles.
* Euler angles are specified in degrees in the interval (-360, 360).
* The type of the property is vector3.
*/
export let euler: any
/**
* This is a callback-function, which is called by the engine at fixed intervals to update the state of a script
* component. The function will be called if 'Fixed Update Frequency' is enabled in the Engine section of game.project.
* It can for instance be used to update game logic with the physics simulation if using a fixed timestep for the
* physics (enabled by ticking 'Use Fixed Timestep' in the Physics section of game.project).
* @param self reference to the script state to be used for storing data
* @param dt the time-step of the frame update
*/
export function fixed_update(self: object, dt: number): void
/**
* in-back
*/
export let EASING_INBACK: any
/**
* in-bounce
*/
export let EASING_INBOUNCE: any
/**
* in-circlic
*/
export let EASING_INCIRC: any
/**
* in-cubic
*/
export let EASING_INCUBIC: any
/**
* in-elastic
*/
export let EASING_INELASTIC: any
/**
* in-exponential
*/
export let EASING_INEXPO: any
/**
* in-out-back
*/
export let EASING_INOUTBACK: any
/**
* in-out-bounce
*/
export let EASING_INOUTBOUNCE: any
/**
* in-out-circlic
*/
export let EASING_INOUTCIRC: any
/**
* in-out-cubic
*/
export let EASING_INOUTCUBIC: any
/**
* in-out-elastic
*/
export let EASING_INOUTELASTIC: any
/**
* in-out-exponential
*/
export let EASING_INOUTEXPO: any
/**
* in-out-quadratic
*/
export let EASING_INOUTQUAD: any
/**
* in-out-quartic
*/
export let EASING_INOUTQUART: any
/**
* in-out-quintic
*/
export let EASING_INOUTQUINT: any
/**
* in-out-sine
*/
export let EASING_INOUTSINE: any
/**
* in-quadratic
*/
export let EASING_INQUAD: any
/**
* in-quartic
*/
export let EASING_INQUART: any
/**
* in-quintic
*/
export let EASING_INQUINT: any
/**
* in-sine
*/
export let EASING_INSINE: any
/**
* linear interpolation
*/
export let EASING_LINEAR: any
/**
* out-back
*/
export let EASING_OUTBACK: any
/**
* out-bounce
*/
export let EASING_OUTBOUNCE: any
/**
* out-circlic
*/
export let EASING_OUTCIRC: any
/**
* out-cubic
*/
export let EASING_OUTCUBIC: any
/**
* out-elastic
*/
export let EASING_OUTELASTIC: any
/**
* out-exponential
*/
export let EASING_OUTEXPO: any
/**
* out-in-back
*/
export let EASING_OUTINBACK: any
/**
* out-in-bounce
*/
export let EASING_OUTINBOUNCE: any
/**
* out-in-circlic
*/
export let EASING_OUTINCIRC: any
/**
* out-in-cubic
*/
export let EASING_OUTINCUBIC: any
/**
* out-in-elastic
*/
export let EASING_OUTINELASTIC: any
/**
* out-in-exponential
*/
export let EASING_OUTINEXPO: any
/**
* out-in-quadratic
*/
export let EASING_OUTINQUAD: any