hytopia 0.8.6-dev5 → 0.8.6-dev6
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/bun-server.mjs +160 -160
- package/docs/server.array3number.md +13 -0
- package/docs/server.array4number.md +13 -0
- package/docs/server.audiomanager.getallaudios.md +38 -1
- package/docs/server.audiomanager.md +1 -1
- package/docs/server.blocktype._constructor_.md +15 -1
- package/docs/server.blocktype.blocktyperegistry.md +13 -0
- package/docs/server.blocktype.md +22 -1
- package/docs/server.blocktyperegistry.getallblocktypes.md +38 -1
- package/docs/server.blocktyperegistry.md +1 -1
- package/docs/server.chunk._constructor_.md +15 -1
- package/docs/server.chunk.chunklattice.md +13 -0
- package/docs/server.chunk.md +22 -1
- package/docs/server.chunklattice.getallchunks.md +38 -1
- package/docs/server.chunklattice.md +22 -1
- package/docs/server.chunklattice.world.md +13 -0
- package/docs/server.entitymanager.getallentities.md +38 -1
- package/docs/server.entitymanager.md +1 -1
- package/docs/server.lightmanager.getalllights.md +38 -1
- package/docs/server.lightmanager.md +1 -1
- package/docs/server.md +33 -0
- package/docs/server.particleemittermanager.getallparticleemitters.md +38 -1
- package/docs/server.particleemittermanager.md +1 -1
- package/docs/server.sceneuimanager.getallsceneuis.md +38 -1
- package/docs/server.sceneuimanager.md +1 -1
- package/docs/server.tickallocator.getarray.md +72 -0
- package/docs/server.tickallocator.getarray3number.md +56 -0
- package/docs/server.tickallocator.getarray4number.md +56 -0
- package/docs/server.tickallocator.getobject.md +72 -0
- package/docs/server.tickallocator.getset.md +72 -0
- package/docs/server.tickallocator.map.md +72 -0
- package/docs/server.tickallocator.md +149 -0
- package/docs/server.tickallocator.reset.md +17 -0
- package/docs/server.world.md +21 -0
- package/docs/server.world.tickallocator.md +13 -0
- package/node-server.mjs +163 -163
- package/package.json +1 -1
- package/server.api.json +930 -39
- package/server.d.ts +164 -27
package/server.api.json
CHANGED
|
@@ -173,6 +173,58 @@
|
|
|
173
173
|
"name": "",
|
|
174
174
|
"preserveMemberOrder": false,
|
|
175
175
|
"members": [
|
|
176
|
+
{
|
|
177
|
+
"kind": "TypeAlias",
|
|
178
|
+
"canonicalReference": "server!Array3Number:type",
|
|
179
|
+
"docComment": "/**\n * A 3-element number array.\n *\n * @public\n */\n",
|
|
180
|
+
"excerptTokens": [
|
|
181
|
+
{
|
|
182
|
+
"kind": "Content",
|
|
183
|
+
"text": "export type Array3Number = "
|
|
184
|
+
},
|
|
185
|
+
{
|
|
186
|
+
"kind": "Content",
|
|
187
|
+
"text": "[number, number, number]"
|
|
188
|
+
},
|
|
189
|
+
{
|
|
190
|
+
"kind": "Content",
|
|
191
|
+
"text": ";"
|
|
192
|
+
}
|
|
193
|
+
],
|
|
194
|
+
"fileUrlPath": "src/shared/classes/TickAllocator.ts",
|
|
195
|
+
"releaseTag": "Public",
|
|
196
|
+
"name": "Array3Number",
|
|
197
|
+
"typeTokenRange": {
|
|
198
|
+
"startIndex": 1,
|
|
199
|
+
"endIndex": 2
|
|
200
|
+
}
|
|
201
|
+
},
|
|
202
|
+
{
|
|
203
|
+
"kind": "TypeAlias",
|
|
204
|
+
"canonicalReference": "server!Array4Number:type",
|
|
205
|
+
"docComment": "/**\n * A 4-element number array.\n *\n * @public\n */\n",
|
|
206
|
+
"excerptTokens": [
|
|
207
|
+
{
|
|
208
|
+
"kind": "Content",
|
|
209
|
+
"text": "export type Array4Number = "
|
|
210
|
+
},
|
|
211
|
+
{
|
|
212
|
+
"kind": "Content",
|
|
213
|
+
"text": "[number, number, number, number]"
|
|
214
|
+
},
|
|
215
|
+
{
|
|
216
|
+
"kind": "Content",
|
|
217
|
+
"text": ";"
|
|
218
|
+
}
|
|
219
|
+
],
|
|
220
|
+
"fileUrlPath": "src/shared/classes/TickAllocator.ts",
|
|
221
|
+
"releaseTag": "Public",
|
|
222
|
+
"name": "Array4Number",
|
|
223
|
+
"typeTokenRange": {
|
|
224
|
+
"startIndex": 1,
|
|
225
|
+
"endIndex": 2
|
|
226
|
+
}
|
|
227
|
+
},
|
|
176
228
|
{
|
|
177
229
|
"kind": "Class",
|
|
178
230
|
"canonicalReference": "server!Audio:class",
|
|
@@ -2087,11 +2139,19 @@
|
|
|
2087
2139
|
{
|
|
2088
2140
|
"kind": "Method",
|
|
2089
2141
|
"canonicalReference": "server!AudioManager#getAllAudios:member(1)",
|
|
2090
|
-
"docComment": "/**\n * Retrieves all loaded audio instances for the world.\n *\n * @returns An array of audio instances.\n */\n",
|
|
2142
|
+
"docComment": "/**\n * Retrieves all loaded audio instances for the world.\n *\n * @param tickAllocated - Whether to use the tick allocator to allocate the returned array of Audio instances. The allocated array will be collected and released at the end of the current tick if true. Only use this if you know what you're doing.\n *\n * @returns An array of audio instances.\n */\n",
|
|
2091
2143
|
"excerptTokens": [
|
|
2092
2144
|
{
|
|
2093
2145
|
"kind": "Content",
|
|
2094
|
-
"text": "getAllAudios(
|
|
2146
|
+
"text": "getAllAudios(tickAllocated?: "
|
|
2147
|
+
},
|
|
2148
|
+
{
|
|
2149
|
+
"kind": "Content",
|
|
2150
|
+
"text": "boolean"
|
|
2151
|
+
},
|
|
2152
|
+
{
|
|
2153
|
+
"kind": "Content",
|
|
2154
|
+
"text": "): "
|
|
2095
2155
|
},
|
|
2096
2156
|
{
|
|
2097
2157
|
"kind": "Reference",
|
|
@@ -2109,13 +2169,22 @@
|
|
|
2109
2169
|
],
|
|
2110
2170
|
"isStatic": false,
|
|
2111
2171
|
"returnTypeTokenRange": {
|
|
2112
|
-
"startIndex":
|
|
2113
|
-
"endIndex":
|
|
2172
|
+
"startIndex": 3,
|
|
2173
|
+
"endIndex": 5
|
|
2114
2174
|
},
|
|
2115
2175
|
"releaseTag": "Public",
|
|
2116
2176
|
"isProtected": false,
|
|
2117
2177
|
"overloadIndex": 1,
|
|
2118
|
-
"parameters": [
|
|
2178
|
+
"parameters": [
|
|
2179
|
+
{
|
|
2180
|
+
"parameterName": "tickAllocated",
|
|
2181
|
+
"parameterTypeTokenRange": {
|
|
2182
|
+
"startIndex": 1,
|
|
2183
|
+
"endIndex": 2
|
|
2184
|
+
},
|
|
2185
|
+
"isOptional": true
|
|
2186
|
+
}
|
|
2187
|
+
],
|
|
2119
2188
|
"isOptional": false,
|
|
2120
2189
|
"isAbstract": false,
|
|
2121
2190
|
"name": "getAllAudios"
|
|
@@ -4910,7 +4979,16 @@
|
|
|
4910
4979
|
"excerptTokens": [
|
|
4911
4980
|
{
|
|
4912
4981
|
"kind": "Content",
|
|
4913
|
-
"text": "constructor(
|
|
4982
|
+
"text": "constructor(blockTypeRegistry: "
|
|
4983
|
+
},
|
|
4984
|
+
{
|
|
4985
|
+
"kind": "Reference",
|
|
4986
|
+
"text": "BlockTypeRegistry",
|
|
4987
|
+
"canonicalReference": "server!BlockTypeRegistry:class"
|
|
4988
|
+
},
|
|
4989
|
+
{
|
|
4990
|
+
"kind": "Content",
|
|
4991
|
+
"text": ", options?: "
|
|
4914
4992
|
},
|
|
4915
4993
|
{
|
|
4916
4994
|
"kind": "Reference",
|
|
@@ -4927,15 +5005,54 @@
|
|
|
4927
5005
|
"overloadIndex": 1,
|
|
4928
5006
|
"parameters": [
|
|
4929
5007
|
{
|
|
4930
|
-
"parameterName": "
|
|
5008
|
+
"parameterName": "blockTypeRegistry",
|
|
4931
5009
|
"parameterTypeTokenRange": {
|
|
4932
5010
|
"startIndex": 1,
|
|
4933
5011
|
"endIndex": 2
|
|
4934
5012
|
},
|
|
5013
|
+
"isOptional": false
|
|
5014
|
+
},
|
|
5015
|
+
{
|
|
5016
|
+
"parameterName": "options",
|
|
5017
|
+
"parameterTypeTokenRange": {
|
|
5018
|
+
"startIndex": 3,
|
|
5019
|
+
"endIndex": 4
|
|
5020
|
+
},
|
|
4935
5021
|
"isOptional": true
|
|
4936
5022
|
}
|
|
4937
5023
|
]
|
|
4938
5024
|
},
|
|
5025
|
+
{
|
|
5026
|
+
"kind": "Property",
|
|
5027
|
+
"canonicalReference": "server!BlockType#blockTypeRegistry:member",
|
|
5028
|
+
"docComment": "/**\n * The block type registry that the block type belongs to.\n */\n",
|
|
5029
|
+
"excerptTokens": [
|
|
5030
|
+
{
|
|
5031
|
+
"kind": "Content",
|
|
5032
|
+
"text": "get blockTypeRegistry(): "
|
|
5033
|
+
},
|
|
5034
|
+
{
|
|
5035
|
+
"kind": "Reference",
|
|
5036
|
+
"text": "BlockTypeRegistry",
|
|
5037
|
+
"canonicalReference": "server!BlockTypeRegistry:class"
|
|
5038
|
+
},
|
|
5039
|
+
{
|
|
5040
|
+
"kind": "Content",
|
|
5041
|
+
"text": ";"
|
|
5042
|
+
}
|
|
5043
|
+
],
|
|
5044
|
+
"isReadonly": true,
|
|
5045
|
+
"isOptional": false,
|
|
5046
|
+
"releaseTag": "Public",
|
|
5047
|
+
"name": "blockTypeRegistry",
|
|
5048
|
+
"propertyTypeTokenRange": {
|
|
5049
|
+
"startIndex": 1,
|
|
5050
|
+
"endIndex": 2
|
|
5051
|
+
},
|
|
5052
|
+
"isStatic": false,
|
|
5053
|
+
"isProtected": false,
|
|
5054
|
+
"isAbstract": false
|
|
5055
|
+
},
|
|
4939
5056
|
{
|
|
4940
5057
|
"kind": "Property",
|
|
4941
5058
|
"canonicalReference": "server!BlockType#colliderOptions:member",
|
|
@@ -5604,11 +5721,19 @@
|
|
|
5604
5721
|
{
|
|
5605
5722
|
"kind": "Method",
|
|
5606
5723
|
"canonicalReference": "server!BlockTypeRegistry#getAllBlockTypes:member(1)",
|
|
5607
|
-
"docComment": "/**\n * Get all registered block types.\n *\n * @returns An array of all registered block types.\n */\n",
|
|
5724
|
+
"docComment": "/**\n * Get all registered block types.\n *\n * @param tickAllocated - Whether to use the tick allocator to allocate the returned array of BlockType instances. The allocated array will be collected and released at the end of the current tick if true. Only use this if you know what you're doing.\n *\n * @returns An array of all registered block types.\n */\n",
|
|
5608
5725
|
"excerptTokens": [
|
|
5609
5726
|
{
|
|
5610
5727
|
"kind": "Content",
|
|
5611
|
-
"text": "getAllBlockTypes(
|
|
5728
|
+
"text": "getAllBlockTypes(tickAllocated?: "
|
|
5729
|
+
},
|
|
5730
|
+
{
|
|
5731
|
+
"kind": "Content",
|
|
5732
|
+
"text": "boolean"
|
|
5733
|
+
},
|
|
5734
|
+
{
|
|
5735
|
+
"kind": "Content",
|
|
5736
|
+
"text": "): "
|
|
5612
5737
|
},
|
|
5613
5738
|
{
|
|
5614
5739
|
"kind": "Reference",
|
|
@@ -5626,13 +5751,22 @@
|
|
|
5626
5751
|
],
|
|
5627
5752
|
"isStatic": false,
|
|
5628
5753
|
"returnTypeTokenRange": {
|
|
5629
|
-
"startIndex":
|
|
5630
|
-
"endIndex":
|
|
5754
|
+
"startIndex": 3,
|
|
5755
|
+
"endIndex": 5
|
|
5631
5756
|
},
|
|
5632
5757
|
"releaseTag": "Public",
|
|
5633
5758
|
"isProtected": false,
|
|
5634
5759
|
"overloadIndex": 1,
|
|
5635
|
-
"parameters": [
|
|
5760
|
+
"parameters": [
|
|
5761
|
+
{
|
|
5762
|
+
"parameterName": "tickAllocated",
|
|
5763
|
+
"parameterTypeTokenRange": {
|
|
5764
|
+
"startIndex": 1,
|
|
5765
|
+
"endIndex": 2
|
|
5766
|
+
},
|
|
5767
|
+
"isOptional": true
|
|
5768
|
+
}
|
|
5769
|
+
],
|
|
5636
5770
|
"isOptional": false,
|
|
5637
5771
|
"isAbstract": false,
|
|
5638
5772
|
"name": "getAllBlockTypes"
|
|
@@ -6541,7 +6675,16 @@
|
|
|
6541
6675
|
"excerptTokens": [
|
|
6542
6676
|
{
|
|
6543
6677
|
"kind": "Content",
|
|
6544
|
-
"text": "constructor(
|
|
6678
|
+
"text": "constructor(chunkLattice: "
|
|
6679
|
+
},
|
|
6680
|
+
{
|
|
6681
|
+
"kind": "Reference",
|
|
6682
|
+
"text": "ChunkLattice",
|
|
6683
|
+
"canonicalReference": "server!ChunkLattice:class"
|
|
6684
|
+
},
|
|
6685
|
+
{
|
|
6686
|
+
"kind": "Content",
|
|
6687
|
+
"text": ", originCoordinate: "
|
|
6545
6688
|
},
|
|
6546
6689
|
{
|
|
6547
6690
|
"kind": "Reference",
|
|
@@ -6558,12 +6701,20 @@
|
|
|
6558
6701
|
"overloadIndex": 1,
|
|
6559
6702
|
"parameters": [
|
|
6560
6703
|
{
|
|
6561
|
-
"parameterName": "
|
|
6704
|
+
"parameterName": "chunkLattice",
|
|
6562
6705
|
"parameterTypeTokenRange": {
|
|
6563
6706
|
"startIndex": 1,
|
|
6564
6707
|
"endIndex": 2
|
|
6565
6708
|
},
|
|
6566
6709
|
"isOptional": false
|
|
6710
|
+
},
|
|
6711
|
+
{
|
|
6712
|
+
"parameterName": "originCoordinate",
|
|
6713
|
+
"parameterTypeTokenRange": {
|
|
6714
|
+
"startIndex": 3,
|
|
6715
|
+
"endIndex": 4
|
|
6716
|
+
},
|
|
6717
|
+
"isOptional": false
|
|
6567
6718
|
}
|
|
6568
6719
|
]
|
|
6569
6720
|
},
|
|
@@ -6660,6 +6811,37 @@
|
|
|
6660
6811
|
"isProtected": false,
|
|
6661
6812
|
"isAbstract": false
|
|
6662
6813
|
},
|
|
6814
|
+
{
|
|
6815
|
+
"kind": "Property",
|
|
6816
|
+
"canonicalReference": "server!Chunk#chunkLattice:member",
|
|
6817
|
+
"docComment": "/**\n * The chunk lattice that the chunk belongs to.\n */\n",
|
|
6818
|
+
"excerptTokens": [
|
|
6819
|
+
{
|
|
6820
|
+
"kind": "Content",
|
|
6821
|
+
"text": "get chunkLattice(): "
|
|
6822
|
+
},
|
|
6823
|
+
{
|
|
6824
|
+
"kind": "Reference",
|
|
6825
|
+
"text": "ChunkLattice",
|
|
6826
|
+
"canonicalReference": "server!ChunkLattice:class"
|
|
6827
|
+
},
|
|
6828
|
+
{
|
|
6829
|
+
"kind": "Content",
|
|
6830
|
+
"text": ";"
|
|
6831
|
+
}
|
|
6832
|
+
],
|
|
6833
|
+
"isReadonly": true,
|
|
6834
|
+
"isOptional": false,
|
|
6835
|
+
"releaseTag": "Public",
|
|
6836
|
+
"name": "chunkLattice",
|
|
6837
|
+
"propertyTypeTokenRange": {
|
|
6838
|
+
"startIndex": 1,
|
|
6839
|
+
"endIndex": 2
|
|
6840
|
+
},
|
|
6841
|
+
"isStatic": false,
|
|
6842
|
+
"isProtected": false,
|
|
6843
|
+
"isAbstract": false
|
|
6844
|
+
},
|
|
6663
6845
|
{
|
|
6664
6846
|
"kind": "Method",
|
|
6665
6847
|
"canonicalReference": "server!Chunk#getBlockId:member(1)",
|
|
@@ -7019,11 +7201,19 @@
|
|
|
7019
7201
|
{
|
|
7020
7202
|
"kind": "Method",
|
|
7021
7203
|
"canonicalReference": "server!ChunkLattice#getAllChunks:member(1)",
|
|
7022
|
-
"docComment": "/**\n * Get all chunks in the lattice.\n *\n * @returns An array of all chunks in the lattice.\n */\n",
|
|
7204
|
+
"docComment": "/**\n * Get all chunks in the lattice.\n *\n * @param tickAllocated - Whether to use the tick allocator to allocate the returned array of Chunk instances. The allocated array will be collected and released at the end of the current tick if true. Only use this if you know what you're doing.\n *\n * @returns An array of all chunks in the lattice.\n */\n",
|
|
7023
7205
|
"excerptTokens": [
|
|
7024
7206
|
{
|
|
7025
7207
|
"kind": "Content",
|
|
7026
|
-
"text": "getAllChunks(
|
|
7208
|
+
"text": "getAllChunks(tickAllocated?: "
|
|
7209
|
+
},
|
|
7210
|
+
{
|
|
7211
|
+
"kind": "Content",
|
|
7212
|
+
"text": "boolean"
|
|
7213
|
+
},
|
|
7214
|
+
{
|
|
7215
|
+
"kind": "Content",
|
|
7216
|
+
"text": "): "
|
|
7027
7217
|
},
|
|
7028
7218
|
{
|
|
7029
7219
|
"kind": "Reference",
|
|
@@ -7041,13 +7231,22 @@
|
|
|
7041
7231
|
],
|
|
7042
7232
|
"isStatic": false,
|
|
7043
7233
|
"returnTypeTokenRange": {
|
|
7044
|
-
"startIndex":
|
|
7045
|
-
"endIndex":
|
|
7234
|
+
"startIndex": 3,
|
|
7235
|
+
"endIndex": 5
|
|
7046
7236
|
},
|
|
7047
7237
|
"releaseTag": "Public",
|
|
7048
7238
|
"isProtected": false,
|
|
7049
7239
|
"overloadIndex": 1,
|
|
7050
|
-
"parameters": [
|
|
7240
|
+
"parameters": [
|
|
7241
|
+
{
|
|
7242
|
+
"parameterName": "tickAllocated",
|
|
7243
|
+
"parameterTypeTokenRange": {
|
|
7244
|
+
"startIndex": 1,
|
|
7245
|
+
"endIndex": 2
|
|
7246
|
+
},
|
|
7247
|
+
"isOptional": true
|
|
7248
|
+
}
|
|
7249
|
+
],
|
|
7051
7250
|
"isOptional": false,
|
|
7052
7251
|
"isAbstract": false,
|
|
7053
7252
|
"name": "getAllChunks"
|
|
@@ -7469,6 +7668,37 @@
|
|
|
7469
7668
|
"isOptional": false,
|
|
7470
7669
|
"isAbstract": false,
|
|
7471
7670
|
"name": "setBlock"
|
|
7671
|
+
},
|
|
7672
|
+
{
|
|
7673
|
+
"kind": "Property",
|
|
7674
|
+
"canonicalReference": "server!ChunkLattice#world:member",
|
|
7675
|
+
"docComment": "/**\n * The world that the chunk lattice belongs to.\n */\n",
|
|
7676
|
+
"excerptTokens": [
|
|
7677
|
+
{
|
|
7678
|
+
"kind": "Content",
|
|
7679
|
+
"text": "get world(): "
|
|
7680
|
+
},
|
|
7681
|
+
{
|
|
7682
|
+
"kind": "Reference",
|
|
7683
|
+
"text": "World",
|
|
7684
|
+
"canonicalReference": "server!World:class"
|
|
7685
|
+
},
|
|
7686
|
+
{
|
|
7687
|
+
"kind": "Content",
|
|
7688
|
+
"text": ";"
|
|
7689
|
+
}
|
|
7690
|
+
],
|
|
7691
|
+
"isReadonly": true,
|
|
7692
|
+
"isOptional": false,
|
|
7693
|
+
"releaseTag": "Public",
|
|
7694
|
+
"name": "world",
|
|
7695
|
+
"propertyTypeTokenRange": {
|
|
7696
|
+
"startIndex": 1,
|
|
7697
|
+
"endIndex": 2
|
|
7698
|
+
},
|
|
7699
|
+
"isStatic": false,
|
|
7700
|
+
"isProtected": false,
|
|
7701
|
+
"isAbstract": false
|
|
7472
7702
|
}
|
|
7473
7703
|
],
|
|
7474
7704
|
"extendsTokenRange": {
|
|
@@ -16600,11 +16830,19 @@
|
|
|
16600
16830
|
{
|
|
16601
16831
|
"kind": "Method",
|
|
16602
16832
|
"canonicalReference": "server!EntityManager#getAllEntities:member(1)",
|
|
16603
|
-
"docComment": "/**\n * Gets all spawned entities in the world.\n *\n * @returns All spawned entities in the world.\n */\n",
|
|
16833
|
+
"docComment": "/**\n * Gets all spawned entities in the world.\n *\n * @param tickAllocated - Whether to use the tick allocator to allocate the returned array of Entity instances. The allocated array will be collected and released at the end of the current tick if true. Only use this if you know what you're doing.\n *\n * @returns All spawned entities in the world.\n */\n",
|
|
16604
16834
|
"excerptTokens": [
|
|
16605
16835
|
{
|
|
16606
16836
|
"kind": "Content",
|
|
16607
|
-
"text": "getAllEntities(
|
|
16837
|
+
"text": "getAllEntities(tickAllocated?: "
|
|
16838
|
+
},
|
|
16839
|
+
{
|
|
16840
|
+
"kind": "Content",
|
|
16841
|
+
"text": "boolean"
|
|
16842
|
+
},
|
|
16843
|
+
{
|
|
16844
|
+
"kind": "Content",
|
|
16845
|
+
"text": "): "
|
|
16608
16846
|
},
|
|
16609
16847
|
{
|
|
16610
16848
|
"kind": "Reference",
|
|
@@ -16622,13 +16860,22 @@
|
|
|
16622
16860
|
],
|
|
16623
16861
|
"isStatic": false,
|
|
16624
16862
|
"returnTypeTokenRange": {
|
|
16625
|
-
"startIndex":
|
|
16626
|
-
"endIndex":
|
|
16863
|
+
"startIndex": 3,
|
|
16864
|
+
"endIndex": 5
|
|
16627
16865
|
},
|
|
16628
16866
|
"releaseTag": "Public",
|
|
16629
16867
|
"isProtected": false,
|
|
16630
16868
|
"overloadIndex": 1,
|
|
16631
|
-
"parameters": [
|
|
16869
|
+
"parameters": [
|
|
16870
|
+
{
|
|
16871
|
+
"parameterName": "tickAllocated",
|
|
16872
|
+
"parameterTypeTokenRange": {
|
|
16873
|
+
"startIndex": 1,
|
|
16874
|
+
"endIndex": 2
|
|
16875
|
+
},
|
|
16876
|
+
"isOptional": true
|
|
16877
|
+
}
|
|
16878
|
+
],
|
|
16632
16879
|
"isOptional": false,
|
|
16633
16880
|
"isAbstract": false,
|
|
16634
16881
|
"name": "getAllEntities"
|
|
@@ -22557,11 +22804,19 @@
|
|
|
22557
22804
|
{
|
|
22558
22805
|
"kind": "Method",
|
|
22559
22806
|
"canonicalReference": "server!LightManager#getAllLights:member(1)",
|
|
22560
|
-
"docComment": "/**\n * Retrieves all spawned Light instances for the world.\n *\n * @returns An array of Light instances.\n */\n",
|
|
22807
|
+
"docComment": "/**\n * Retrieves all spawned Light instances for the world.\n *\n * @param tickAllocated - Whether to use the tick allocator to allocate the returned array of Light instances. The allocated array will be collected and released at the end of the current tick if true. Only use this if you know what you're doing.\n *\n * @returns An array of Light instances.\n */\n",
|
|
22561
22808
|
"excerptTokens": [
|
|
22562
22809
|
{
|
|
22563
22810
|
"kind": "Content",
|
|
22564
|
-
"text": "getAllLights(
|
|
22811
|
+
"text": "getAllLights(tickAllocated?: "
|
|
22812
|
+
},
|
|
22813
|
+
{
|
|
22814
|
+
"kind": "Content",
|
|
22815
|
+
"text": "boolean"
|
|
22816
|
+
},
|
|
22817
|
+
{
|
|
22818
|
+
"kind": "Content",
|
|
22819
|
+
"text": "): "
|
|
22565
22820
|
},
|
|
22566
22821
|
{
|
|
22567
22822
|
"kind": "Reference",
|
|
@@ -22579,13 +22834,22 @@
|
|
|
22579
22834
|
],
|
|
22580
22835
|
"isStatic": false,
|
|
22581
22836
|
"returnTypeTokenRange": {
|
|
22582
|
-
"startIndex":
|
|
22583
|
-
"endIndex":
|
|
22837
|
+
"startIndex": 3,
|
|
22838
|
+
"endIndex": 5
|
|
22584
22839
|
},
|
|
22585
22840
|
"releaseTag": "Public",
|
|
22586
22841
|
"isProtected": false,
|
|
22587
22842
|
"overloadIndex": 1,
|
|
22588
|
-
"parameters": [
|
|
22843
|
+
"parameters": [
|
|
22844
|
+
{
|
|
22845
|
+
"parameterName": "tickAllocated",
|
|
22846
|
+
"parameterTypeTokenRange": {
|
|
22847
|
+
"startIndex": 1,
|
|
22848
|
+
"endIndex": 2
|
|
22849
|
+
},
|
|
22850
|
+
"isOptional": true
|
|
22851
|
+
}
|
|
22852
|
+
],
|
|
22589
22853
|
"isOptional": false,
|
|
22590
22854
|
"isAbstract": false,
|
|
22591
22855
|
"name": "getAllLights"
|
|
@@ -33446,11 +33710,19 @@
|
|
|
33446
33710
|
{
|
|
33447
33711
|
"kind": "Method",
|
|
33448
33712
|
"canonicalReference": "server!ParticleEmitterManager#getAllParticleEmitters:member(1)",
|
|
33449
|
-
"docComment": "/**\n * Retrieves all spawned ParticleEmitter instances for the world.\n *\n * @returns An array of ParticleEmitter instances.\n */\n",
|
|
33713
|
+
"docComment": "/**\n * Retrieves all spawned ParticleEmitter instances for the world.\n *\n * @param tickAllocated - Whether to use the tick allocator to allocate the returned array of ParticleEmitter instances. The allocated array will be collected and released at the end of the current tick if true. Only use this if you know what you're doing.\n *\n * @returns An array of ParticleEmitter instances.\n */\n",
|
|
33450
33714
|
"excerptTokens": [
|
|
33451
33715
|
{
|
|
33452
33716
|
"kind": "Content",
|
|
33453
|
-
"text": "getAllParticleEmitters(
|
|
33717
|
+
"text": "getAllParticleEmitters(tickAllocated?: "
|
|
33718
|
+
},
|
|
33719
|
+
{
|
|
33720
|
+
"kind": "Content",
|
|
33721
|
+
"text": "boolean"
|
|
33722
|
+
},
|
|
33723
|
+
{
|
|
33724
|
+
"kind": "Content",
|
|
33725
|
+
"text": "): "
|
|
33454
33726
|
},
|
|
33455
33727
|
{
|
|
33456
33728
|
"kind": "Reference",
|
|
@@ -33468,13 +33740,22 @@
|
|
|
33468
33740
|
],
|
|
33469
33741
|
"isStatic": false,
|
|
33470
33742
|
"returnTypeTokenRange": {
|
|
33471
|
-
"startIndex":
|
|
33472
|
-
"endIndex":
|
|
33743
|
+
"startIndex": 3,
|
|
33744
|
+
"endIndex": 5
|
|
33473
33745
|
},
|
|
33474
33746
|
"releaseTag": "Public",
|
|
33475
33747
|
"isProtected": false,
|
|
33476
33748
|
"overloadIndex": 1,
|
|
33477
|
-
"parameters": [
|
|
33749
|
+
"parameters": [
|
|
33750
|
+
{
|
|
33751
|
+
"parameterName": "tickAllocated",
|
|
33752
|
+
"parameterTypeTokenRange": {
|
|
33753
|
+
"startIndex": 1,
|
|
33754
|
+
"endIndex": 2
|
|
33755
|
+
},
|
|
33756
|
+
"isOptional": true
|
|
33757
|
+
}
|
|
33758
|
+
],
|
|
33478
33759
|
"isOptional": false,
|
|
33479
33760
|
"isAbstract": false,
|
|
33480
33761
|
"name": "getAllParticleEmitters"
|
|
@@ -46615,11 +46896,19 @@
|
|
|
46615
46896
|
{
|
|
46616
46897
|
"kind": "Method",
|
|
46617
46898
|
"canonicalReference": "server!SceneUIManager#getAllSceneUIs:member(1)",
|
|
46618
|
-
"docComment": "/**\n * Retrieves all loaded SceneUI instances for the world.\n *\n * @returns An array of SceneUI instances.\n */\n",
|
|
46899
|
+
"docComment": "/**\n * Retrieves all loaded SceneUI instances for the world.\n *\n * @param tickAllocated - Whether to use the tick allocator to allocate the returned array of SceneUI instances. The allocated array will be collected and released at the end of the current tick if true. Only use this if you know what you're doing.\n *\n * @returns An array of SceneUI instances.\n */\n",
|
|
46619
46900
|
"excerptTokens": [
|
|
46620
46901
|
{
|
|
46621
46902
|
"kind": "Content",
|
|
46622
|
-
"text": "getAllSceneUIs(
|
|
46903
|
+
"text": "getAllSceneUIs(tickAllocated?: "
|
|
46904
|
+
},
|
|
46905
|
+
{
|
|
46906
|
+
"kind": "Content",
|
|
46907
|
+
"text": "boolean"
|
|
46908
|
+
},
|
|
46909
|
+
{
|
|
46910
|
+
"kind": "Content",
|
|
46911
|
+
"text": "): "
|
|
46623
46912
|
},
|
|
46624
46913
|
{
|
|
46625
46914
|
"kind": "Reference",
|
|
@@ -46637,13 +46926,22 @@
|
|
|
46637
46926
|
],
|
|
46638
46927
|
"isStatic": false,
|
|
46639
46928
|
"returnTypeTokenRange": {
|
|
46640
|
-
"startIndex":
|
|
46641
|
-
"endIndex":
|
|
46929
|
+
"startIndex": 3,
|
|
46930
|
+
"endIndex": 5
|
|
46642
46931
|
},
|
|
46643
46932
|
"releaseTag": "Public",
|
|
46644
46933
|
"isProtected": false,
|
|
46645
46934
|
"overloadIndex": 1,
|
|
46646
|
-
"parameters": [
|
|
46935
|
+
"parameters": [
|
|
46936
|
+
{
|
|
46937
|
+
"parameterName": "tickAllocated",
|
|
46938
|
+
"parameterTypeTokenRange": {
|
|
46939
|
+
"startIndex": 1,
|
|
46940
|
+
"endIndex": 2
|
|
46941
|
+
},
|
|
46942
|
+
"isOptional": true
|
|
46943
|
+
}
|
|
46944
|
+
],
|
|
46647
46945
|
"isOptional": false,
|
|
46648
46946
|
"isAbstract": false,
|
|
46649
46947
|
"name": "getAllSceneUIs"
|
|
@@ -48604,6 +48902,568 @@
|
|
|
48604
48902
|
"endIndex": 2
|
|
48605
48903
|
}
|
|
48606
48904
|
},
|
|
48905
|
+
{
|
|
48906
|
+
"kind": "Class",
|
|
48907
|
+
"canonicalReference": "server!TickAllocator:class",
|
|
48908
|
+
"docComment": "/**\n * High-performance tick-scoped allocator for temporary objects, arrays, and buffers. All allocations are automatically bulk-released when reset() is called.\n *\n * @remarks\n *\n * TickAllocator maintains separate pools for different data types and tracks all allocations made during a tick cycle. Objects are reused across ticks to eliminate garbage collection overhead in hot paths like network synchronization.\n *\n * @example\n * ```typescript\n * // Allocate during tick\n * const position = tickAllocator.getArray3Number();\n * const rotation = tickAllocator.getArray4Number();\n * const data = tickAllocator.getObject<EntitySchema>();\n *\n * // At end of tick - bulk release everything\n * tickAllocator.reset();\n * ```\n *\n * @public\n */\n",
|
|
48909
|
+
"excerptTokens": [
|
|
48910
|
+
{
|
|
48911
|
+
"kind": "Content",
|
|
48912
|
+
"text": "export default class TickAllocator "
|
|
48913
|
+
}
|
|
48914
|
+
],
|
|
48915
|
+
"fileUrlPath": "src/shared/classes/TickAllocator.ts",
|
|
48916
|
+
"releaseTag": "Public",
|
|
48917
|
+
"isAbstract": false,
|
|
48918
|
+
"name": "TickAllocator",
|
|
48919
|
+
"preserveMemberOrder": false,
|
|
48920
|
+
"members": [
|
|
48921
|
+
{
|
|
48922
|
+
"kind": "Method",
|
|
48923
|
+
"canonicalReference": "server!TickAllocator#getArray:member(1)",
|
|
48924
|
+
"docComment": "/**\n * Gets a generic array from the pool. Array is reset to empty state and ready for use.\n *\n * @typeParam T - The array type.\n *\n * @returns A reusable array.\n */\n",
|
|
48925
|
+
"excerptTokens": [
|
|
48926
|
+
{
|
|
48927
|
+
"kind": "Content",
|
|
48928
|
+
"text": "getArray<T extends "
|
|
48929
|
+
},
|
|
48930
|
+
{
|
|
48931
|
+
"kind": "Content",
|
|
48932
|
+
"text": "unknown[]"
|
|
48933
|
+
},
|
|
48934
|
+
{
|
|
48935
|
+
"kind": "Content",
|
|
48936
|
+
"text": " = "
|
|
48937
|
+
},
|
|
48938
|
+
{
|
|
48939
|
+
"kind": "Content",
|
|
48940
|
+
"text": "unknown[]"
|
|
48941
|
+
},
|
|
48942
|
+
{
|
|
48943
|
+
"kind": "Content",
|
|
48944
|
+
"text": ">(copyFromA?: "
|
|
48945
|
+
},
|
|
48946
|
+
{
|
|
48947
|
+
"kind": "Reference",
|
|
48948
|
+
"text": "Iterable",
|
|
48949
|
+
"canonicalReference": "!Iterable:interface"
|
|
48950
|
+
},
|
|
48951
|
+
{
|
|
48952
|
+
"kind": "Content",
|
|
48953
|
+
"text": "<unknown>"
|
|
48954
|
+
},
|
|
48955
|
+
{
|
|
48956
|
+
"kind": "Content",
|
|
48957
|
+
"text": ", copyFromB?: "
|
|
48958
|
+
},
|
|
48959
|
+
{
|
|
48960
|
+
"kind": "Reference",
|
|
48961
|
+
"text": "Iterable",
|
|
48962
|
+
"canonicalReference": "!Iterable:interface"
|
|
48963
|
+
},
|
|
48964
|
+
{
|
|
48965
|
+
"kind": "Content",
|
|
48966
|
+
"text": "<unknown>"
|
|
48967
|
+
},
|
|
48968
|
+
{
|
|
48969
|
+
"kind": "Content",
|
|
48970
|
+
"text": "): "
|
|
48971
|
+
},
|
|
48972
|
+
{
|
|
48973
|
+
"kind": "Content",
|
|
48974
|
+
"text": "T"
|
|
48975
|
+
},
|
|
48976
|
+
{
|
|
48977
|
+
"kind": "Content",
|
|
48978
|
+
"text": ";"
|
|
48979
|
+
}
|
|
48980
|
+
],
|
|
48981
|
+
"typeParameters": [
|
|
48982
|
+
{
|
|
48983
|
+
"typeParameterName": "T",
|
|
48984
|
+
"constraintTokenRange": {
|
|
48985
|
+
"startIndex": 1,
|
|
48986
|
+
"endIndex": 2
|
|
48987
|
+
},
|
|
48988
|
+
"defaultTypeTokenRange": {
|
|
48989
|
+
"startIndex": 3,
|
|
48990
|
+
"endIndex": 4
|
|
48991
|
+
}
|
|
48992
|
+
}
|
|
48993
|
+
],
|
|
48994
|
+
"isStatic": false,
|
|
48995
|
+
"returnTypeTokenRange": {
|
|
48996
|
+
"startIndex": 11,
|
|
48997
|
+
"endIndex": 12
|
|
48998
|
+
},
|
|
48999
|
+
"releaseTag": "Public",
|
|
49000
|
+
"isProtected": false,
|
|
49001
|
+
"overloadIndex": 1,
|
|
49002
|
+
"parameters": [
|
|
49003
|
+
{
|
|
49004
|
+
"parameterName": "copyFromA",
|
|
49005
|
+
"parameterTypeTokenRange": {
|
|
49006
|
+
"startIndex": 5,
|
|
49007
|
+
"endIndex": 7
|
|
49008
|
+
},
|
|
49009
|
+
"isOptional": true
|
|
49010
|
+
},
|
|
49011
|
+
{
|
|
49012
|
+
"parameterName": "copyFromB",
|
|
49013
|
+
"parameterTypeTokenRange": {
|
|
49014
|
+
"startIndex": 8,
|
|
49015
|
+
"endIndex": 10
|
|
49016
|
+
},
|
|
49017
|
+
"isOptional": true
|
|
49018
|
+
}
|
|
49019
|
+
],
|
|
49020
|
+
"isOptional": false,
|
|
49021
|
+
"isAbstract": false,
|
|
49022
|
+
"name": "getArray"
|
|
49023
|
+
},
|
|
49024
|
+
{
|
|
49025
|
+
"kind": "Method",
|
|
49026
|
+
"canonicalReference": "server!TickAllocator#getArray3Number:member(1)",
|
|
49027
|
+
"docComment": "/**\n * Gets a 3-element number array from the pool. Array is reset to [0, 0, 0] and ready for use.\n *\n * @returns A reusable 3-element array.\n */\n",
|
|
49028
|
+
"excerptTokens": [
|
|
49029
|
+
{
|
|
49030
|
+
"kind": "Content",
|
|
49031
|
+
"text": "getArray3Number(copyFrom?: "
|
|
49032
|
+
},
|
|
49033
|
+
{
|
|
49034
|
+
"kind": "Reference",
|
|
49035
|
+
"text": "Array3Number",
|
|
49036
|
+
"canonicalReference": "server!Array3Number:type"
|
|
49037
|
+
},
|
|
49038
|
+
{
|
|
49039
|
+
"kind": "Content",
|
|
49040
|
+
"text": " | "
|
|
49041
|
+
},
|
|
49042
|
+
{
|
|
49043
|
+
"kind": "Reference",
|
|
49044
|
+
"text": "Set",
|
|
49045
|
+
"canonicalReference": "!Set:interface"
|
|
49046
|
+
},
|
|
49047
|
+
{
|
|
49048
|
+
"kind": "Content",
|
|
49049
|
+
"text": "<number>"
|
|
49050
|
+
},
|
|
49051
|
+
{
|
|
49052
|
+
"kind": "Content",
|
|
49053
|
+
"text": "): "
|
|
49054
|
+
},
|
|
49055
|
+
{
|
|
49056
|
+
"kind": "Reference",
|
|
49057
|
+
"text": "Array3Number",
|
|
49058
|
+
"canonicalReference": "server!Array3Number:type"
|
|
49059
|
+
},
|
|
49060
|
+
{
|
|
49061
|
+
"kind": "Content",
|
|
49062
|
+
"text": ";"
|
|
49063
|
+
}
|
|
49064
|
+
],
|
|
49065
|
+
"isStatic": false,
|
|
49066
|
+
"returnTypeTokenRange": {
|
|
49067
|
+
"startIndex": 6,
|
|
49068
|
+
"endIndex": 7
|
|
49069
|
+
},
|
|
49070
|
+
"releaseTag": "Public",
|
|
49071
|
+
"isProtected": false,
|
|
49072
|
+
"overloadIndex": 1,
|
|
49073
|
+
"parameters": [
|
|
49074
|
+
{
|
|
49075
|
+
"parameterName": "copyFrom",
|
|
49076
|
+
"parameterTypeTokenRange": {
|
|
49077
|
+
"startIndex": 1,
|
|
49078
|
+
"endIndex": 5
|
|
49079
|
+
},
|
|
49080
|
+
"isOptional": true
|
|
49081
|
+
}
|
|
49082
|
+
],
|
|
49083
|
+
"isOptional": false,
|
|
49084
|
+
"isAbstract": false,
|
|
49085
|
+
"name": "getArray3Number"
|
|
49086
|
+
},
|
|
49087
|
+
{
|
|
49088
|
+
"kind": "Method",
|
|
49089
|
+
"canonicalReference": "server!TickAllocator#getArray4Number:member(1)",
|
|
49090
|
+
"docComment": "/**\n * Gets a 4-element number array from the pool. Array is reset to [0, 0, 0, 0] and ready for use.\n *\n * @returns A reusable 4-element array.\n */\n",
|
|
49091
|
+
"excerptTokens": [
|
|
49092
|
+
{
|
|
49093
|
+
"kind": "Content",
|
|
49094
|
+
"text": "getArray4Number(copyFrom?: "
|
|
49095
|
+
},
|
|
49096
|
+
{
|
|
49097
|
+
"kind": "Reference",
|
|
49098
|
+
"text": "Array4Number",
|
|
49099
|
+
"canonicalReference": "server!Array4Number:type"
|
|
49100
|
+
},
|
|
49101
|
+
{
|
|
49102
|
+
"kind": "Content",
|
|
49103
|
+
"text": " | "
|
|
49104
|
+
},
|
|
49105
|
+
{
|
|
49106
|
+
"kind": "Reference",
|
|
49107
|
+
"text": "Set",
|
|
49108
|
+
"canonicalReference": "!Set:interface"
|
|
49109
|
+
},
|
|
49110
|
+
{
|
|
49111
|
+
"kind": "Content",
|
|
49112
|
+
"text": "<number>"
|
|
49113
|
+
},
|
|
49114
|
+
{
|
|
49115
|
+
"kind": "Content",
|
|
49116
|
+
"text": "): "
|
|
49117
|
+
},
|
|
49118
|
+
{
|
|
49119
|
+
"kind": "Reference",
|
|
49120
|
+
"text": "Array4Number",
|
|
49121
|
+
"canonicalReference": "server!Array4Number:type"
|
|
49122
|
+
},
|
|
49123
|
+
{
|
|
49124
|
+
"kind": "Content",
|
|
49125
|
+
"text": ";"
|
|
49126
|
+
}
|
|
49127
|
+
],
|
|
49128
|
+
"isStatic": false,
|
|
49129
|
+
"returnTypeTokenRange": {
|
|
49130
|
+
"startIndex": 6,
|
|
49131
|
+
"endIndex": 7
|
|
49132
|
+
},
|
|
49133
|
+
"releaseTag": "Public",
|
|
49134
|
+
"isProtected": false,
|
|
49135
|
+
"overloadIndex": 1,
|
|
49136
|
+
"parameters": [
|
|
49137
|
+
{
|
|
49138
|
+
"parameterName": "copyFrom",
|
|
49139
|
+
"parameterTypeTokenRange": {
|
|
49140
|
+
"startIndex": 1,
|
|
49141
|
+
"endIndex": 5
|
|
49142
|
+
},
|
|
49143
|
+
"isOptional": true
|
|
49144
|
+
}
|
|
49145
|
+
],
|
|
49146
|
+
"isOptional": false,
|
|
49147
|
+
"isAbstract": false,
|
|
49148
|
+
"name": "getArray4Number"
|
|
49149
|
+
},
|
|
49150
|
+
{
|
|
49151
|
+
"kind": "Method",
|
|
49152
|
+
"canonicalReference": "server!TickAllocator#getObject:member(1)",
|
|
49153
|
+
"docComment": "/**\n * Gets a plain object from the pool. Object is reset to empty state and ready for use.\n *\n * @typeParam T - The type interface for the object.\n *\n * @returns A reusable plain object.\n */\n",
|
|
49154
|
+
"excerptTokens": [
|
|
49155
|
+
{
|
|
49156
|
+
"kind": "Content",
|
|
49157
|
+
"text": "getObject<T extends "
|
|
49158
|
+
},
|
|
49159
|
+
{
|
|
49160
|
+
"kind": "Reference",
|
|
49161
|
+
"text": "Record",
|
|
49162
|
+
"canonicalReference": "!Record:type"
|
|
49163
|
+
},
|
|
49164
|
+
{
|
|
49165
|
+
"kind": "Content",
|
|
49166
|
+
"text": "<string, unknown>"
|
|
49167
|
+
},
|
|
49168
|
+
{
|
|
49169
|
+
"kind": "Content",
|
|
49170
|
+
"text": " = "
|
|
49171
|
+
},
|
|
49172
|
+
{
|
|
49173
|
+
"kind": "Reference",
|
|
49174
|
+
"text": "Record",
|
|
49175
|
+
"canonicalReference": "!Record:type"
|
|
49176
|
+
},
|
|
49177
|
+
{
|
|
49178
|
+
"kind": "Content",
|
|
49179
|
+
"text": "<string, unknown>"
|
|
49180
|
+
},
|
|
49181
|
+
{
|
|
49182
|
+
"kind": "Content",
|
|
49183
|
+
"text": ">(copyFromA?: "
|
|
49184
|
+
},
|
|
49185
|
+
{
|
|
49186
|
+
"kind": "Content",
|
|
49187
|
+
"text": "T"
|
|
49188
|
+
},
|
|
49189
|
+
{
|
|
49190
|
+
"kind": "Content",
|
|
49191
|
+
"text": ", copyFromB?: "
|
|
49192
|
+
},
|
|
49193
|
+
{
|
|
49194
|
+
"kind": "Content",
|
|
49195
|
+
"text": "T"
|
|
49196
|
+
},
|
|
49197
|
+
{
|
|
49198
|
+
"kind": "Content",
|
|
49199
|
+
"text": "): "
|
|
49200
|
+
},
|
|
49201
|
+
{
|
|
49202
|
+
"kind": "Content",
|
|
49203
|
+
"text": "T"
|
|
49204
|
+
},
|
|
49205
|
+
{
|
|
49206
|
+
"kind": "Content",
|
|
49207
|
+
"text": ";"
|
|
49208
|
+
}
|
|
49209
|
+
],
|
|
49210
|
+
"typeParameters": [
|
|
49211
|
+
{
|
|
49212
|
+
"typeParameterName": "T",
|
|
49213
|
+
"constraintTokenRange": {
|
|
49214
|
+
"startIndex": 1,
|
|
49215
|
+
"endIndex": 3
|
|
49216
|
+
},
|
|
49217
|
+
"defaultTypeTokenRange": {
|
|
49218
|
+
"startIndex": 4,
|
|
49219
|
+
"endIndex": 6
|
|
49220
|
+
}
|
|
49221
|
+
}
|
|
49222
|
+
],
|
|
49223
|
+
"isStatic": false,
|
|
49224
|
+
"returnTypeTokenRange": {
|
|
49225
|
+
"startIndex": 11,
|
|
49226
|
+
"endIndex": 12
|
|
49227
|
+
},
|
|
49228
|
+
"releaseTag": "Public",
|
|
49229
|
+
"isProtected": false,
|
|
49230
|
+
"overloadIndex": 1,
|
|
49231
|
+
"parameters": [
|
|
49232
|
+
{
|
|
49233
|
+
"parameterName": "copyFromA",
|
|
49234
|
+
"parameterTypeTokenRange": {
|
|
49235
|
+
"startIndex": 7,
|
|
49236
|
+
"endIndex": 8
|
|
49237
|
+
},
|
|
49238
|
+
"isOptional": true
|
|
49239
|
+
},
|
|
49240
|
+
{
|
|
49241
|
+
"parameterName": "copyFromB",
|
|
49242
|
+
"parameterTypeTokenRange": {
|
|
49243
|
+
"startIndex": 9,
|
|
49244
|
+
"endIndex": 10
|
|
49245
|
+
},
|
|
49246
|
+
"isOptional": true
|
|
49247
|
+
}
|
|
49248
|
+
],
|
|
49249
|
+
"isOptional": false,
|
|
49250
|
+
"isAbstract": false,
|
|
49251
|
+
"name": "getObject"
|
|
49252
|
+
},
|
|
49253
|
+
{
|
|
49254
|
+
"kind": "Method",
|
|
49255
|
+
"canonicalReference": "server!TickAllocator#getSet:member(1)",
|
|
49256
|
+
"docComment": "/**\n * Gets a set from the pool. Set is reset to empty state and ready for use.\n *\n * @typeParam T - The type of the set.\n *\n * @returns A reusable set.\n */\n",
|
|
49257
|
+
"excerptTokens": [
|
|
49258
|
+
{
|
|
49259
|
+
"kind": "Content",
|
|
49260
|
+
"text": "getSet<T>(copyFromA?: "
|
|
49261
|
+
},
|
|
49262
|
+
{
|
|
49263
|
+
"kind": "Reference",
|
|
49264
|
+
"text": "Set",
|
|
49265
|
+
"canonicalReference": "!Set:interface"
|
|
49266
|
+
},
|
|
49267
|
+
{
|
|
49268
|
+
"kind": "Content",
|
|
49269
|
+
"text": "<T> | T[]"
|
|
49270
|
+
},
|
|
49271
|
+
{
|
|
49272
|
+
"kind": "Content",
|
|
49273
|
+
"text": ", copyFromB?: "
|
|
49274
|
+
},
|
|
49275
|
+
{
|
|
49276
|
+
"kind": "Reference",
|
|
49277
|
+
"text": "Set",
|
|
49278
|
+
"canonicalReference": "!Set:interface"
|
|
49279
|
+
},
|
|
49280
|
+
{
|
|
49281
|
+
"kind": "Content",
|
|
49282
|
+
"text": "<T> | T[]"
|
|
49283
|
+
},
|
|
49284
|
+
{
|
|
49285
|
+
"kind": "Content",
|
|
49286
|
+
"text": "): "
|
|
49287
|
+
},
|
|
49288
|
+
{
|
|
49289
|
+
"kind": "Reference",
|
|
49290
|
+
"text": "Set",
|
|
49291
|
+
"canonicalReference": "!Set:interface"
|
|
49292
|
+
},
|
|
49293
|
+
{
|
|
49294
|
+
"kind": "Content",
|
|
49295
|
+
"text": "<T>"
|
|
49296
|
+
},
|
|
49297
|
+
{
|
|
49298
|
+
"kind": "Content",
|
|
49299
|
+
"text": ";"
|
|
49300
|
+
}
|
|
49301
|
+
],
|
|
49302
|
+
"typeParameters": [
|
|
49303
|
+
{
|
|
49304
|
+
"typeParameterName": "T",
|
|
49305
|
+
"constraintTokenRange": {
|
|
49306
|
+
"startIndex": 0,
|
|
49307
|
+
"endIndex": 0
|
|
49308
|
+
},
|
|
49309
|
+
"defaultTypeTokenRange": {
|
|
49310
|
+
"startIndex": 0,
|
|
49311
|
+
"endIndex": 0
|
|
49312
|
+
}
|
|
49313
|
+
}
|
|
49314
|
+
],
|
|
49315
|
+
"isStatic": false,
|
|
49316
|
+
"returnTypeTokenRange": {
|
|
49317
|
+
"startIndex": 7,
|
|
49318
|
+
"endIndex": 9
|
|
49319
|
+
},
|
|
49320
|
+
"releaseTag": "Public",
|
|
49321
|
+
"isProtected": false,
|
|
49322
|
+
"overloadIndex": 1,
|
|
49323
|
+
"parameters": [
|
|
49324
|
+
{
|
|
49325
|
+
"parameterName": "copyFromA",
|
|
49326
|
+
"parameterTypeTokenRange": {
|
|
49327
|
+
"startIndex": 1,
|
|
49328
|
+
"endIndex": 3
|
|
49329
|
+
},
|
|
49330
|
+
"isOptional": true
|
|
49331
|
+
},
|
|
49332
|
+
{
|
|
49333
|
+
"parameterName": "copyFromB",
|
|
49334
|
+
"parameterTypeTokenRange": {
|
|
49335
|
+
"startIndex": 4,
|
|
49336
|
+
"endIndex": 6
|
|
49337
|
+
},
|
|
49338
|
+
"isOptional": true
|
|
49339
|
+
}
|
|
49340
|
+
],
|
|
49341
|
+
"isOptional": false,
|
|
49342
|
+
"isAbstract": false,
|
|
49343
|
+
"name": "getSet"
|
|
49344
|
+
},
|
|
49345
|
+
{
|
|
49346
|
+
"kind": "Method",
|
|
49347
|
+
"canonicalReference": "server!TickAllocator#map:member(1)",
|
|
49348
|
+
"docComment": "/**\n * Maps an array to a new array using a callback function.\n *\n * @param array - The array to map.\n *\n * @param callback - The callback function to map the array.\n *\n * @typeParam T - The type of the array.\n *\n * @typeParam U - The type of the resulting array.\n *\n * @returns A new array with the mapped values.\n */\n",
|
|
49349
|
+
"excerptTokens": [
|
|
49350
|
+
{
|
|
49351
|
+
"kind": "Content",
|
|
49352
|
+
"text": "map<T, U>(array: "
|
|
49353
|
+
},
|
|
49354
|
+
{
|
|
49355
|
+
"kind": "Content",
|
|
49356
|
+
"text": "T[]"
|
|
49357
|
+
},
|
|
49358
|
+
{
|
|
49359
|
+
"kind": "Content",
|
|
49360
|
+
"text": ", callback: "
|
|
49361
|
+
},
|
|
49362
|
+
{
|
|
49363
|
+
"kind": "Content",
|
|
49364
|
+
"text": "(value: T, index: number, array: T[]) => U"
|
|
49365
|
+
},
|
|
49366
|
+
{
|
|
49367
|
+
"kind": "Content",
|
|
49368
|
+
"text": "): "
|
|
49369
|
+
},
|
|
49370
|
+
{
|
|
49371
|
+
"kind": "Content",
|
|
49372
|
+
"text": "U[]"
|
|
49373
|
+
},
|
|
49374
|
+
{
|
|
49375
|
+
"kind": "Content",
|
|
49376
|
+
"text": ";"
|
|
49377
|
+
}
|
|
49378
|
+
],
|
|
49379
|
+
"typeParameters": [
|
|
49380
|
+
{
|
|
49381
|
+
"typeParameterName": "T",
|
|
49382
|
+
"constraintTokenRange": {
|
|
49383
|
+
"startIndex": 0,
|
|
49384
|
+
"endIndex": 0
|
|
49385
|
+
},
|
|
49386
|
+
"defaultTypeTokenRange": {
|
|
49387
|
+
"startIndex": 0,
|
|
49388
|
+
"endIndex": 0
|
|
49389
|
+
}
|
|
49390
|
+
},
|
|
49391
|
+
{
|
|
49392
|
+
"typeParameterName": "U",
|
|
49393
|
+
"constraintTokenRange": {
|
|
49394
|
+
"startIndex": 0,
|
|
49395
|
+
"endIndex": 0
|
|
49396
|
+
},
|
|
49397
|
+
"defaultTypeTokenRange": {
|
|
49398
|
+
"startIndex": 0,
|
|
49399
|
+
"endIndex": 0
|
|
49400
|
+
}
|
|
49401
|
+
}
|
|
49402
|
+
],
|
|
49403
|
+
"isStatic": false,
|
|
49404
|
+
"returnTypeTokenRange": {
|
|
49405
|
+
"startIndex": 5,
|
|
49406
|
+
"endIndex": 6
|
|
49407
|
+
},
|
|
49408
|
+
"releaseTag": "Public",
|
|
49409
|
+
"isProtected": false,
|
|
49410
|
+
"overloadIndex": 1,
|
|
49411
|
+
"parameters": [
|
|
49412
|
+
{
|
|
49413
|
+
"parameterName": "array",
|
|
49414
|
+
"parameterTypeTokenRange": {
|
|
49415
|
+
"startIndex": 1,
|
|
49416
|
+
"endIndex": 2
|
|
49417
|
+
},
|
|
49418
|
+
"isOptional": false
|
|
49419
|
+
},
|
|
49420
|
+
{
|
|
49421
|
+
"parameterName": "callback",
|
|
49422
|
+
"parameterTypeTokenRange": {
|
|
49423
|
+
"startIndex": 3,
|
|
49424
|
+
"endIndex": 4
|
|
49425
|
+
},
|
|
49426
|
+
"isOptional": false
|
|
49427
|
+
}
|
|
49428
|
+
],
|
|
49429
|
+
"isOptional": false,
|
|
49430
|
+
"isAbstract": false,
|
|
49431
|
+
"name": "map"
|
|
49432
|
+
},
|
|
49433
|
+
{
|
|
49434
|
+
"kind": "Method",
|
|
49435
|
+
"canonicalReference": "server!TickAllocator#reset:member(1)",
|
|
49436
|
+
"docComment": "/**\n * Releases all allocated objects back to their respective pools. This is intended to be called at the end of a tick.\n */\n",
|
|
49437
|
+
"excerptTokens": [
|
|
49438
|
+
{
|
|
49439
|
+
"kind": "Content",
|
|
49440
|
+
"text": "reset(): "
|
|
49441
|
+
},
|
|
49442
|
+
{
|
|
49443
|
+
"kind": "Content",
|
|
49444
|
+
"text": "void"
|
|
49445
|
+
},
|
|
49446
|
+
{
|
|
49447
|
+
"kind": "Content",
|
|
49448
|
+
"text": ";"
|
|
49449
|
+
}
|
|
49450
|
+
],
|
|
49451
|
+
"isStatic": false,
|
|
49452
|
+
"returnTypeTokenRange": {
|
|
49453
|
+
"startIndex": 1,
|
|
49454
|
+
"endIndex": 2
|
|
49455
|
+
},
|
|
49456
|
+
"releaseTag": "Public",
|
|
49457
|
+
"isProtected": false,
|
|
49458
|
+
"overloadIndex": 1,
|
|
49459
|
+
"parameters": [],
|
|
49460
|
+
"isOptional": false,
|
|
49461
|
+
"isAbstract": false,
|
|
49462
|
+
"name": "reset"
|
|
49463
|
+
}
|
|
49464
|
+
],
|
|
49465
|
+
"implementsTokenRanges": []
|
|
49466
|
+
},
|
|
48607
49467
|
{
|
|
48608
49468
|
"kind": "Interface",
|
|
48609
49469
|
"canonicalReference": "server!TrimeshColliderOptions:interface",
|
|
@@ -54162,6 +55022,37 @@
|
|
|
54162
55022
|
"isStatic": false,
|
|
54163
55023
|
"isProtected": false,
|
|
54164
55024
|
"isAbstract": false
|
|
55025
|
+
},
|
|
55026
|
+
{
|
|
55027
|
+
"kind": "Property",
|
|
55028
|
+
"canonicalReference": "server!World#tickAllocator:member",
|
|
55029
|
+
"docComment": "/**\n * The tick allocator for the world.\n */\n",
|
|
55030
|
+
"excerptTokens": [
|
|
55031
|
+
{
|
|
55032
|
+
"kind": "Content",
|
|
55033
|
+
"text": "get tickAllocator(): "
|
|
55034
|
+
},
|
|
55035
|
+
{
|
|
55036
|
+
"kind": "Reference",
|
|
55037
|
+
"text": "TickAllocator",
|
|
55038
|
+
"canonicalReference": "server!TickAllocator:class"
|
|
55039
|
+
},
|
|
55040
|
+
{
|
|
55041
|
+
"kind": "Content",
|
|
55042
|
+
"text": ";"
|
|
55043
|
+
}
|
|
55044
|
+
],
|
|
55045
|
+
"isReadonly": true,
|
|
55046
|
+
"isOptional": false,
|
|
55047
|
+
"releaseTag": "Public",
|
|
55048
|
+
"name": "tickAllocator",
|
|
55049
|
+
"propertyTypeTokenRange": {
|
|
55050
|
+
"startIndex": 1,
|
|
55051
|
+
"endIndex": 2
|
|
55052
|
+
},
|
|
55053
|
+
"isStatic": false,
|
|
55054
|
+
"isProtected": false,
|
|
55055
|
+
"isAbstract": false
|
|
54165
55056
|
}
|
|
54166
55057
|
],
|
|
54167
55058
|
"extendsTokenRange": {
|