160 Commits

Author SHA1 Message Date
dc0d5dc2c1 WorkStation: rename WorkStation -> ImmersiveWorkStation, rework code, support new node tab stuff 2026-05-20 21:23:21 +03:00
8a5b358d79 ProcessingStation: minor changes 2026-05-20 21:22:04 +03:00
0051dea067 CraftSystem: reworking the code, adding something useful 2026-05-20 21:20:55 +03:00
83aac87ab9 PlayerInventoryUI: Creating a crafting tab template and supporting crafting through the node tab 2026-05-20 21:19:38 +03:00
bdef2fffaf HelperLib: remove immersiveCraftData stuff 2026-05-20 21:18:02 +03:00
c578e6d5b1 Update ide-helper 2026-05-20 21:17:07 +03:00
85aaf470f7 Table: fix annotations, remove defMerge alias from Item, Node, and Tool 2026-05-19 17:14:56 +03:00
bd1059f9d7 Table: table.merge annotation fix 2026-05-18 21:48:43 +03:00
73905c8bc6 CraftSystem: Changing the approach to class inheritance and adding default parameters for crafts 2026-05-18 21:48:12 +03:00
e410afaffc ProcessingStation: minor refactoring and addition of idle parameter 2026-05-17 16:43:32 +03:00
ab140b4373 PlayerInventoryUI: fix updateNodeForm stuff 2026-05-17 16:42:11 +03:00
832ff491f6 Table: fix table.remove_value 2026-05-17 16:40:56 +03:00
9bbdbe4d2b Update utf8 submodule 2026-05-14 22:46:22 +03:00
edd20882ed ProcessingStation: add class and test node (furnance) 2026-05-14 22:20:33 +03:00
35de78bdec PlayerInventory: add updateNodeForm method and support stuff 2026-05-14 22:18:54 +03:00
0ee21106d5 CraftSystem: add TODO note 2026-05-14 22:17:29 +03:00
ac8cb8a99f Mod: raise an error if the mod does not exist 2026-05-14 22:16:41 +03:00
1a97abe49e update ide-helper 2026-05-09 23:01:54 +03:00
3255b919e2 BaseUI: minor change 2026-05-09 22:58:28 +03:00
2b7600b745 Table: add table.remove_value method 2026-05-09 22:57:45 +03:00
5265024231 CraftSystem: add getCraftByHash method to ProcessingCraftHandler, minor fixes 2026-05-06 19:44:18 +03:00
089105d3e9 PlayerInventoryUI: Added support for node tabs 2026-05-04 20:44:35 +03:00
88abb30041 HelperLib: add PlayerInventoryUI require 2026-05-04 20:43:59 +03:00
566fbc36d7 WorkStation: minor fix 2026-05-03 22:40:06 +03:00
c143e95b27 CraftSystem (and other): Changing the approach to the crafting system. Adding crafting types, correcting calls to the crafting system 2026-05-03 22:31:50 +03:00
35699c1489 WorkStation: minor fixes 2026-05-02 20:46:41 +03:00
17a2aabfcc Node: clarification of callbacks annotations 2026-05-02 20:13:46 +03:00
4d11335470 CraftSystem: add processing craft. Close #28 2026-05-02 19:33:15 +03:00
f60faa4293 PlayerInventoryUI: Added display of material availability in the crafting recipe. #34 2026-05-01 19:46:05 +03:00
c902aff4af Formspec: Added escaping for some text elements 2026-05-01 19:45:32 +03:00
4a8a6245a6 PlayerInventoryUI: Support and display of alternative recipes in the crafting menu. #34 2026-04-30 21:35:30 +03:00
08dde36326 CraftSystem: add alternative recipes to primitive crafts 2026-04-30 21:34:50 +03:00
964a60ed7c equipment: update equipment_sheet.png 2026-04-29 21:38:08 +03:00
6c64e2fe27 PlayerInventoryUI: add search craft field 2026-04-29 21:37:44 +03:00
3feefb2e96 HelperLib: remove print() 2026-04-29 21:36:52 +03:00
e8210924bf CraftSystem: Added the ability to select crafts by pattern 2026-04-29 21:35:28 +03:00
bbaf18f352 Formspec: fix fieldCloseOnEnter 2026-04-29 20:11:49 +03:00
95bba1b02d equipment & PlayerInventoryUI: Added test clothing, autolistring for clothing slots, and clothing slot overlay 2026-04-28 19:52:02 +03:00
b314f7adf8 Item & PlayerInventoryUI: Bags now have the ability to filter items by groups 2026-04-28 19:30:32 +03:00
0b372111cf Item: minor annotations fix 2026-04-27 21:55:25 +03:00
c2782dda61 PlayerInventoryUI: change the orientation of the inventory mode switch 2026-04-27 21:54:47 +03:00
a9f96d97f2 ide-helper update 2026-04-27 19:39:42 +03:00
18d152bfa2 equipment: add test bags 2026-04-27 19:38:19 +03:00
bbafab8e00 PlayerInventoryUI: Organizing the equipment and bag tabs. Creating a bag mechanic. #34 2026-04-27 19:37:27 +03:00
c871b549d8 Item: New fields responsible for inventory items have been added. 2026-04-27 19:34:44 +03:00
7c241af96a HelperLib: Added methods for handler inventory items 2026-04-27 19:34:04 +03:00
e4f0799487 Table: fix table.key_value_list 2026-04-27 19:30:17 +03:00
757221e668 mapGenerator: add generation grass and rock to meadow 2026-04-23 22:31:14 +03:00
3793afebbd Plant: add waving 2026-04-23 22:30:17 +03:00
af3ce8c769 plants: add meadow grass 2026-04-23 22:29:57 +03:00
fcae65e8f8 MapGen & mapGenerator: add param2_data 2026-04-23 16:49:35 +03:00
1b98571eae plants: add rye 2026-04-23 15:44:42 +03:00
51394d1df6 soils: add plowed soil 2026-04-23 15:44:22 +03:00
c6ec550ee4 mapGenerator: create green meadow biome 2026-04-22 22:10:18 +03:00
b881039368 soils: Creation of a soil registration function. Registration of humus and meadow turf 2026-04-22 22:09:52 +03:00
1b5d122205 AdminListUI: Correct processing of items without special fields. 2026-04-21 21:48:34 +03:00
7c7a318d22 PlayerInventoryUI: autolistring equipments slots 2026-04-21 21:06:19 +03:00
ad521ce2b7 Update ide-helper 2026-04-19 21:41:02 +03:00
0d986dafd5 rocks: rocks update 2026-04-19 21:35:10 +03:00
f34c12c59f PlayerInventoryUI: add equipment slot overlay 2026-04-19 20:31:52 +03:00
89bc05d2cb equipment: add some armor 2026-04-19 20:31:26 +03:00
99093493c0 rocks: Change of registration of rocks 2026-04-19 19:48:04 +03:00
31d66277ae wood: Added registration of node segments for planks and timber 2026-04-18 22:41:33 +03:00
93d4b3145c Node: Added the ability to register slabs and stairs through a specific group. 2026-04-18 22:38:33 +03:00
ed9a80b2cf rocks: add chipped tautite 2026-04-18 21:44:47 +03:00
9fd665aaa5 PlayerInventoryUI: remove profiler string 2026-04-17 18:01:14 +03:00
8e09f8fa53 PlayerInventoryUI: Now you can only place items with a specific group in equipment slots. #34 2026-04-17 17:34:15 +03:00
97084c9060 equipment: create equipment mod, add test equip 2026-04-17 17:24:10 +03:00
7e46c858cc Update ide-helper 2026-04-17 17:10:44 +03:00
ac28f9e92b Update ide-helper 2026-04-17 16:55:52 +03:00
b62e19d10a Update ide-helper 2026-04-17 16:26:02 +03:00
6dba6f8c78 PlayerInventory & PlayerInventoryUI: create equip slots & draft equip tab. #34 2026-04-16 21:07:19 +03:00
0a97ef3a83 PlayerInventory & PlayerInventoryUI: Transferring inventory action handlers from Player to PlayerInventoryUI. #34 2026-04-16 20:30:10 +03:00
7661cacbfe Changing the format for writing chain-calls for FormSpecs. 2026-04-13 22:06:02 +03:00
c172198ff7 PlayerInventory & PlayerInventoryUI: adding explanatory annotations and comments to the code. #34 2026-04-13 22:00:27 +03:00
f1c82d9220 Tool: remove unnecessary code 2026-04-13 20:58:37 +03:00
b4290ad1f9 Update copyright year 2026-04-13 20:46:48 +03:00
f31277f8b0 update menu/background.png 2026-04-11 22:48:30 +03:00
0189b29257 wood: update wood blocks names, add timber textures, add log branch 2026-04-11 22:48:04 +03:00
b0aad2823a Fix merge items settings 2026-04-11 21:54:49 +03:00
76f74743ba PlayerInventory & PlayerInventoryUI: adding a compact inventory form and changing the tab switching system. #34 2026-04-10 21:44:23 +03:00
cc8f896d6e PlayerInventory & PlayerInventoryUI: rename pane -> tab. #34 2026-04-07 20:50:03 +03:00
b579418b9a wood: update sheet 2026-04-07 20:27:42 +03:00
bddcb4e36c PlayerInventory & PlayerInventoryUI: You can now specify groups as materials for primitive crafting in your inventory. #34 2026-04-04 18:00:24 +03:00
d5c6101c0f PlayerInventory & PlayerInventoryUI: remove group image animation. #34 2026-04-04 16:55:42 +03:00
b53753c6a5 HelperLib: delete Philosopher font 2026-04-04 16:54:54 +03:00
427c674103 PlayerInventory & PlayerInventoryUI: Completion of work on a sane version of the crafting menu. #34 2026-04-03 21:45:24 +03:00
91603e21f8 Table: Replacing the Voxrames version of table.join with ours 2026-04-03 21:43:43 +03:00
f5fba0b779 wood & rocks: changes to draft crafts for demonstration 2026-04-03 21:41:02 +03:00
d5b9504cc5 CraftSystem: small fix 2026-04-03 21:40:17 +03:00
a1e74978a5 BaseUI: Added support for tracking active forms 2026-04-03 21:39:19 +03:00
1dc6fb3f39 HelperLib: add Smc.getRegisteredItemByName() 2026-04-03 21:38:09 +03:00
89c52c80bc HelperLib: Smc.registerGlobalStepForEachPlayer fix 2026-04-03 21:37:39 +03:00
162f8d2639 HelperLib: events fixes 2026-04-03 21:36:55 +03:00
7af83a87d8 HelperLib: add active formspecs handler 2026-04-03 21:36:08 +03:00
0e59cf799a CraftSystem: change table.merge -> table.join 2026-04-03 19:26:16 +03:00
89de48b5a8 Table: add table.join from Voxrame 2026-04-03 19:18:54 +03:00
362d626f9b CraftSystem: add groupedCrafts 2026-04-03 18:42:18 +03:00
defd3531bc wood: add stiks, planks, bars 2026-03-30 21:25:19 +03:00
584e710d5c PlayerInventory & PlayerInventoryUI: Fixed inventory state saving 2026-03-30 21:06:09 +03:00
8a0b5785ab Added the ability to specify the number of items in primitive crafting recipes and results 2026-03-30 20:59:34 +03:00
9873e059cb Submodule: ide-helper update 2026-03-30 20:54:14 +03:00
d05af7dacc PlayerInventoryUI:Adding background textures to the crafting menu. #34 2026-03-28 18:14:01 +03:00
9ed2319b14 PlayerInventory & PlayerInventoryUI: Adding minimal functionality to the crafting pane. #34 2026-03-28 17:03:04 +03:00
d6cc39a0b2 rocks & wood: add draft crafts 2026-03-28 17:01:49 +03:00
2935c4d10b CraftSystem: minor fixes 2026-03-28 17:00:54 +03:00
Van
53801a56a8 Merge pull request 'mapgen-optimizations' (#39) from mapgen-optimizations into main
Reviewed-on: #39
2026-03-28 15:20:23 +03:00
f1610056cc Formspec: create Formspec:listNodeMetaLocation 2026-03-27 19:03:43 +03:00
914ea881a4 PlayerInventoryUI: update backgrounds textures. #34 2026-03-26 21:37:13 +03:00
cb87d16560 Remove docs directory 2026-03-21 21:28:35 +03:00
ceb35639b8 MapGen: minor refactoring 2026-03-21 21:26:27 +03:00
79df8f2f52 MapGen: a little bit more optimizations 2026-03-21 20:53:02 +03:00
44916bcd3b BaseUI: remove print() 2026-03-20 23:06:05 +03:00
3483cd650a Item: add optional rarity color in title. Close #35 2026-03-20 23:05:40 +03:00
c4104a1834 HelperLib: add craft system requires 2026-03-20 22:10:26 +03:00
e98935cf6f PlayerInventoryUI: Adding basic panes switching functionality. #34 2026-03-19 21:57:43 +03:00
338cc7a36b PlayerInventoryUI: Draft version of the player inventory and pane templates. #34 2026-03-18 22:12:01 +03:00
18f06d13d3 Formspec: minor fixes 2026-03-18 22:10:35 +03:00
e986a4c538 MapGen: There is now only one triangulation map instead of three. 2026-03-16 20:59:39 +03:00
93bda75727 Profiler: some changes 2026-03-16 20:57:37 +03:00
1531abc3e2 MapGen: Attempt to speed up generation. Some MapGen.Peak fields can now be accessed directly. Layers are now defined for the entire chunk, rather than per node. 2026-03-15 22:08:13 +03:00
a34822ed54 MapGen: find optimization. #37 2026-03-13 21:57:05 +03:00
145f65d4af Player: create PlayerInventoryUI class & change item count in hotbar (8->9). #34 2026-03-12 21:44:03 +03:00
e359c4be09 Profiler: create class and base functional. Close #36 2026-03-12 20:10:55 +03:00
c009493484 MapGen: remove space 2026-03-12 19:44:27 +03:00
fab86c0486 License fix 2 2026-03-12 19:29:24 +03:00
cb15f25d60 License fix 2026-03-12 19:11:41 +03:00
867238e11b MapGen: add large map, disable log profiler 2026-03-12 15:05:53 +03:00
df247108ef MapGen: fastgen? 2026-03-11 23:34:09 +03:00
e34fd29a4b MapGen: removing unnecessary code. Completion of work on a new triangulation method. Close #25 2026-03-10 21:14:31 +03:00
41cf4710da MapGen: small map test 2026-03-09 21:51:49 +03:00
c6573ae308 MapGen: fix patch 2026-03-09 21:16:53 +03:00
4ef2476771 MapGen: Moving triangulation outside of Lua scripts, using pre-triangulated JSON files 2026-03-09 20:07:00 +03:00
2c13e1697f Wood: some Russian localization has been added 2026-03-08 22:44:42 +03:00
7b4839e63b Item: minor item description changes 2026-03-08 22:44:06 +03:00
2813d9d5fe Add missing locale admin command. Remove auto-check missing locale` 2026-03-08 20:56:48 +03:00
652200f28c Update ide-helper 2026-03-08 20:55:06 +03:00
eeffae6852 Item: add missing localization check 2026-03-06 20:10:04 +03:00
fe3298d112 Change regular & mono fonts on Philosopher 2026-03-06 19:03:45 +03:00
7d49bbf535 MapGen: add post-processing generation in biomes. Close #30 2026-03-05 21:46:28 +03:00
efcbc909e0 CraftSystem: save counter in ModStorage. Close #32 2026-03-05 20:11:32 +03:00
17413df9c4 storages: create storages mod, move case wood -> storages, create draft chest 2026-03-05 19:47:27 +03:00
2eede05436 HelperLib: add regular & mono fonts - Stengazeta 2026-03-05 19:46:33 +03:00
b863c88838 wood: fix textures & add new wood - gi 2026-03-02 22:28:29 +03:00
692105abfa BaseUI: Clearing the context is now an optional parameter & edit /list command. close #33 2026-03-02 19:57:54 +03:00
1a6086190e wood: improved textures, adding stripped wood 2026-03-01 22:20:14 +03:00
e20c3b4ef4 rocks: add sylite pillars 2026-03-01 22:19:00 +03:00
8b55ccff72 adminCommands: update /list command 2026-02-27 21:55:34 +03:00
c7cfe26335 Tool: create tool class 2026-02-27 20:57:54 +03:00
51e6763457 HelperLib: add require methods 2026-02-27 20:34:37 +03:00
c47ab6ac3c soils: update textures 2026-02-27 20:23:35 +03:00
6fd8295500 Item: minor fixes & set default stack is 128 2026-02-27 20:23:15 +03:00
b12f890740 adminCommands: minor fixes & test shaders 2026-02-27 20:22:19 +03:00
4c90041c68 Add essences (rofl) 2026-02-27 20:21:26 +03:00
b50d642bcf Trees update 2026-02-24 21:48:42 +03:00
e0b9024458 Add leafs & fix list command 2026-02-22 22:01:22 +03:00
745eaa8569 CraftSystem: TappingStage can now require a tool with a specific group for crafting 2026-02-20 22:18:25 +03:00
b6051e5724 WorkStation add TODO 2026-02-20 22:01:53 +03:00
5c936025f1 Add craft abort support & fixes visual tappingCraftNode 2026-02-20 21:46:45 +03:00
Van
5be847bf58 Merge pull request 'CraftSystem: first working version' (#31) from craft-system into main 2026-02-18 22:30:38 +03:00
184 changed files with 16030 additions and 11743 deletions

View File

@@ -32,7 +32,8 @@
"vector", "vector",
"Ensure", "Ensure",
"string", "string",
"string_utf8" "string_utf8",
"Profiler"
], ],
"globalsRegex": [] "globalsRegex": []
}, },

View File

@@ -1,7 +1,8 @@
Source code licensing: # Source code licensing
The MIT License (MIT) **The MIT License (MIT)**
Copyright (c) 2025 Apancore.Studio, Doloment
Copyright (c) 2025-2026 Apancore.Studio, Van (varttist), Doloment
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
@@ -11,9 +12,13 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
------------------------ ------------------------
Sprites licensing: # Sprites licensing
CC BY 4.0 **CC BY 4.0**
Copyright (c) 2025 Apancore.Studio, Doloment and others (see list below)
Copyright (c) 2025-2026 Apancore.Studio, Van (varttist) and others (see list below)
All textures except those listed here are copyrighted by Van (varttist) and are distributed under the CC BY 4.0.
List of all textures and authors: List of all textures and authors:
- ...

View File

@@ -1,218 +0,0 @@
MapGen.PastCalcNoiseValue *MapGen.PastCalcNoiseValue*
Type: ~
MapGen *MapGen*
Fields: ~
{layersByName} (table<string,MapGen.Layer>)
{layersList} (MapGen.Layer[])
{staticsByName} (table<string,MapGen.StaticLayer>)
{staticsList} (MapGen.StaticLayer[])
{layersNoisesInitialized} (boolean) Is the fractal noise of the layer initialized? This is necessary for a one-time noise initialization.
{cavernsNoiseInitialized} (boolean) Is the fractal noise of the caverns initialized? This is necessary for a one-time noise initialization.
{isRunning} (boolean) A static field that guarantees that only one instance of the `MapGen` class will work.
{nodeIDs} (table<string,number>)
MapGenDef *MapGenDef*
Definition table for the `MapGen`.
**Only for EmmyLua.**
Fields: ~
{nodes} (table<string,string>)
MapGen:new({def}) *MapGen:new*
Parameters: ~
{def} (MapGenDef)
Returns: ~
(MapGen)
MapGen:getLayerByHeight({yPos}) *MapGen:getLayerByHeight*
Determines which layer a node belongs to based on its height coordinate.
Parameters: ~
{yPos} (number) @return MapGen.Layer?
MapGen:getStaticByHeight({yPos}) *MapGen:getStaticByHeight*
Determines which statics layer a node belongs to based on its height coordinate.
Parameters: ~
{yPos} (number) @return MapGen.StaticLayer?
MapGen:registerLayer({name}, {def}) *MapGen:registerLayer*
Mark the world area between two heights as a `MapGen.Layer`.
Note: layers must not overlap.
Parameters: ~
{name} (string) The name that will be assigned to the layer. The name must be unique for each layer.
{def} (MapGen.LayerDef) Layer description table, see details `MapGen.LayerDef`.
*MapGen:registerLayerNoiseColor*
MapGen:registerLayerNoiseColor({layerName}, {category}, {color}, {noiseParams})
Register the color and the noise parameters that correspond to it.
Parameters: ~
{layerName} (string) The name of the layer for which the color will be registered.
{category} (MapGen.Layer.Category) Category indicating what will be generated by noise.
{color} (ColorString) Noise color. Must be unique.
{noiseParams} (NoiseParams) Fractal noise parameters.
*MapGen:registerStaticLayer*
MapGen:registerStaticLayer({name}, {def})
Mark the world area between two heights as a `MapGen.StaticLayer`.
Note: layers must not overlap.
Parameters: ~
{name} (string) The name that will be assigned to the static layer. The name must be unique for each layer.
{def} (MapGen.StaticLayerDef) Static layer description table, see details `MapGen.StaticLayerDef`.
*MapGen:registerPeak*
MapGen:registerPeak({layerName}, {category}, {def})
Mark a world point as `MapGen.Peak` and assign it a specific color that will affect the generation.
Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.
Parameters: ~
{layerName} (string) The name of the layer in which the new peak will be included.
{category} (MapGen.Layer.Category) Category indicating what will be generated by peak.
{def} (MapGen.PeakDef) Peak description table, see details `MapGen.PeakDef`.
*MapGen:register2DPeak*
MapGen:register2DPeak({layerName}, {category}, {def})
Mark a world point as `MapGen.Peak` and assign it a specific color that will affect the generation.
The Y coordinate will be forced to zero, and the `is2d` group will be added to the groups field.
Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.
Parameters: ~
{layerName} (string) The name of the layer in which the new peak will be included.
{category} (MapGen.Layer.Category) Category indicating what will be generated by peak.
{def} (MapGen.PeakDef) Peak description table, see details `MapGen.PeakDef`.
*MapGen:register2DPeaks*
MapGen:register2DPeaks({layerName}, {category}, {defs})
Mark the world points as `MapGen.Peak` and assign them all a specific noise that will affect generation.
The Y coordinate will be forced to zero, and the `is2d` group will be added to the groups field.
Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.
Parameters: ~
{layerName} (string) The name of the layer in which the new peaks will be included.
{category} (MapGen.Layer.Category) Category indicating what will be generated by peaks.
{defs} (MapGen.PeakDef[]) Peaks description table, see details `MapGen.PeakDef`.
*MapGen:register2DPeaksFromFile*
MapGen:register2DPeaksFromFile({layerName}, {map}, {scale}, {zeroPos}, {category}, {groups?})
Extract the `MapGen.Peak` from the image and assign them all a specific color that will affect the generation.
Parameters: ~
{layerName} (string) The name of the layer in which the new peaks will be included.
{map} (string) The name of the image from which the peaks will be extracted. It should be located in the `<mod_name>/textures/maps` folder and have the following format `<image_name>.ff`
{scale} (number) Multiplier of how many blocks (nodes) will be between image pixels. It is not recommended to set the value below 50 for performance reasons.
{zeroPos} (Position2d) The position in pixels where the zero world coordinate will be in the image.
{category} (MapGen.Layer.Category) Category indicating what will be generated by peaks.
{groups?} (table<string,number>) Groups that will be added to all peaks.
*MapGen:registerBiome*
MapGen:registerBiome({layerName}, {biomeName}, {def})
Mark a point on the biomes diagram and constrain the world area by height to mark it as `MapGen.Biome`.
Parameters: ~
{layerName} (string) The name of the layer in which the new biome will be included.
{biomeName} (string) The name to be assigned to the biome. The name must be unique for each biome.
{def} (MapGen.BiomeDef) Biome description table, see details `MapGen.BiomeDef`
*MapGen:registerCavern*
MapGen:registerCavern({layerName}, {cavernName}, {def})
Mark the world area between two heights as a `MapGen.Cavern` and assign the noise that the cave will be generated from.
Parameters: ~
{layerName} (string) The name of the layer in which the new cavern will be included.
{cavernName} (string) The name to be assigned to the cavern. The name must be unique for each cavern.
{def} (MapGen.CavernDef) Cavern description table, see details `MapGen.CavernDef`
MapGen:initLayersTriangultaion() *MapGen:initLayersTriangultaion*
Divide all layers into triangles whose vertices are the `Mapgen.Peak` belonging to these layers.
MapGen:initLayersNoises() *MapGen:initLayersNoises*
Initialize all layer noises. This should be called after the map object is loaded.
MapGen:initBiomesDiagram() *MapGen:initBiomesDiagram*
Initialization of the biome diagram using the Voronoi method.
MapGen:initCavernsNoise() *MapGen:initCavernsNoise*
Initialize caverns's noises. This should be called after the map object is loaded.
*MapGen:getNoises2dValue*
MapGen:getNoises2dValue({category}, {layer}, {x}, {y}, {z})
Calculates a smoothed 2D noise value based on a preliminary space partitioning.
Returns `nil` if the point is not included in any triangle.
Parameters: ~
{category} (MapGen.Layer.Category)
{layer} (MapGen.Layer)
{x} (integer)
{y} (integer)
{z} (integer) @return number?
*MapGen:getNoises3dValues*
MapGen:getNoises3dValues({layer}, {x}, {y}, {z})
Calculates a smoothed 3D noise value based on a preliminary space partitioning.
Returns `nil` if the point is not included in any tetrahedron.
Parameters: ~
{layer} (MapGen.Layer)
{x} (number)
{y} (number)
{z} (number) @return number?
*MapGen:onMapGenerated*
MapGen:onMapGenerated({voxelManip}, {minPos}, {maxPos}, {blockseed})
Chunk generation handler.
Parameters: ~
{voxelManip} (VoxelManip)
{minPos} (Position)
{maxPos} (Position)
{blockseed} (number)
MapGen:run() *MapGen:run*
Run world generation through this mapgen object
Note: only one instance of a `MapGen` class can be running.
**FOR MAPGEN ENVIRONMENT ONLY**
vim:tw=78:ts=8:noet:ft=help:norl:

View File

@@ -1,54 +0,0 @@
# index
## Types
- [alias Category](types/MapGen.Layer.Category.md)
- [alias CircumCircleEnum](types/MapGen.Triangle.CircumCircleEnum.md)
- [alias ColoredDotsTable](types/ColoredDotsTable.md)
- [alias Neighbours](types/MapGen.Triangle.Neighbours.md)
- [alias PastCalcNoiseValue](types/MapGen.PastCalcNoiseValue.md)
- [alias generateFunc](types/generateFunc.md)
- [class Biome](types/MapGen.Biome.md)
- [class BiomeDef](types/MapGen.BiomeDef.md)
- [class Cavern](types/MapGen.Cavern.md)
- [class CavernDef](types/MapGen.CavernDef.md)
- [class Decoration](types/MapGen.Decoration.md)
- [class Edge](types/MapGen.Triangulation.Edge.md)
- [class FakePeak](types/MapGen.Triangulation.FakePeak.md)
- [class GroundNodes](types/MapGen.Biome.GroundNodes.md)
- [class GroundNodesIDs](types/MapGen.Biome.GroundNodesIDs.md)
- [class Layer](types/MapGen.Layer.md)
- [class LayerDef](types/MapGen.LayerDef.md)
- [class MapGen](types/MapGen.md)
- [class MapGenDef](types/MapGenDef.md)
- [class Peak](types/MapGen.Peak.md)
- [class PeakDef](types/MapGen.PeakDef.md)
- [class StaticLayer](types/MapGen.StaticLayer.md)
- [class StaticLayerDef](types/MapGen.StaticLayerDef.md)
- [class Tetrahedron](types/MapGen.Tetrahedron.md)
- [class Triangle](types/MapGen.Triangle.md)
- [class Triangulation](types/MapGen.Triangulation.md)
## Modules
- [MapGen](modules/MapGen.md)
- [MapGen.Biome](modules/MapGen.Biome.md)
- [MapGen.Biome.GroundNodes](modules/MapGen.Biome.GroundNodes.md)
- [MapGen.Biome.GroundNodesIds](modules/MapGen.Biome.GroundNodesIds.md)
- [MapGen.Cavern](modules/MapGen.Cavern.md)
- [MapGen.Decoration](modules/MapGen.Decoration.md)
- [MapGen.Layer](modules/MapGen.Layer.md)
- [MapGen.Peak](modules/MapGen.Peak.md)
- [MapGen.StaticLayer](modules/MapGen.StaticLayer.md)
- [MapGen.Tetrahedron](modules/MapGen.Tetrahedron.md)
- [MapGen.Triangle](modules/MapGen.Triangle.md)
- [MapGen.Triangulation](modules/MapGen.Triangulation.md)
- [MapGen.Triangulation.Edge](modules/MapGen.Triangulation.Edge.md)
- [MapGen.Triangulation.FakePeak](modules/MapGen.Triangulation.FakePeak.md)
- [MapGen.ff2luat](modules/MapGen.ff2luat.md)

View File

@@ -1,85 +0,0 @@
# global MapGen.Biome.GroundNodes
---
## fields
---
### GroundNodes.turf
---
```lua
GroundNodes.turf : string
```
The soil covering the surface of the biome
### GroundNodes.soil
---
```lua
GroundNodes.soil : string
```
The soil beneath the turf. The height of this layer depends on `Biome.soilHeight`
### GroundNodes.rock
---
```lua
GroundNodes.rock : string
```
The rock found beneath the soil of a biome.
### GroundNodes.bottom
---
```lua
GroundNodes.bottom : string
```
Covering the bottom of reservoirs.

View File

@@ -1,85 +0,0 @@
# global MapGen.Biome.GroundNodesIds
---
## fields
---
### GroundNodesIDs.turf
---
```lua
GroundNodesIDs.turf : number
```
The soil covering the surface of the biome
### GroundNodesIDs.soil
---
```lua
GroundNodesIDs.soil : number
```
The soil beneath the turf. The height of this layer depends on `Biome.soilHeight`
### GroundNodesIDs.rock
---
```lua
GroundNodesIDs.rock : number
```
The rock found beneath the soil of a biome.
### GroundNodesIDs.bottom
---
```lua
GroundNodesIDs.bottom : number
```
Covering the bottom of reservoirs.

View File

@@ -1,307 +0,0 @@
# global MapGen.Biome
---
## methods
---
### Biome.new
---
```lua
function Biome.new(
name: string,
def: MapGen.BiomeDef {
tempPoint = number,
humidityPoint = number,
minY = number,
maxY = number,
groundNodes = MapGen.Biome.GroundNodes,
soilHeight = number,
generateAir = generateFunc?,
generateCavernAir = generateFunc?,
generateWater = generateFunc?,
generateRock = generateFunc?,
generateTurf = generateFunc?,
generateSoil = generateFunc?,
generateBottom = generateFunc?,
}
) -> MapGen.Biome {
name = string,
tempPoint = number,
humidityPoint = number,
minY = number,
maxY = number,
groundNodes = MapGen.Biome.GroundNodes,
groundNodesIDs = MapGen.Biome.GroundNodesIDs,
soilHeight = number,
generateAir = generateFunc,
generateCavernAir = generateFunc,
generateWater = generateFunc,
generateRock = generateFunc,
generateTurf = generateFunc,
generateSoil = generateFunc,
generateBottom = generateFunc,
new = function,
}
```
## fields
---
### Biome.name
---
```lua
Biome.name : string
```
### Biome.tempPoint
---
```lua
Biome.tempPoint : number
```
### Biome.humidityPoint
---
```lua
Biome.humidityPoint : number
```
### Biome.minY
---
```lua
Biome.minY : number
```
### Biome.maxY
---
```lua
Biome.maxY : number
```
### Biome.groundNodes
---
```lua
Biome.groundNodes : MapGen.Biome.GroundNodes {
turf: string,
soil: string,
rock: string,
bottom: string,
}
```
### Biome.groundNodesIDs
---
```lua
Biome.groundNodesIDs : MapGen.Biome.GroundNodesIDs {
turf: number,
soil: number,
rock: number,
bottom: number,
}
```
### Biome.soilHeight
---
```lua
Biome.soilHeight : number
```
### Biome.generateAir
---
```lua
Biome.generateAir : generateFunc
```
### Biome.generateCavernAir
---
```lua
Biome.generateCavernAir : generateFunc
```
### Biome.generateWater
---
```lua
Biome.generateWater : generateFunc
```
### Biome.generateRock
---
```lua
Biome.generateRock : generateFunc
```
### Biome.generateTurf
---
```lua
Biome.generateTurf : generateFunc
```
### Biome.generateSoil
---
```lua
Biome.generateSoil : generateFunc
```
### Biome.generateBottom
---
```lua
Biome.generateBottom : generateFunc
```

View File

@@ -1,203 +0,0 @@
# global MapGen.Cavern
---
## methods
---
### Cavern.getNoise
---
```lua
function Cavern.getNoise()-> ValueNoise
```
### Cavern.initNoise
---
```lua
function Cavern.initNoise()-> nil
```
### Cavern.getGroups
---
```lua
function Cavern.getGroups()
-> table<string,number>
```
### Cavern.new
---
```lua
function Cavern.new(
name: string,
def: MapGen.CavernDef {
minY = number,
maxY = number,
noiseParams = NoiseParams,
smoothDistance = number,
threshold = number?,
groups = table<string,number>?,
}
) -> MapGen.Cavern {
name = string,
minY = number,
maxY = number,
smoothDistance = number,
threshold = number,
getNoise = function,
initNoise = function,
getGroups = function,
new = function,
isCavern = function,
}
```
### Cavern.isCavern
---
```lua
function Cavern.isCavern(
x: integer,
y: integer,
z: integer
) -> boolean
```
Returns `true` if there is a cavern at the specified coordinates.
## fields
---
### Cavern.name
---
```lua
Cavern.name : string
```
### Cavern.minY
---
```lua
Cavern.minY : number
```
### Cavern.maxY
---
```lua
Cavern.maxY : number
```
### Cavern.smoothDistance
---
```lua
Cavern.smoothDistance : number
```
### Cavern.threshold
---
```lua
Cavern.threshold : number
```

View File

@@ -1,36 +0,0 @@
# global MapGen.Decoration
---
## methods
---
### Decoration.new
---
```lua
function Decoration.new() -> MapGen.Decoration {
new = function,
}
```

View File

@@ -1,673 +0,0 @@
# global MapGen.Layer
---
## methods
---
### Layer.calcTemp
---
```lua
function Layer.calcTemp(
self: MapGen.Layer {
name = string,
minY = integer,
maxY = integer,
minTemp = integer,
maxTemp = integer,
minHumidity = integer,
maxHumidity = integer,
waterLevel = integer,
peaksList = { humidity: MapGen.Peak[], landscape: MapGen.Peak[], temp: MapGen.Peak[] },
noisesByColor = { humidity: table<ColorString,ValueNoise>, landscape: table<ColorString,ValueNoise>, temp: table<ColorString,ValueNoise> },
noisesParamsByColor = { humidity: table<ColorString,NoiseParams>, landscape: table<ColorString,NoiseParams>, temp: table<ColorString,NoiseParams> },
biomesByName = table<string,MapGen.Biome>,
biomesList = MapGen.Biome[],
biomesDiagram = table,
biomesGorizontalScattering = integer,
biomesVerticalScattering = integer,
cavernsByName = table<string,MapGen.Cavern>,
cavernsList = MapGen.Cavern[],
trianglesList = { humidity: MapGen.Triangle[], landscape: MapGen.Triangle[], temp: MapGen.Triangle[] },
tetrahedronsList = MapGen.Tetrahedron[],
calcTemp = function,
calcHumidity = function,
new = function,
addPeak = function,
addNoiseParamsColor = function,
getNoiseByColor = function,
addBiome = function,
addCavern = function,
initNoises = function,
initBiomesDiagram = function,
},
value: number,
height: number
)-> number
```
### Layer.calcHumidity
---
```lua
function Layer.calcHumidity(
self: MapGen.Layer {
name = string,
minY = integer,
maxY = integer,
minTemp = integer,
maxTemp = integer,
minHumidity = integer,
maxHumidity = integer,
waterLevel = integer,
peaksList = { humidity: MapGen.Peak[], landscape: MapGen.Peak[], temp: MapGen.Peak[] },
noisesByColor = { humidity: table<ColorString,ValueNoise>, landscape: table<ColorString,ValueNoise>, temp: table<ColorString,ValueNoise> },
noisesParamsByColor = { humidity: table<ColorString,NoiseParams>, landscape: table<ColorString,NoiseParams>, temp: table<ColorString,NoiseParams> },
biomesByName = table<string,MapGen.Biome>,
biomesList = MapGen.Biome[],
biomesDiagram = table,
biomesGorizontalScattering = integer,
biomesVerticalScattering = integer,
cavernsByName = table<string,MapGen.Cavern>,
cavernsList = MapGen.Cavern[],
trianglesList = { humidity: MapGen.Triangle[], landscape: MapGen.Triangle[], temp: MapGen.Triangle[] },
tetrahedronsList = MapGen.Tetrahedron[],
calcTemp = function,
calcHumidity = function,
new = function,
addPeak = function,
addNoiseParamsColor = function,
getNoiseByColor = function,
addBiome = function,
addCavern = function,
initNoises = function,
initBiomesDiagram = function,
},
value: number,
height: number
)-> number
```
### Layer.new
---
```lua
function Layer.new(
name: string,
def: MapGen.LayerDef {
minY = number,
maxY = number,
minTemp = number,
maxTemp = number,
minHumidity = number,
maxHumidity = number,
waterLevel = number?,
calcTemp = (fun(self: MapGen.Layer, value: number, height: number) -> number)?,
calcHumidity = (fun(self: MapGen.Layer, value: number, height: number) -> number)?,
biomesGorizontalScattering = number?,
biomesVerticalScattering = number?,
}
) -> MapGen.Layer {
name = string,
minY = integer,
maxY = integer,
minTemp = integer,
maxTemp = integer,
minHumidity = integer,
maxHumidity = integer,
waterLevel = integer,
peaksList = { humidity: MapGen.Peak[], landscape: MapGen.Peak[], temp: MapGen.Peak[] },
noisesByColor = { humidity: table<ColorString,ValueNoise>, landscape: table<ColorString,ValueNoise>, temp: table<ColorString,ValueNoise> },
noisesParamsByColor = { humidity: table<ColorString,NoiseParams>, landscape: table<ColorString,NoiseParams>, temp: table<ColorString,NoiseParams> },
biomesByName = table<string,MapGen.Biome>,
biomesList = MapGen.Biome[],
biomesDiagram = table,
biomesGorizontalScattering = integer,
biomesVerticalScattering = integer,
cavernsByName = table<string,MapGen.Cavern>,
cavernsList = MapGen.Cavern[],
trianglesList = { humidity: MapGen.Triangle[], landscape: MapGen.Triangle[], temp: MapGen.Triangle[] },
tetrahedronsList = MapGen.Tetrahedron[],
calcTemp = function,
calcHumidity = function,
new = function,
addPeak = function,
addNoiseParamsColor = function,
getNoiseByColor = function,
addBiome = function,
addCavern = function,
initNoises = function,
initBiomesDiagram = function,
}
```
### Layer.addPeak
---
```lua
function Layer.addPeak(
category: MapGen.Layer.Category,
peak: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> nil
```
Adds a peak to the `Layer.peaksList`
### Layer.addNoiseParamsColor
---
```lua
function Layer.addNoiseParamsColor(
category: MapGen.Layer.Category,
color: ColorString,
noiseParams: NoiseParams
) -> nil
```
Adds a NoiseParams color to the `Layer.noisesParamsByColor`
### Layer.getNoiseByColor
---
```lua
function Layer.getNoiseByColor(
category: MapGen.Layer.Category,
color: ColorString
) -> ValueNoise
```
Returns noise corresponding to a color.
### Layer.addBiome
---
```lua
function Layer.addBiome(
biomeName: string,
biome: MapGen.Biome {
name = string,
tempPoint = number,
humidityPoint = number,
minY = number,
maxY = number,
groundNodes = MapGen.Biome.GroundNodes,
groundNodesIDs = MapGen.Biome.GroundNodesIDs,
soilHeight = number,
generateAir = generateFunc,
generateCavernAir = generateFunc,
generateWater = generateFunc,
generateRock = generateFunc,
generateTurf = generateFunc,
generateSoil = generateFunc,
generateBottom = generateFunc,
new = function,
}
) -> nil
```
Adds a biome to the `Layer.biomesByName` & `Layer.biomesList`
### Layer.addCavern
---
```lua
function Layer.addCavern(
cavernName: string,
cavern: MapGen.Cavern {
name = string,
minY = number,
maxY = number,
smoothDistance = number,
threshold = number,
getNoise = function,
initNoise = function,
getGroups = function,
new = function,
isCavern = function,
}
) -> nil
```
Adds a cavern to the `Layer.cavernsByName` & `Layer.cavernsList`
### Layer.initNoises
---
```lua
function Layer.initNoises() -> nil
```
Initializes noise for generation.
Should only be called after the mapgen object has been loaded.
### Layer.initBiomesDiagram
---
```lua
function Layer.initBiomesDiagram() -> nil
```
Initialization of the biome diagram using the Voronoi method.
## fields
---
### Layer.name
---
```lua
Layer.name : string
```
### Layer.minY
---
```lua
Layer.minY : integer
```
### Layer.maxY
---
```lua
Layer.maxY : integer
```
### Layer.minTemp
---
```lua
Layer.minTemp : integer
```
### Layer.maxTemp
---
```lua
Layer.maxTemp : integer
```
### Layer.minHumidity
---
```lua
Layer.minHumidity : integer
```
### Layer.maxHumidity
---
```lua
Layer.maxHumidity : integer
```
### Layer.waterLevel
---
```lua
Layer.waterLevel : integer
```
### Layer.peaksList
---
```lua
Layer.peaksList : { humidity: MapGen.Peak[], landscape: MapGen.Peak[], temp: MapGen.Peak[] }
```
### Layer.noisesByColor
---
```lua
Layer.noisesByColor : { humidity: table<ColorString,ValueNoise>, landscape: table<ColorString,ValueNoise>, temp: table<ColorString,ValueNoise> }
```
### Layer.noisesParamsByColor
---
```lua
Layer.noisesParamsByColor : { humidity: table<ColorString,NoiseParams>, landscape: table<ColorString,NoiseParams>, temp: table<ColorString,NoiseParams> }
```
### Layer.biomesByName
---
```lua
Layer.biomesByName : table<string,MapGen.Biome>
```
### Layer.biomesList
---
```lua
Layer.biomesList : MapGen.Biome[]
```
### Layer.biomesDiagram
---
```lua
Layer.biomesDiagram : table
```
### Layer.biomesGorizontalScattering
---
```lua
Layer.biomesGorizontalScattering : integer
```
### Layer.biomesVerticalScattering
---
```lua
Layer.biomesVerticalScattering : integer
```
### Layer.cavernsByName
---
```lua
Layer.cavernsByName : table<string,MapGen.Cavern>
```
### Layer.cavernsList
---
```lua
Layer.cavernsList : MapGen.Cavern[]
```
### Layer.trianglesList
---
```lua
Layer.trianglesList : { humidity: MapGen.Triangle[], landscape: MapGen.Triangle[], temp: MapGen.Triangle[] }
```
### Layer.tetrahedronsList
---
```lua
Layer.tetrahedronsList : MapGen.Tetrahedron[]
```
**Not supported**

View File

@@ -1,157 +0,0 @@
# global MapGen.Peak
---
## methods
---
### Peak.getPeakPos
---
```lua
function Peak.getPeakPos(self)-> vector
```
### Peak.getColor
---
```lua
function Peak.getColor(self)-> ColorString
```
### Peak.getGroups
---
```lua
function Peak.getGroups(self)
-> table<string,number>
```
### Peak.new
---
```lua
function Peak.new(def: MapGen.PeakDef {
pos = vector,
color = ColorString,
groups = table<string,number>?,
}) -> MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
```
### Peak.toString
---
```lua
function Peak.toString() -> string
```
Returns a string describing the object in a readable form.
### Peak.eq
---
```lua
function Peak.eq(other: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}) -> boolean
```
Returns true if the peaks are equivalent.
## fields
---
### Peak.id
---
```lua
Peak.id : number
```

View File

@@ -1,144 +0,0 @@
# global MapGen.StaticLayer
---
## methods
---
### StaticLayer.new
---
```lua
function StaticLayer.new(
name: string,
def: MapGen.StaticLayerDef {
minY = number,
maxY = number,
staticNode = string,
generateStaticNode = generateFunc,
}
) -> MapGen.StaticLayer {
name = string,
minY = number,
maxY = number,
staticNode = string,
staticNodeID = number,
generateStaticNode = generateFunc,
new = function,
}
```
## fields
---
### StaticLayer.name
---
```lua
StaticLayer.name : string
```
### StaticLayer.minY
---
```lua
StaticLayer.minY : number
```
### StaticLayer.maxY
---
```lua
StaticLayer.maxY : number
```
### StaticLayer.staticNode
---
```lua
StaticLayer.staticNode : string
```
### StaticLayer.staticNodeID
---
```lua
StaticLayer.staticNodeID : number
```
### StaticLayer.generateStaticNode
---
```lua
StaticLayer.generateStaticNode : generateFunc
```

View File

@@ -1,536 +0,0 @@
# global MapGen.Tetrahedron
---
## methods
---
### Tetrahedron.new
---
```lua
function Tetrahedron.new(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p3: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p4: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Tetrahedron {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
p3 = MapGen.Peak,
p4 = MapGen.Peak,
h1 = MapGen.Triangulation.Edge,
h2 = MapGen.Triangulation.Edge,
h3 = MapGen.Triangulation.Edge,
h4 = MapGen.Triangulation.Edge,
f1 = MapGen.Triangle,
f2 = MapGen.Triangle,
f3 = MapGen.Triangle,
f4 = MapGen.Triangle,
new = function,
toString = function,
getHeight = function,
getCircumSphereCenter = function,
getCircumSphereRadius = function,
inCircumSphere = function,
}
```
### Tetrahedron.toString
---
```lua
function Tetrahedron.toString() -> string
```
Returns a string describing the object in a readable form.
### Tetrahedron.getHeight
---
```lua
function Tetrahedron.getHeight(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p3: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p4: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Triangulation.Edge?
```
### Tetrahedron.getCircumSphereCenter
---
```lua
function Tetrahedron.getCircumSphereCenter() -> vector
```
Returns the center of the circumscribed sphere.
### Tetrahedron.getCircumSphereRadius
---
```lua
function Tetrahedron.getCircumSphereRadius() -> number
```
Returns the radius of the circumscribed sphere.
### Tetrahedron.inCircumSphere
---
```lua
function Tetrahedron.inCircumSphere(p: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}) -> boolean
```
Checks whether a given point lies within the circumscribed sphere of a tetrahedron.
## fields
---
### Tetrahedron.p1
---
```lua
Tetrahedron.p1 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Tetrahedron.p2
---
```lua
Tetrahedron.p2 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Tetrahedron.p3
---
```lua
Tetrahedron.p3 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Tetrahedron.p4
---
```lua
Tetrahedron.p4 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Tetrahedron.h1
---
```lua
Tetrahedron.h1 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Tetrahedron.h2
---
```lua
Tetrahedron.h2 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Tetrahedron.h3
---
```lua
Tetrahedron.h3 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Tetrahedron.h4
---
```lua
Tetrahedron.h4 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Tetrahedron.f1
---
```lua
Tetrahedron.f1 : MapGen.Triangle {
p1: MapGen.Peak,
p2: MapGen.Peak,
p3: MapGen.Peak,
e1: MapGen.Triangulation.Edge,
e2: MapGen.Triangulation.Edge,
e3: MapGen.Triangulation.Edge,
h1: MapGen.Triangulation.Edge,
h2: MapGen.Triangulation.Edge,
h3: MapGen.Triangulation.Edge,
neighbours: MapGen.Triangle.Neighbours,
color: ColorString?,
new: function,
...(+13)
}
```
### Tetrahedron.f2
---
```lua
Tetrahedron.f2 : MapGen.Triangle {
p1: MapGen.Peak,
p2: MapGen.Peak,
p3: MapGen.Peak,
e1: MapGen.Triangulation.Edge,
e2: MapGen.Triangulation.Edge,
e3: MapGen.Triangulation.Edge,
h1: MapGen.Triangulation.Edge,
h2: MapGen.Triangulation.Edge,
h3: MapGen.Triangulation.Edge,
neighbours: MapGen.Triangle.Neighbours,
color: ColorString?,
new: function,
...(+13)
}
```
### Tetrahedron.f3
---
```lua
Tetrahedron.f3 : MapGen.Triangle {
p1: MapGen.Peak,
p2: MapGen.Peak,
p3: MapGen.Peak,
e1: MapGen.Triangulation.Edge,
e2: MapGen.Triangulation.Edge,
e3: MapGen.Triangulation.Edge,
h1: MapGen.Triangulation.Edge,
h2: MapGen.Triangulation.Edge,
h3: MapGen.Triangulation.Edge,
neighbours: MapGen.Triangle.Neighbours,
color: ColorString?,
new: function,
...(+13)
}
```
### Tetrahedron.f4
---
```lua
Tetrahedron.f4 : MapGen.Triangle {
p1: MapGen.Peak,
p2: MapGen.Peak,
p3: MapGen.Peak,
e1: MapGen.Triangulation.Edge,
e2: MapGen.Triangulation.Edge,
e3: MapGen.Triangulation.Edge,
h1: MapGen.Triangulation.Edge,
h2: MapGen.Triangulation.Edge,
h3: MapGen.Triangulation.Edge,
neighbours: MapGen.Triangle.Neighbours,
color: ColorString?,
new: function,
...(+13)
}
```

View File

@@ -1,745 +0,0 @@
# global MapGen.Triangle
---
## methods
---
### Triangle.new
---
```lua
function Triangle.new(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p3: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Triangle {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
p3 = MapGen.Peak,
e1 = MapGen.Triangulation.Edge,
e2 = MapGen.Triangulation.Edge,
e3 = MapGen.Triangulation.Edge,
h1 = MapGen.Triangulation.Edge,
h2 = MapGen.Triangulation.Edge,
h3 = MapGen.Triangulation.Edge,
neighbours = MapGen.Triangle.Neighbours,
color = ColorString?,
new = function,
toString = function,
eq = function,
same = function,
getCenter = function,
getArea = function,
getHeight = function,
getHeight2D = function,
getSidesLength = function,
getSidesLength2D = function,
getCircumCenter2D = function,
getCircumRadius2D = function,
getCircumCircle2D = function,
inCircumCircle2D = function,
}
```
### Triangle.toString
---
```lua
function Triangle.toString() -> string
```
Returns a string describing the object in a readable form.
### Triangle.eq
---
```lua
function Triangle.eq(other: MapGen.Triangle {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
p3 = MapGen.Peak,
e1 = MapGen.Triangulation.Edge,
e2 = MapGen.Triangulation.Edge,
e3 = MapGen.Triangulation.Edge,
h1 = MapGen.Triangulation.Edge,
h2 = MapGen.Triangulation.Edge,
h3 = MapGen.Triangulation.Edge,
neighbours = MapGen.Triangle.Neighbours,
color = ColorString?,
new = function,
toString = function,
eq = function,
same = function,
getCenter = function,
getArea = function,
getHeight = function,
getHeight2D = function,
getSidesLength = function,
getSidesLength2D = function,
getCircumCenter2D = function,
getCircumRadius2D = function,
getCircumCircle2D = function,
inCircumCircle2D = function,
}) -> boolean
```
Returns true if the triangles are equivalent.
### Triangle.same
---
```lua
function Triangle.same(other: MapGen.Triangle {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
p3 = MapGen.Peak,
e1 = MapGen.Triangulation.Edge,
e2 = MapGen.Triangulation.Edge,
e3 = MapGen.Triangulation.Edge,
h1 = MapGen.Triangulation.Edge,
h2 = MapGen.Triangulation.Edge,
h3 = MapGen.Triangulation.Edge,
neighbours = MapGen.Triangle.Neighbours,
color = ColorString?,
new = function,
toString = function,
eq = function,
same = function,
getCenter = function,
getArea = function,
getHeight = function,
getHeight2D = function,
getSidesLength = function,
getSidesLength2D = function,
getCircumCenter2D = function,
getCircumRadius2D = function,
getCircumCircle2D = function,
inCircumCircle2D = function,
}) -> boolean
```
Returns true if the triangles are similar.
### Triangle.getCenter
---
```lua
function Triangle.getCenter() -> vector
```
Returns the coordinates of the triangle's center.
### Triangle.getArea
---
```lua
function Triangle.getArea() -> number
```
Returns the area of a triangle.
### Triangle.getHeight
---
```lua
function Triangle.getHeight(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p3: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Triangulation.Edge {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
new = function,
toString = function,
eq = function,
same = function,
length = function,
getMidPoint = function,
}
```
Returns the perpendicular from the vertex Peak1 to the line Peak2-Peak3.
### Triangle.getHeight2D
---
```lua
function Triangle.getHeight2D(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p3: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Triangulation.Edge {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
new = function,
toString = function,
eq = function,
same = function,
length = function,
getMidPoint = function,
}
```
Returns the perpendicular from the vertex Peak1 to the line Peak2-Peak3.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
### Triangle.getSidesLength
---
```lua
function Triangle.getSidesLength()
-> number
-> number
-> number
```
Returns the length of the edges
### Triangle.getSidesLength2D
---
```lua
function Triangle.getSidesLength2D()
-> number
-> number
-> number
```
Returns the length of the edges.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
### Triangle.getCircumCenter2D
---
```lua
function Triangle.getCircumCenter2D() -> vector
```
Returns the coordinates of the circumcircle center.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
### Triangle.getCircumRadius2D
---
```lua
function Triangle.getCircumRadius2D() -> number
```
Returns the radius of the circumcircle.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
### Triangle.getCircumCircle2D
---
```lua
function Triangle.getCircumCircle2D()
-> vector
-> number
```
Returns the coordinates of the circumcircle center and its radius.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
### Triangle.inCircumCircle2D
---
```lua
function Triangle.inCircumCircle2D(p: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}) -> boolean
```
Checks if a given point lies into the triangle circumcircle.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
## fields
---
### Triangle.p1
---
```lua
Triangle.p1 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Triangle.p2
---
```lua
Triangle.p2 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Triangle.p3
---
```lua
Triangle.p3 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Triangle.e1
---
```lua
Triangle.e1 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.e2
---
```lua
Triangle.e2 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.e3
---
```lua
Triangle.e3 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.h1
---
```lua
Triangle.h1 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.h2
---
```lua
Triangle.h2 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.h3
---
```lua
Triangle.h3 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.neighbours
---
```lua
Triangle.neighbours : MapGen.Triangle.Neighbours
```
### Triangle.color
---
```lua
Triangle.color : ColorString?
```

View File

@@ -1,225 +0,0 @@
# global MapGen.Triangulation.Edge
---
## methods
---
### Edge.new
---
```lua
function Edge.new(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Triangulation.Edge {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
new = function,
toString = function,
eq = function,
same = function,
length = function,
getMidPoint = function,
}
```
### Edge.toString
---
```lua
function Edge.toString() -> string
```
Returns a string describing the object in a readable form.
### Edge.eq
---
```lua
function Edge.eq(other: MapGen.Triangulation.Edge {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
new = function,
toString = function,
eq = function,
same = function,
length = function,
getMidPoint = function,
}) -> boolean
```
Returns true if the edges are equivalent.
### Edge.same
---
```lua
function Edge.same(other: MapGen.Triangulation.Edge {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
new = function,
toString = function,
eq = function,
same = function,
length = function,
getMidPoint = function,
}) -> boolean
```
Returns true if the edges are similar.
### Edge.length
---
```lua
function Edge.length() -> number
```
Returns the length of an edge.
### Edge.getMidPoint
---
```lua
function Edge.getMidPoint() -> vector
```
Returns the vector of the point located in the middle of the edge.
## fields
---
### Edge.p1
---
```lua
Edge.p1 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Edge.p2
---
```lua
Edge.p2 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```

View File

@@ -1,79 +0,0 @@
# global MapGen.Triangulation.FakePeak
---
## methods
---
### FakePeak.getPeakPos
---
```lua
function FakePeak.getPeakPos()-> vector
```
### FakePeak.new
---
```lua
function FakePeak.new(peakPos: vector) -> MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
```
Returns a fake `MapGen.Peak` that has no noise parameters.
Note that the initialized peak should not be used in generation.
## fields
---
### FakePeak.id
---
```lua
FakePeak.id : number
```

View File

@@ -1,81 +0,0 @@
# global MapGen.Triangulation
---
## methods
---
### Triangulation.triangulate
---
```lua
function Triangulation.triangulate(vertices: table<integer,MapGen.Peak>) -> ((MapGen.Triangle)|MapGen.Triangle[])
```
The Delaunay method divides a plane into triangles based on a list of their vertices.
Doesn't take into account the Y coordinate of the vertices.
That is, all triangles that don't lie in the XZ plane will be projected onto it.
Vertices that do not have a `is2d` group will not participate in the triangulation.
### Triangulation.tetrahedralize
---
```lua
function Triangulation.tetrahedralize(vertices: table<integer,MapGen.Peak>) -> ((MapGen.Tetrahedron)|MapGen.Tetrahedron[])
```
The Delaunay method divides space into tetrahedra based on a list of their vertices.
Vertices that do not have a `is3d` group will not participate in the triangulation.
## fields
---
### Triangulation.convexMultiplier
---
```lua
Triangulation.convexMultiplier : number
```

View File

@@ -1,30 +0,0 @@
# global MapGen.ff2luat
Converts given farbfeld image to ColoredDotsTable.
Farbfeld format:
```
╔════════╤═════════════════════════════════════════════════════════╗
║ Bytes │ Description ║
╠════════╪═════════════════════════════════════════════════════════╣
║ 8 │ 'farbfeld' magic value ║
╟────────┼─────────────────────────────────────────────────────────╢
║ 4 │ 32-Bit BE unsigned integer (width) ║
╟────────┼─────────────────────────────────────────────────────────╢
║ 4 │ 32-Bit BE unsigned integer (height) ║
╟────────┼─────────────────────────────────────────────────────────╢
║ [2222] │ 4x16-Bit BE unsigned integers [RGBA] / pixel, row-major ║
╚════════╧═════════════════════════════════════════════════════════╝
```
[tools/farbfeld | suckless.org software that sucks less](https://tools.suckless.org/farbfeld/)
---

View File

@@ -1,738 +0,0 @@
# global MapGen
---
## methods
---
### MapGen.new
---
```lua
function MapGen.new(def: MapGenDef {
nodes = table<string,string>,
}) -> MapGen {
layersByName = table<string,MapGen.Layer>,
layersList = MapGen.Layer[],
staticsByName = table<string,MapGen.StaticLayer>,
staticsList = MapGen.StaticLayer[],
layersNoisesInitialized = boolean,
cavernsNoiseInitialized = boolean,
isRunning = boolean,
nodeIDs = table<string,number>,
new = function,
getLayerByHeight = function,
getStaticByHeight = function,
registerLayer = function,
registerLayerNoiseColor = function,
registerStaticLayer = function,
registerPeak = function,
register2DPeak = function,
register2DPeaks = function,
register2DPeaksFromFile = function,
registerBiome = function,
registerCavern = function,
initLayersTriangultaion = function,
initLayersNoises = function,
initBiomesDiagram = function,
initCavernsNoise = function,
getNoises2dValue = function,
onMapGenerated = function,
run = function,
}
```
### MapGen.getLayerByHeight
---
```lua
function MapGen.getLayerByHeight(yPos: number) -> MapGen.Layer?
```
Determines which layer a node belongs to based on its height coordinate.
### MapGen.getStaticByHeight
---
```lua
function MapGen.getStaticByHeight(yPos: number) -> MapGen.StaticLayer?
```
Determines which statics layer a node belongs to based on its height coordinate.
### MapGen.registerLayer
---
```lua
function MapGen.registerLayer(
name: string,
def: MapGen.LayerDef {
minY = number,
maxY = number,
minTemp = number,
maxTemp = number,
minHumidity = number,
maxHumidity = number,
waterLevel = number?,
calcTemp = (fun(self: MapGen.Layer, value: number, height: number) -> number)?,
calcHumidity = (fun(self: MapGen.Layer, value: number, height: number) -> number)?,
biomesGorizontalScattering = number?,
biomesVerticalScattering = number?,
}
) -> nil
```
@param `name` - The name that will be assigned to the layer. The name must be unique for each layer.
@param `def` - Layer description table, see details `MapGen.LayerDef`.
Mark the world area between two heights as a `MapGen.Layer`.
Note: layers must not overlap.
### MapGen.registerLayerNoiseColor
---
```lua
function MapGen.registerLayerNoiseColor(
layerName: string,
category: MapGen.Layer.Category,
color: ColorString,
noiseParams: NoiseParams
) -> nil
```
@param `layerName` - The name of the layer for which the color will be registered.
@param `category` - Category indicating what will be generated by noise.
@param `color` - Noise color. Must be unique.
@param `noiseParams` - Fractal noise parameters.
Register the color and the noise parameters that correspond to it.
### MapGen.registerStaticLayer
---
```lua
function MapGen.registerStaticLayer(
name: string,
def: MapGen.StaticLayerDef {
minY = number,
maxY = number,
staticNode = string,
generateStaticNode = generateFunc,
}
) -> nil
```
@param `name` - The name that will be assigned to the static layer. The name must be unique for each layer.
@param `def` - Static layer description table, see details `MapGen.StaticLayerDef`.
Mark the world area between two heights as a `MapGen.StaticLayer`.
Note: layers must not overlap.
### MapGen.registerPeak
---
```lua
function MapGen.registerPeak(
layerName: string,
category: MapGen.Layer.Category,
def: MapGen.PeakDef {
pos = vector,
color = ColorString,
groups = table<string,number>?,
}
) -> nil
```
@param `layerName` - The name of the layer in which the new peak will be included.
@param `category` - Category indicating what will be generated by peak.
@param `def` - Peak description table, see details `MapGen.PeakDef`.
Mark a world point as `MapGen.Peak` and assign it a specific color that will affect the generation.
Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.
### MapGen.register2DPeak
---
```lua
function MapGen.register2DPeak(
layerName: string,
category: MapGen.Layer.Category,
def: MapGen.PeakDef {
pos = vector,
color = ColorString,
groups = table<string,number>?,
}
) -> nil
```
@param `layerName` - The name of the layer in which the new peak will be included.
@param `category` - Category indicating what will be generated by peak.
@param `def` - Peak description table, see details `MapGen.PeakDef`.
Mark a world point as `MapGen.Peak` and assign it a specific color that will affect the generation.
The Y coordinate will be forced to zero, and the `is2d` group will be added to the groups field.
Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.
### MapGen.register2DPeaks
---
```lua
function MapGen.register2DPeaks(
layerName: string,
category: MapGen.Layer.Category,
defs: MapGen.PeakDef[]
) -> nil
```
@param `layerName` - The name of the layer in which the new peaks will be included.
@param `category` - Category indicating what will be generated by peaks.
@param `defs` - Peaks description table, see details `MapGen.PeakDef`.
Mark the world points as `MapGen.Peak` and assign them all a specific noise that will affect generation.
The Y coordinate will be forced to zero, and the `is2d` group will be added to the groups field.
Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.
### MapGen.register2DPeaksFromFile
---
```lua
function MapGen.register2DPeaksFromFile(
layerName: string,
map: string,
scale: number,
zeroPos: Position2d,
category: MapGen.Layer.Category,
groups: table<string,number>?
) -> nil
```
@param `layerName` - The name of the layer in which the new peaks will be included.
@param `map` - The name of the image from which the peaks will be extracted. It should be located in the `<mod_name>/textures/maps` folder and have the following format `<image_name>.ff`
@param `scale` - Multiplier of how many blocks (nodes) will be between image pixels. It is not recommended to set the value below 50 for performance reasons.
@param `zeroPos` - The position in pixels where the zero world coordinate will be in the image.
@param `category` - Category indicating what will be generated by peaks.
@param `groups` - Groups that will be added to all peaks.
Extract the `MapGen.Peak` from the image and assign them all a specific color that will affect the generation.
### MapGen.registerBiome
---
```lua
function MapGen.registerBiome(
layerName: string,
biomeName: string,
def: MapGen.BiomeDef {
tempPoint = number,
humidityPoint = number,
minY = number,
maxY = number,
groundNodes = MapGen.Biome.GroundNodes,
soilHeight = number,
generateAir = generateFunc?,
generateCavernAir = generateFunc?,
generateWater = generateFunc?,
generateRock = generateFunc?,
generateTurf = generateFunc?,
generateSoil = generateFunc?,
generateBottom = generateFunc?,
}
) -> nil
```
@param `layerName` - The name of the layer in which the new biome will be included.
@param `biomeName` - The name to be assigned to the biome. The name must be unique for each biome.
@param `def` - Biome description table, see details `MapGen.BiomeDef`
Mark a point on the biomes diagram and constrain the world area by height to mark it as `MapGen.Biome`.
### MapGen.registerCavern
---
```lua
function MapGen.registerCavern(
layerName: string,
cavernName: string,
def: MapGen.CavernDef {
minY = number,
maxY = number,
noiseParams = NoiseParams,
smoothDistance = number,
threshold = number?,
groups = table<string,number>?,
}
) -> nil
```
@param `layerName` - The name of the layer in which the new cavern will be included.
@param `cavernName` - The name to be assigned to the cavern. The name must be unique for each cavern.
@param `def` - Cavern description table, see details `MapGen.CavernDef`
Mark the world area between two heights as a `MapGen.Cavern` and assign the noise that the cave will be generated from.
### MapGen.initLayersTriangultaion
---
```lua
function MapGen.initLayersTriangultaion() -> nil
```
Divide all layers into triangles whose vertices are the `Mapgen.Peak` belonging to these layers.
### MapGen.initLayersNoises
---
```lua
function MapGen.initLayersNoises() -> nil
```
Initialize all layer noises. This should be called after the map object is loaded.
### MapGen.initBiomesDiagram
---
```lua
function MapGen.initBiomesDiagram() -> nil
```
Initialization of the biome diagram using the Voronoi method.
### MapGen.initCavernsNoise
---
```lua
function MapGen.initCavernsNoise() -> nil
```
Initialize caverns's noises. This should be called after the map object is loaded.
### MapGen.getNoises2dValue
---
```lua
function MapGen.getNoises2dValue(
category: MapGen.Layer.Category,
layer: MapGen.Layer {
name = string,
minY = integer,
maxY = integer,
minTemp = integer,
maxTemp = integer,
minHumidity = integer,
maxHumidity = integer,
waterLevel = integer,
peaksList = { humidity: MapGen.Peak[], landscape: MapGen.Peak[], temp: MapGen.Peak[] },
noisesByColor = { humidity: table<ColorString,ValueNoise>, landscape: table<ColorString,ValueNoise>, temp: table<ColorString,ValueNoise> },
noisesParamsByColor = { humidity: table<ColorString,NoiseParams>, landscape: table<ColorString,NoiseParams>, temp: table<ColorString,NoiseParams> },
biomesByName = table<string,MapGen.Biome>,
biomesList = MapGen.Biome[],
biomesDiagram = table,
biomesGorizontalScattering = integer,
biomesVerticalScattering = integer,
cavernsByName = table<string,MapGen.Cavern>,
cavernsList = MapGen.Cavern[],
trianglesList = { humidity: MapGen.Triangle[], landscape: MapGen.Triangle[], temp: MapGen.Triangle[] },
tetrahedronsList = MapGen.Tetrahedron[],
calcTemp = function,
calcHumidity = function,
new = function,
addPeak = function,
addNoiseParamsColor = function,
getNoiseByColor = function,
addBiome = function,
addCavern = function,
initNoises = function,
initBiomesDiagram = function,
},
x: integer,
y: integer,
z: integer
) -> number?
```
Calculates a smoothed 2D noise value based on a preliminary space partitioning.
Returns `nil` if the point is not included in any triangle.
### MapGen.onMapGenerated
---
```lua
function MapGen.onMapGenerated(
voxelManip: VoxelManip,
minPos: Position,
maxPos: Position,
blockseed: number
) -> nil
```
Chunk generation handler.
### MapGen.run
---
```lua
function MapGen.run() -> nil
```
Run world generation through this mapgen object
Note: only one instance of a `MapGen` class can be running.
**FOR MAPGEN ENVIRONMENT ONLY**
## fields
---
### MapGen.layersByName
---
```lua
MapGen.layersByName : table<string,MapGen.Layer>
```
### MapGen.layersList
---
```lua
MapGen.layersList : MapGen.Layer[]
```
### MapGen.staticsByName
---
```lua
MapGen.staticsByName : table<string,MapGen.StaticLayer>
```
### MapGen.staticsList
---
```lua
MapGen.staticsList : MapGen.StaticLayer[]
```
### MapGen.layersNoisesInitialized
---
```lua
MapGen.layersNoisesInitialized : boolean
```
Is the fractal noise of the layer initialized? This is necessary for a one-time noise initialization.
### MapGen.cavernsNoiseInitialized
---
```lua
MapGen.cavernsNoiseInitialized : boolean
```
Is the fractal noise of the caverns initialized? This is necessary for a one-time noise initialization.
### MapGen.isRunning
---
```lua
MapGen.isRunning : boolean
```
A static field that guarantees that only one instance of the `MapGen` class will work.
### MapGen.nodeIDs
---
```lua
MapGen.nodeIDs : table<string,number>
```

View File

@@ -1,23 +0,0 @@
# alias ColoredDotsTable
---
```lua
(alias) ColoredDotsTable = table<string,table>
```
Table with color as key and value is table with coordinates of dots. Note: coords begin from 1,1 (not 0,0).
Example of table:
```lua
{
'size': { h=256, w=256 },
'#fff': { {x=1,y=1}, {x=2,y=2}, ... },
'#ff0': { {x=3,y=3}, {x=4,y=4}, ... },
...
}
```

View File

@@ -1,92 +0,0 @@
# class GroundNodes
- namespace: MapGen.Biome
**Only for EmmyLua.**
---
## fields
---
### GroundNodes.turf
---
```lua
GroundNodes.turf : string
```
The soil covering the surface of the biome
### GroundNodes.soil
---
```lua
GroundNodes.soil : string
```
The soil beneath the turf. The height of this layer depends on `Biome.soilHeight`
### GroundNodes.rock
---
```lua
GroundNodes.rock : string
```
The rock found beneath the soil of a biome.
### GroundNodes.bottom
---
```lua
GroundNodes.bottom : string
```
Covering the bottom of reservoirs.

View File

@@ -1,92 +0,0 @@
# class GroundNodesIDs
- namespace: MapGen.Biome
**Only for EmmyLua.**
---
## fields
---
### GroundNodesIDs.turf
---
```lua
GroundNodesIDs.turf : number
```
The soil covering the surface of the biome
### GroundNodesIDs.soil
---
```lua
GroundNodesIDs.soil : number
```
The soil beneath the turf. The height of this layer depends on `Biome.soilHeight`
### GroundNodesIDs.rock
---
```lua
GroundNodesIDs.rock : number
```
The rock found beneath the soil of a biome.
### GroundNodesIDs.bottom
---
```lua
GroundNodesIDs.bottom : number
```
Covering the bottom of reservoirs.

View File

@@ -1,312 +0,0 @@
# class Biome
- namespace: MapGen
---
## methods
---
### Biome.new
---
```lua
function Biome.new(
name: string,
def: MapGen.BiomeDef {
tempPoint = number,
humidityPoint = number,
minY = number,
maxY = number,
groundNodes = MapGen.Biome.GroundNodes,
soilHeight = number,
generateAir = generateFunc?,
generateCavernAir = generateFunc?,
generateWater = generateFunc?,
generateRock = generateFunc?,
generateTurf = generateFunc?,
generateSoil = generateFunc?,
generateBottom = generateFunc?,
}
) -> MapGen.Biome {
name = string,
tempPoint = number,
humidityPoint = number,
minY = number,
maxY = number,
groundNodes = MapGen.Biome.GroundNodes,
groundNodesIDs = MapGen.Biome.GroundNodesIDs,
soilHeight = number,
generateAir = generateFunc,
generateCavernAir = generateFunc,
generateWater = generateFunc,
generateRock = generateFunc,
generateTurf = generateFunc,
generateSoil = generateFunc,
generateBottom = generateFunc,
new = function,
}
```
## fields
---
### Biome.name
---
```lua
Biome.name : string
```
### Biome.tempPoint
---
```lua
Biome.tempPoint : number
```
### Biome.humidityPoint
---
```lua
Biome.humidityPoint : number
```
### Biome.minY
---
```lua
Biome.minY : number
```
### Biome.maxY
---
```lua
Biome.maxY : number
```
### Biome.groundNodes
---
```lua
Biome.groundNodes : MapGen.Biome.GroundNodes {
turf: string,
soil: string,
rock: string,
bottom: string,
}
```
### Biome.groundNodesIDs
---
```lua
Biome.groundNodesIDs : MapGen.Biome.GroundNodesIDs {
turf: number,
soil: number,
rock: number,
bottom: number,
}
```
### Biome.soilHeight
---
```lua
Biome.soilHeight : number
```
### Biome.generateAir
---
```lua
Biome.generateAir : generateFunc
```
### Biome.generateCavernAir
---
```lua
Biome.generateCavernAir : generateFunc
```
### Biome.generateWater
---
```lua
Biome.generateWater : generateFunc
```
### Biome.generateRock
---
```lua
Biome.generateRock : generateFunc
```
### Biome.generateTurf
---
```lua
Biome.generateTurf : generateFunc
```
### Biome.generateSoil
---
```lua
Biome.generateSoil : generateFunc
```
### Biome.generateBottom
---
```lua
Biome.generateBottom : generateFunc
```

View File

@@ -1,226 +0,0 @@
# class BiomeDef
- namespace: MapGen
Definition table for the `MapGen.Biome`.
**Only for EmmyLua.**
---
## fields
---
### BiomeDef.tempPoint
---
```lua
BiomeDef.tempPoint : number
```
### BiomeDef.humidityPoint
---
```lua
BiomeDef.humidityPoint : number
```
### BiomeDef.minY
---
```lua
BiomeDef.minY : number
```
### BiomeDef.maxY
---
```lua
BiomeDef.maxY : number
```
### BiomeDef.groundNodes
---
```lua
BiomeDef.groundNodes : MapGen.Biome.GroundNodes {
turf: string,
soil: string,
rock: string,
bottom: string,
}
```
### BiomeDef.soilHeight
---
```lua
BiomeDef.soilHeight : number
```
### BiomeDef.generateAir
---
```lua
BiomeDef.generateAir : generateFunc?
```
### BiomeDef.generateCavernAir
---
```lua
BiomeDef.generateCavernAir : generateFunc?
```
### BiomeDef.generateWater
---
```lua
BiomeDef.generateWater : generateFunc?
```
### BiomeDef.generateRock
---
```lua
BiomeDef.generateRock : generateFunc?
```
### BiomeDef.generateTurf
---
```lua
BiomeDef.generateTurf : generateFunc?
```
### BiomeDef.generateSoil
---
```lua
BiomeDef.generateSoil : generateFunc?
```
### BiomeDef.generateBottom
---
```lua
BiomeDef.generateBottom : generateFunc?
```

View File

@@ -1,208 +0,0 @@
# class Cavern
- namespace: MapGen
---
## methods
---
### Cavern.getNoise
---
```lua
function Cavern.getNoise()-> ValueNoise
```
### Cavern.initNoise
---
```lua
function Cavern.initNoise()-> nil
```
### Cavern.getGroups
---
```lua
function Cavern.getGroups()
-> table<string,number>
```
### Cavern.new
---
```lua
function Cavern.new(
name: string,
def: MapGen.CavernDef {
minY = number,
maxY = number,
noiseParams = NoiseParams,
smoothDistance = number,
threshold = number?,
groups = table<string,number>?,
}
) -> MapGen.Cavern {
name = string,
minY = number,
maxY = number,
smoothDistance = number,
threshold = number,
getNoise = function,
initNoise = function,
getGroups = function,
new = function,
isCavern = function,
}
```
### Cavern.isCavern
---
```lua
function Cavern.isCavern(
x: integer,
y: integer,
z: integer
) -> boolean
```
Returns `true` if there is a cavern at the specified coordinates.
## fields
---
### Cavern.name
---
```lua
Cavern.name : string
```
### Cavern.minY
---
```lua
Cavern.minY : number
```
### Cavern.maxY
---
```lua
Cavern.maxY : number
```
### Cavern.smoothDistance
---
```lua
Cavern.smoothDistance : number
```
### Cavern.threshold
---
```lua
Cavern.threshold : number
```

View File

@@ -1,116 +0,0 @@
# class CavernDef
- namespace: MapGen
Definition table for the `MapGen.Cavern`.
**Only for EmmyLua.**
---
## fields
---
### CavernDef.minY
---
```lua
CavernDef.minY : number
```
### CavernDef.maxY
---
```lua
CavernDef.maxY : number
```
### CavernDef.noiseParams
---
```lua
CavernDef.noiseParams : NoiseParams
```
### CavernDef.smoothDistance
---
```lua
CavernDef.smoothDistance : number
```
### CavernDef.threshold
---
```lua
CavernDef.threshold : number?
```
### CavernDef.groups
---
```lua
CavernDef.groups : table<string,number>?
```

View File

@@ -1,43 +0,0 @@
# class Decoration
- namespace: MapGen
**NOT IMPLEMENTED**
---
## methods
---
### Decoration.new
---
```lua
function Decoration.new() -> MapGen.Decoration {
new = function,
}
```

View File

@@ -1,16 +0,0 @@
# alias Category
---
- namespace: MapGen.Layer
```lua
(alias) Category = ("landscape"|"temp"|"humidity")
```
A category of noise that affects specific map generation objects.

View File

@@ -1,678 +0,0 @@
# class Layer
- namespace: MapGen
---
## methods
---
### Layer.calcTemp
---
```lua
function Layer.calcTemp(
self: MapGen.Layer {
name = string,
minY = integer,
maxY = integer,
minTemp = integer,
maxTemp = integer,
minHumidity = integer,
maxHumidity = integer,
waterLevel = integer,
peaksList = { humidity: MapGen.Peak[], landscape: MapGen.Peak[], temp: MapGen.Peak[] },
noisesByColor = { humidity: table<ColorString,ValueNoise>, landscape: table<ColorString,ValueNoise>, temp: table<ColorString,ValueNoise> },
noisesParamsByColor = { humidity: table<ColorString,NoiseParams>, landscape: table<ColorString,NoiseParams>, temp: table<ColorString,NoiseParams> },
biomesByName = table<string,MapGen.Biome>,
biomesList = MapGen.Biome[],
biomesDiagram = table,
biomesGorizontalScattering = integer,
biomesVerticalScattering = integer,
cavernsByName = table<string,MapGen.Cavern>,
cavernsList = MapGen.Cavern[],
trianglesList = { humidity: MapGen.Triangle[], landscape: MapGen.Triangle[], temp: MapGen.Triangle[] },
tetrahedronsList = MapGen.Tetrahedron[],
calcTemp = function,
calcHumidity = function,
new = function,
addPeak = function,
addNoiseParamsColor = function,
getNoiseByColor = function,
addBiome = function,
addCavern = function,
initNoises = function,
initBiomesDiagram = function,
},
value: number,
height: number
)-> number
```
### Layer.calcHumidity
---
```lua
function Layer.calcHumidity(
self: MapGen.Layer {
name = string,
minY = integer,
maxY = integer,
minTemp = integer,
maxTemp = integer,
minHumidity = integer,
maxHumidity = integer,
waterLevel = integer,
peaksList = { humidity: MapGen.Peak[], landscape: MapGen.Peak[], temp: MapGen.Peak[] },
noisesByColor = { humidity: table<ColorString,ValueNoise>, landscape: table<ColorString,ValueNoise>, temp: table<ColorString,ValueNoise> },
noisesParamsByColor = { humidity: table<ColorString,NoiseParams>, landscape: table<ColorString,NoiseParams>, temp: table<ColorString,NoiseParams> },
biomesByName = table<string,MapGen.Biome>,
biomesList = MapGen.Biome[],
biomesDiagram = table,
biomesGorizontalScattering = integer,
biomesVerticalScattering = integer,
cavernsByName = table<string,MapGen.Cavern>,
cavernsList = MapGen.Cavern[],
trianglesList = { humidity: MapGen.Triangle[], landscape: MapGen.Triangle[], temp: MapGen.Triangle[] },
tetrahedronsList = MapGen.Tetrahedron[],
calcTemp = function,
calcHumidity = function,
new = function,
addPeak = function,
addNoiseParamsColor = function,
getNoiseByColor = function,
addBiome = function,
addCavern = function,
initNoises = function,
initBiomesDiagram = function,
},
value: number,
height: number
)-> number
```
### Layer.new
---
```lua
function Layer.new(
name: string,
def: MapGen.LayerDef {
minY = number,
maxY = number,
minTemp = number,
maxTemp = number,
minHumidity = number,
maxHumidity = number,
waterLevel = number?,
calcTemp = (fun(self: MapGen.Layer, value: number, height: number) -> number)?,
calcHumidity = (fun(self: MapGen.Layer, value: number, height: number) -> number)?,
biomesGorizontalScattering = number?,
biomesVerticalScattering = number?,
}
) -> MapGen.Layer {
name = string,
minY = integer,
maxY = integer,
minTemp = integer,
maxTemp = integer,
minHumidity = integer,
maxHumidity = integer,
waterLevel = integer,
peaksList = { humidity: MapGen.Peak[], landscape: MapGen.Peak[], temp: MapGen.Peak[] },
noisesByColor = { humidity: table<ColorString,ValueNoise>, landscape: table<ColorString,ValueNoise>, temp: table<ColorString,ValueNoise> },
noisesParamsByColor = { humidity: table<ColorString,NoiseParams>, landscape: table<ColorString,NoiseParams>, temp: table<ColorString,NoiseParams> },
biomesByName = table<string,MapGen.Biome>,
biomesList = MapGen.Biome[],
biomesDiagram = table,
biomesGorizontalScattering = integer,
biomesVerticalScattering = integer,
cavernsByName = table<string,MapGen.Cavern>,
cavernsList = MapGen.Cavern[],
trianglesList = { humidity: MapGen.Triangle[], landscape: MapGen.Triangle[], temp: MapGen.Triangle[] },
tetrahedronsList = MapGen.Tetrahedron[],
calcTemp = function,
calcHumidity = function,
new = function,
addPeak = function,
addNoiseParamsColor = function,
getNoiseByColor = function,
addBiome = function,
addCavern = function,
initNoises = function,
initBiomesDiagram = function,
}
```
### Layer.addPeak
---
```lua
function Layer.addPeak(
category: MapGen.Layer.Category,
peak: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> nil
```
Adds a peak to the `Layer.peaksList`
### Layer.addNoiseParamsColor
---
```lua
function Layer.addNoiseParamsColor(
category: MapGen.Layer.Category,
color: ColorString,
noiseParams: NoiseParams
) -> nil
```
Adds a NoiseParams color to the `Layer.noisesParamsByColor`
### Layer.getNoiseByColor
---
```lua
function Layer.getNoiseByColor(
category: MapGen.Layer.Category,
color: ColorString
) -> ValueNoise
```
Returns noise corresponding to a color.
### Layer.addBiome
---
```lua
function Layer.addBiome(
biomeName: string,
biome: MapGen.Biome {
name = string,
tempPoint = number,
humidityPoint = number,
minY = number,
maxY = number,
groundNodes = MapGen.Biome.GroundNodes,
groundNodesIDs = MapGen.Biome.GroundNodesIDs,
soilHeight = number,
generateAir = generateFunc,
generateCavernAir = generateFunc,
generateWater = generateFunc,
generateRock = generateFunc,
generateTurf = generateFunc,
generateSoil = generateFunc,
generateBottom = generateFunc,
new = function,
}
) -> nil
```
Adds a biome to the `Layer.biomesByName` & `Layer.biomesList`
### Layer.addCavern
---
```lua
function Layer.addCavern(
cavernName: string,
cavern: MapGen.Cavern {
name = string,
minY = number,
maxY = number,
smoothDistance = number,
threshold = number,
getNoise = function,
initNoise = function,
getGroups = function,
new = function,
isCavern = function,
}
) -> nil
```
Adds a cavern to the `Layer.cavernsByName` & `Layer.cavernsList`
### Layer.initNoises
---
```lua
function Layer.initNoises() -> nil
```
Initializes noise for generation.
Should only be called after the mapgen object has been loaded.
### Layer.initBiomesDiagram
---
```lua
function Layer.initBiomesDiagram() -> nil
```
Initialization of the biome diagram using the Voronoi method.
## fields
---
### Layer.name
---
```lua
Layer.name : string
```
### Layer.minY
---
```lua
Layer.minY : integer
```
### Layer.maxY
---
```lua
Layer.maxY : integer
```
### Layer.minTemp
---
```lua
Layer.minTemp : integer
```
### Layer.maxTemp
---
```lua
Layer.maxTemp : integer
```
### Layer.minHumidity
---
```lua
Layer.minHumidity : integer
```
### Layer.maxHumidity
---
```lua
Layer.maxHumidity : integer
```
### Layer.waterLevel
---
```lua
Layer.waterLevel : integer
```
### Layer.peaksList
---
```lua
Layer.peaksList : { humidity: MapGen.Peak[], landscape: MapGen.Peak[], temp: MapGen.Peak[] }
```
### Layer.noisesByColor
---
```lua
Layer.noisesByColor : { humidity: table<ColorString,ValueNoise>, landscape: table<ColorString,ValueNoise>, temp: table<ColorString,ValueNoise> }
```
### Layer.noisesParamsByColor
---
```lua
Layer.noisesParamsByColor : { humidity: table<ColorString,NoiseParams>, landscape: table<ColorString,NoiseParams>, temp: table<ColorString,NoiseParams> }
```
### Layer.biomesByName
---
```lua
Layer.biomesByName : table<string,MapGen.Biome>
```
### Layer.biomesList
---
```lua
Layer.biomesList : MapGen.Biome[]
```
### Layer.biomesDiagram
---
```lua
Layer.biomesDiagram : table
```
### Layer.biomesGorizontalScattering
---
```lua
Layer.biomesGorizontalScattering : integer
```
### Layer.biomesVerticalScattering
---
```lua
Layer.biomesVerticalScattering : integer
```
### Layer.cavernsByName
---
```lua
Layer.cavernsByName : table<string,MapGen.Cavern>
```
### Layer.cavernsList
---
```lua
Layer.cavernsList : MapGen.Cavern[]
```
### Layer.trianglesList
---
```lua
Layer.trianglesList : { humidity: MapGen.Triangle[], landscape: MapGen.Triangle[], temp: MapGen.Triangle[] }
```
### Layer.tetrahedronsList
---
```lua
Layer.tetrahedronsList : MapGen.Tetrahedron[]
```
**Not supported**

View File

@@ -1,191 +0,0 @@
# class LayerDef
- namespace: MapGen
Definition table for the `MapGen.Layer`.
**Only for EmmyLua.**
---
## fields
---
### LayerDef.minY
---
```lua
LayerDef.minY : number
```
### LayerDef.maxY
---
```lua
LayerDef.maxY : number
```
### LayerDef.minTemp
---
```lua
LayerDef.minTemp : number
```
### LayerDef.maxTemp
---
```lua
LayerDef.maxTemp : number
```
### LayerDef.minHumidity
---
```lua
LayerDef.minHumidity : number
```
### LayerDef.maxHumidity
---
```lua
LayerDef.maxHumidity : number
```
### LayerDef.waterLevel
---
```lua
LayerDef.waterLevel : number?
```
### LayerDef.calcTemp
---
```lua
LayerDef.calcTemp : (fun(self: MapGen.Layer, value: number, height: number) -> number)?
```
### LayerDef.calcHumidity
---
```lua
LayerDef.calcHumidity : (fun(self: MapGen.Layer, value: number, height: number) -> number)?
```
### LayerDef.biomesGorizontalScattering
---
```lua
LayerDef.biomesGorizontalScattering : number?
```
### LayerDef.biomesVerticalScattering
---
```lua
LayerDef.biomesVerticalScattering : number?
```

View File

@@ -1,14 +0,0 @@
# alias PastCalcNoiseValue
---
- namespace: MapGen
```lua
(alias) PastCalcNoiseValue = { noiseValue: number?, triangle: MapGen.Triangle?, x: integer?, z: integer? }
```

View File

@@ -1,162 +0,0 @@
# class Peak
- namespace: MapGen
---
## methods
---
### Peak.getPeakPos
---
```lua
function Peak.getPeakPos(self)-> vector
```
### Peak.getColor
---
```lua
function Peak.getColor(self)-> ColorString
```
### Peak.getGroups
---
```lua
function Peak.getGroups(self)
-> table<string,number>
```
### Peak.new
---
```lua
function Peak.new(def: MapGen.PeakDef {
pos = vector,
color = ColorString,
groups = table<string,number>?,
}) -> MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
```
### Peak.toString
---
```lua
function Peak.toString() -> string
```
Returns a string describing the object in a readable form.
### Peak.eq
---
```lua
function Peak.eq(other: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}) -> boolean
```
Returns true if the peaks are equivalent.
## fields
---
### Peak.id
---
```lua
Peak.id : number
```

View File

@@ -1,71 +0,0 @@
# class PeakDef
- namespace: MapGen
Definition table for the `MapGen.Peak`.
**Only for EmmyLua.**
---
## fields
---
### PeakDef.pos
---
```lua
PeakDef.pos : vector
```
### PeakDef.color
---
```lua
PeakDef.color : ColorString
```
### PeakDef.groups
---
```lua
PeakDef.groups : table<string,number>?
```

View File

@@ -1,149 +0,0 @@
# class StaticLayer
- namespace: MapGen
---
## methods
---
### StaticLayer.new
---
```lua
function StaticLayer.new(
name: string,
def: MapGen.StaticLayerDef {
minY = number,
maxY = number,
staticNode = string,
generateStaticNode = generateFunc,
}
) -> MapGen.StaticLayer {
name = string,
minY = number,
maxY = number,
staticNode = string,
staticNodeID = number,
generateStaticNode = generateFunc,
new = function,
}
```
## fields
---
### StaticLayer.name
---
```lua
StaticLayer.name : string
```
### StaticLayer.minY
---
```lua
StaticLayer.minY : number
```
### StaticLayer.maxY
---
```lua
StaticLayer.maxY : number
```
### StaticLayer.staticNode
---
```lua
StaticLayer.staticNode : string
```
### StaticLayer.staticNodeID
---
```lua
StaticLayer.staticNodeID : number
```
### StaticLayer.generateStaticNode
---
```lua
StaticLayer.generateStaticNode : generateFunc
```

View File

@@ -1,86 +0,0 @@
# class StaticLayerDef
- namespace: MapGen
Definition table for the `MapGen.StaticLayer`.
**Only for EmmyLua.**
---
## fields
---
### StaticLayerDef.minY
---
```lua
StaticLayerDef.minY : number
```
### StaticLayerDef.maxY
---
```lua
StaticLayerDef.maxY : number
```
### StaticLayerDef.staticNode
---
```lua
StaticLayerDef.staticNode : string
```
### StaticLayerDef.generateStaticNode
---
```lua
StaticLayerDef.generateStaticNode : generateFunc
```

View File

@@ -1,541 +0,0 @@
# class Tetrahedron
- namespace: MapGen
---
## methods
---
### Tetrahedron.new
---
```lua
function Tetrahedron.new(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p3: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p4: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Tetrahedron {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
p3 = MapGen.Peak,
p4 = MapGen.Peak,
h1 = MapGen.Triangulation.Edge,
h2 = MapGen.Triangulation.Edge,
h3 = MapGen.Triangulation.Edge,
h4 = MapGen.Triangulation.Edge,
f1 = MapGen.Triangle,
f2 = MapGen.Triangle,
f3 = MapGen.Triangle,
f4 = MapGen.Triangle,
new = function,
toString = function,
getHeight = function,
getCircumSphereCenter = function,
getCircumSphereRadius = function,
inCircumSphere = function,
}
```
### Tetrahedron.toString
---
```lua
function Tetrahedron.toString() -> string
```
Returns a string describing the object in a readable form.
### Tetrahedron.getHeight
---
```lua
function Tetrahedron.getHeight(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p3: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p4: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Triangulation.Edge?
```
### Tetrahedron.getCircumSphereCenter
---
```lua
function Tetrahedron.getCircumSphereCenter() -> vector
```
Returns the center of the circumscribed sphere.
### Tetrahedron.getCircumSphereRadius
---
```lua
function Tetrahedron.getCircumSphereRadius() -> number
```
Returns the radius of the circumscribed sphere.
### Tetrahedron.inCircumSphere
---
```lua
function Tetrahedron.inCircumSphere(p: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}) -> boolean
```
Checks whether a given point lies within the circumscribed sphere of a tetrahedron.
## fields
---
### Tetrahedron.p1
---
```lua
Tetrahedron.p1 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Tetrahedron.p2
---
```lua
Tetrahedron.p2 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Tetrahedron.p3
---
```lua
Tetrahedron.p3 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Tetrahedron.p4
---
```lua
Tetrahedron.p4 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Tetrahedron.h1
---
```lua
Tetrahedron.h1 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Tetrahedron.h2
---
```lua
Tetrahedron.h2 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Tetrahedron.h3
---
```lua
Tetrahedron.h3 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Tetrahedron.h4
---
```lua
Tetrahedron.h4 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Tetrahedron.f1
---
```lua
Tetrahedron.f1 : MapGen.Triangle {
p1: MapGen.Peak,
p2: MapGen.Peak,
p3: MapGen.Peak,
e1: MapGen.Triangulation.Edge,
e2: MapGen.Triangulation.Edge,
e3: MapGen.Triangulation.Edge,
h1: MapGen.Triangulation.Edge,
h2: MapGen.Triangulation.Edge,
h3: MapGen.Triangulation.Edge,
neighbours: MapGen.Triangle.Neighbours,
color: ColorString?,
new: function,
...(+13)
}
```
### Tetrahedron.f2
---
```lua
Tetrahedron.f2 : MapGen.Triangle {
p1: MapGen.Peak,
p2: MapGen.Peak,
p3: MapGen.Peak,
e1: MapGen.Triangulation.Edge,
e2: MapGen.Triangulation.Edge,
e3: MapGen.Triangulation.Edge,
h1: MapGen.Triangulation.Edge,
h2: MapGen.Triangulation.Edge,
h3: MapGen.Triangulation.Edge,
neighbours: MapGen.Triangle.Neighbours,
color: ColorString?,
new: function,
...(+13)
}
```
### Tetrahedron.f3
---
```lua
Tetrahedron.f3 : MapGen.Triangle {
p1: MapGen.Peak,
p2: MapGen.Peak,
p3: MapGen.Peak,
e1: MapGen.Triangulation.Edge,
e2: MapGen.Triangulation.Edge,
e3: MapGen.Triangulation.Edge,
h1: MapGen.Triangulation.Edge,
h2: MapGen.Triangulation.Edge,
h3: MapGen.Triangulation.Edge,
neighbours: MapGen.Triangle.Neighbours,
color: ColorString?,
new: function,
...(+13)
}
```
### Tetrahedron.f4
---
```lua
Tetrahedron.f4 : MapGen.Triangle {
p1: MapGen.Peak,
p2: MapGen.Peak,
p3: MapGen.Peak,
e1: MapGen.Triangulation.Edge,
e2: MapGen.Triangulation.Edge,
e3: MapGen.Triangulation.Edge,
h1: MapGen.Triangulation.Edge,
h2: MapGen.Triangulation.Edge,
h3: MapGen.Triangulation.Edge,
neighbours: MapGen.Triangle.Neighbours,
color: ColorString?,
new: function,
...(+13)
}
```

View File

@@ -1,14 +0,0 @@
# alias CircumCircleEnum
---
- namespace: MapGen.Triangle
```lua
(alias) CircumCircleEnum = ("IN"|"BEHIND"|"ON")
```

View File

@@ -1,19 +0,0 @@
# alias Neighbours
---
- namespace: MapGen.Triangle
```lua
(alias) Neighbours = { t1: MapGen.Triangle?, t2: MapGen.Triangle?, t3: MapGen.Triangle? }
```
Adjacent triangles:
* `t1` with a common side p1-p2
* `t2` with a common side p2-p3
* `t3` with a common side p3-p1

View File

@@ -1,750 +0,0 @@
# class Triangle
- namespace: MapGen
---
## methods
---
### Triangle.new
---
```lua
function Triangle.new(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p3: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Triangle {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
p3 = MapGen.Peak,
e1 = MapGen.Triangulation.Edge,
e2 = MapGen.Triangulation.Edge,
e3 = MapGen.Triangulation.Edge,
h1 = MapGen.Triangulation.Edge,
h2 = MapGen.Triangulation.Edge,
h3 = MapGen.Triangulation.Edge,
neighbours = MapGen.Triangle.Neighbours,
color = ColorString?,
new = function,
toString = function,
eq = function,
same = function,
getCenter = function,
getArea = function,
getHeight = function,
getHeight2D = function,
getSidesLength = function,
getSidesLength2D = function,
getCircumCenter2D = function,
getCircumRadius2D = function,
getCircumCircle2D = function,
inCircumCircle2D = function,
}
```
### Triangle.toString
---
```lua
function Triangle.toString() -> string
```
Returns a string describing the object in a readable form.
### Triangle.eq
---
```lua
function Triangle.eq(other: MapGen.Triangle {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
p3 = MapGen.Peak,
e1 = MapGen.Triangulation.Edge,
e2 = MapGen.Triangulation.Edge,
e3 = MapGen.Triangulation.Edge,
h1 = MapGen.Triangulation.Edge,
h2 = MapGen.Triangulation.Edge,
h3 = MapGen.Triangulation.Edge,
neighbours = MapGen.Triangle.Neighbours,
color = ColorString?,
new = function,
toString = function,
eq = function,
same = function,
getCenter = function,
getArea = function,
getHeight = function,
getHeight2D = function,
getSidesLength = function,
getSidesLength2D = function,
getCircumCenter2D = function,
getCircumRadius2D = function,
getCircumCircle2D = function,
inCircumCircle2D = function,
}) -> boolean
```
Returns true if the triangles are equivalent.
### Triangle.same
---
```lua
function Triangle.same(other: MapGen.Triangle {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
p3 = MapGen.Peak,
e1 = MapGen.Triangulation.Edge,
e2 = MapGen.Triangulation.Edge,
e3 = MapGen.Triangulation.Edge,
h1 = MapGen.Triangulation.Edge,
h2 = MapGen.Triangulation.Edge,
h3 = MapGen.Triangulation.Edge,
neighbours = MapGen.Triangle.Neighbours,
color = ColorString?,
new = function,
toString = function,
eq = function,
same = function,
getCenter = function,
getArea = function,
getHeight = function,
getHeight2D = function,
getSidesLength = function,
getSidesLength2D = function,
getCircumCenter2D = function,
getCircumRadius2D = function,
getCircumCircle2D = function,
inCircumCircle2D = function,
}) -> boolean
```
Returns true if the triangles are similar.
### Triangle.getCenter
---
```lua
function Triangle.getCenter() -> vector
```
Returns the coordinates of the triangle's center.
### Triangle.getArea
---
```lua
function Triangle.getArea() -> number
```
Returns the area of a triangle.
### Triangle.getHeight
---
```lua
function Triangle.getHeight(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p3: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Triangulation.Edge {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
new = function,
toString = function,
eq = function,
same = function,
length = function,
getMidPoint = function,
}
```
Returns the perpendicular from the vertex Peak1 to the line Peak2-Peak3.
### Triangle.getHeight2D
---
```lua
function Triangle.getHeight2D(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p3: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Triangulation.Edge {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
new = function,
toString = function,
eq = function,
same = function,
length = function,
getMidPoint = function,
}
```
Returns the perpendicular from the vertex Peak1 to the line Peak2-Peak3.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
### Triangle.getSidesLength
---
```lua
function Triangle.getSidesLength()
-> number
-> number
-> number
```
Returns the length of the edges
### Triangle.getSidesLength2D
---
```lua
function Triangle.getSidesLength2D()
-> number
-> number
-> number
```
Returns the length of the edges.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
### Triangle.getCircumCenter2D
---
```lua
function Triangle.getCircumCenter2D() -> vector
```
Returns the coordinates of the circumcircle center.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
### Triangle.getCircumRadius2D
---
```lua
function Triangle.getCircumRadius2D() -> number
```
Returns the radius of the circumcircle.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
### Triangle.getCircumCircle2D
---
```lua
function Triangle.getCircumCircle2D()
-> vector
-> number
```
Returns the coordinates of the circumcircle center and its radius.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
### Triangle.inCircumCircle2D
---
```lua
function Triangle.inCircumCircle2D(p: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}) -> boolean
```
Checks if a given point lies into the triangle circumcircle.
Note: This function does not take into account the Y-coordinate,
that is, the calculation is performed on the projection of the triangle XZ.
## fields
---
### Triangle.p1
---
```lua
Triangle.p1 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Triangle.p2
---
```lua
Triangle.p2 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Triangle.p3
---
```lua
Triangle.p3 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Triangle.e1
---
```lua
Triangle.e1 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.e2
---
```lua
Triangle.e2 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.e3
---
```lua
Triangle.e3 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.h1
---
```lua
Triangle.h1 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.h2
---
```lua
Triangle.h2 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.h3
---
```lua
Triangle.h3 : MapGen.Triangulation.Edge {
p1: MapGen.Peak,
p2: MapGen.Peak,
new: function,
toString: function,
eq: function,
same: function,
length: function,
getMidPoint: function,
}
```
### Triangle.neighbours
---
```lua
Triangle.neighbours : MapGen.Triangle.Neighbours
```
### Triangle.color
---
```lua
Triangle.color : ColorString?
```

View File

@@ -1,230 +0,0 @@
# class Edge
- namespace: MapGen.Triangulation
---
## methods
---
### Edge.new
---
```lua
function Edge.new(
p1: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
},
p2: MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
) -> MapGen.Triangulation.Edge {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
new = function,
toString = function,
eq = function,
same = function,
length = function,
getMidPoint = function,
}
```
### Edge.toString
---
```lua
function Edge.toString() -> string
```
Returns a string describing the object in a readable form.
### Edge.eq
---
```lua
function Edge.eq(other: MapGen.Triangulation.Edge {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
new = function,
toString = function,
eq = function,
same = function,
length = function,
getMidPoint = function,
}) -> boolean
```
Returns true if the edges are equivalent.
### Edge.same
---
```lua
function Edge.same(other: MapGen.Triangulation.Edge {
p1 = MapGen.Peak,
p2 = MapGen.Peak,
new = function,
toString = function,
eq = function,
same = function,
length = function,
getMidPoint = function,
}) -> boolean
```
Returns true if the edges are similar.
### Edge.length
---
```lua
function Edge.length() -> number
```
Returns the length of an edge.
### Edge.getMidPoint
---
```lua
function Edge.getMidPoint() -> vector
```
Returns the vector of the point located in the middle of the edge.
## fields
---
### Edge.p1
---
```lua
Edge.p1 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```
### Edge.p2
---
```lua
Edge.p2 : MapGen.Peak {
id: number,
getPeakPos: function,
getColor: function,
getGroups: function,
new: function,
toString: function,
eq: function,
}
```

View File

@@ -1,90 +0,0 @@
# class FakePeak
- supers: MapGen.Peak
- namespace: MapGen.Triangulation
Allows you to create a `MapGen.Peak` without specifying a noise parameter.
**WARNING: MUST NOT BE PARTICIPATED IN GENERATION**
---
## methods
---
### FakePeak.getPeakPos
---
```lua
function FakePeak.getPeakPos()-> vector
```
### FakePeak.new
---
```lua
function FakePeak.new(peakPos: vector) -> MapGen.Peak {
id = number,
getPeakPos = function,
getColor = function,
getGroups = function,
new = function,
toString = function,
eq = function,
}
```
Returns a fake `MapGen.Peak` that has no noise parameters.
Note that the initialized peak should not be used in generation.
## fields
---
### FakePeak.id
---
```lua
FakePeak.id : number
```

View File

@@ -1,86 +0,0 @@
# class Triangulation
- namespace: MapGen
---
## methods
---
### Triangulation.triangulate
---
```lua
function Triangulation.triangulate(vertices: table<integer,MapGen.Peak>) -> ((MapGen.Triangle)|MapGen.Triangle[])
```
The Delaunay method divides a plane into triangles based on a list of their vertices.
Doesn't take into account the Y coordinate of the vertices.
That is, all triangles that don't lie in the XZ plane will be projected onto it.
Vertices that do not have a `is2d` group will not participate in the triangulation.
### Triangulation.tetrahedralize
---
```lua
function Triangulation.tetrahedralize(vertices: table<integer,MapGen.Peak>) -> ((MapGen.Tetrahedron)|MapGen.Tetrahedron[])
```
The Delaunay method divides space into tetrahedra based on a list of their vertices.
Vertices that do not have a `is3d` group will not participate in the triangulation.
## fields
---
### Triangulation.convexMultiplier
---
```lua
Triangulation.convexMultiplier : number
```

View File

@@ -1,741 +0,0 @@
# class MapGen
---
## methods
---
### MapGen.new
---
```lua
function MapGen.new(def: MapGenDef {
nodes = table<string,string>,
}) -> MapGen {
layersByName = table<string,MapGen.Layer>,
layersList = MapGen.Layer[],
staticsByName = table<string,MapGen.StaticLayer>,
staticsList = MapGen.StaticLayer[],
layersNoisesInitialized = boolean,
cavernsNoiseInitialized = boolean,
isRunning = boolean,
nodeIDs = table<string,number>,
new = function,
getLayerByHeight = function,
getStaticByHeight = function,
registerLayer = function,
registerLayerNoiseColor = function,
registerStaticLayer = function,
registerPeak = function,
register2DPeak = function,
register2DPeaks = function,
register2DPeaksFromFile = function,
registerBiome = function,
registerCavern = function,
initLayersTriangultaion = function,
initLayersNoises = function,
initBiomesDiagram = function,
initCavernsNoise = function,
getNoises2dValue = function,
onMapGenerated = function,
run = function,
}
```
### MapGen.getLayerByHeight
---
```lua
function MapGen.getLayerByHeight(yPos: number) -> MapGen.Layer?
```
Determines which layer a node belongs to based on its height coordinate.
### MapGen.getStaticByHeight
---
```lua
function MapGen.getStaticByHeight(yPos: number) -> MapGen.StaticLayer?
```
Determines which statics layer a node belongs to based on its height coordinate.
### MapGen.registerLayer
---
```lua
function MapGen.registerLayer(
name: string,
def: MapGen.LayerDef {
minY = number,
maxY = number,
minTemp = number,
maxTemp = number,
minHumidity = number,
maxHumidity = number,
waterLevel = number?,
calcTemp = (fun(self: MapGen.Layer, value: number, height: number) -> number)?,
calcHumidity = (fun(self: MapGen.Layer, value: number, height: number) -> number)?,
biomesGorizontalScattering = number?,
biomesVerticalScattering = number?,
}
) -> nil
```
@param `name` - The name that will be assigned to the layer. The name must be unique for each layer.
@param `def` - Layer description table, see details `MapGen.LayerDef`.
Mark the world area between two heights as a `MapGen.Layer`.
Note: layers must not overlap.
### MapGen.registerLayerNoiseColor
---
```lua
function MapGen.registerLayerNoiseColor(
layerName: string,
category: MapGen.Layer.Category,
color: ColorString,
noiseParams: NoiseParams
) -> nil
```
@param `layerName` - The name of the layer for which the color will be registered.
@param `category` - Category indicating what will be generated by noise.
@param `color` - Noise color. Must be unique.
@param `noiseParams` - Fractal noise parameters.
Register the color and the noise parameters that correspond to it.
### MapGen.registerStaticLayer
---
```lua
function MapGen.registerStaticLayer(
name: string,
def: MapGen.StaticLayerDef {
minY = number,
maxY = number,
staticNode = string,
generateStaticNode = generateFunc,
}
) -> nil
```
@param `name` - The name that will be assigned to the static layer. The name must be unique for each layer.
@param `def` - Static layer description table, see details `MapGen.StaticLayerDef`.
Mark the world area between two heights as a `MapGen.StaticLayer`.
Note: layers must not overlap.
### MapGen.registerPeak
---
```lua
function MapGen.registerPeak(
layerName: string,
category: MapGen.Layer.Category,
def: MapGen.PeakDef {
pos = vector,
color = ColorString,
groups = table<string,number>?,
}
) -> nil
```
@param `layerName` - The name of the layer in which the new peak will be included.
@param `category` - Category indicating what will be generated by peak.
@param `def` - Peak description table, see details `MapGen.PeakDef`.
Mark a world point as `MapGen.Peak` and assign it a specific color that will affect the generation.
Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.
### MapGen.register2DPeak
---
```lua
function MapGen.register2DPeak(
layerName: string,
category: MapGen.Layer.Category,
def: MapGen.PeakDef {
pos = vector,
color = ColorString,
groups = table<string,number>?,
}
) -> nil
```
@param `layerName` - The name of the layer in which the new peak will be included.
@param `category` - Category indicating what will be generated by peak.
@param `def` - Peak description table, see details `MapGen.PeakDef`.
Mark a world point as `MapGen.Peak` and assign it a specific color that will affect the generation.
The Y coordinate will be forced to zero, and the `is2d` group will be added to the groups field.
Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.
### MapGen.register2DPeaks
---
```lua
function MapGen.register2DPeaks(
layerName: string,
category: MapGen.Layer.Category,
defs: MapGen.PeakDef[]
) -> nil
```
@param `layerName` - The name of the layer in which the new peaks will be included.
@param `category` - Category indicating what will be generated by peaks.
@param `defs` - Peaks description table, see details `MapGen.PeakDef`.
Mark the world points as `MapGen.Peak` and assign them all a specific noise that will affect generation.
The Y coordinate will be forced to zero, and the `is2d` group will be added to the groups field.
Note: The peaks shouldn't overlap. This won't cause any errors, but it might ruin the generation.
### MapGen.register2DPeaksFromFile
---
```lua
function MapGen.register2DPeaksFromFile(
layerName: string,
map: string,
scale: number,
zeroPos: Position2d,
category: MapGen.Layer.Category,
groups: table<string,number>?
) -> nil
```
@param `layerName` - The name of the layer in which the new peaks will be included.
@param `map` - The name of the image from which the peaks will be extracted. It should be located in the `<mod_name>/textures/maps` folder and have the following format `<image_name>.ff`
@param `scale` - Multiplier of how many blocks (nodes) will be between image pixels. It is not recommended to set the value below 50 for performance reasons.
@param `zeroPos` - The position in pixels where the zero world coordinate will be in the image.
@param `category` - Category indicating what will be generated by peaks.
@param `groups` - Groups that will be added to all peaks.
Extract the `MapGen.Peak` from the image and assign them all a specific color that will affect the generation.
### MapGen.registerBiome
---
```lua
function MapGen.registerBiome(
layerName: string,
biomeName: string,
def: MapGen.BiomeDef {
tempPoint = number,
humidityPoint = number,
minY = number,
maxY = number,
groundNodes = MapGen.Biome.GroundNodes,
soilHeight = number,
generateAir = generateFunc?,
generateCavernAir = generateFunc?,
generateWater = generateFunc?,
generateRock = generateFunc?,
generateTurf = generateFunc?,
generateSoil = generateFunc?,
generateBottom = generateFunc?,
}
) -> nil
```
@param `layerName` - The name of the layer in which the new biome will be included.
@param `biomeName` - The name to be assigned to the biome. The name must be unique for each biome.
@param `def` - Biome description table, see details `MapGen.BiomeDef`
Mark a point on the biomes diagram and constrain the world area by height to mark it as `MapGen.Biome`.
### MapGen.registerCavern
---
```lua
function MapGen.registerCavern(
layerName: string,
cavernName: string,
def: MapGen.CavernDef {
minY = number,
maxY = number,
noiseParams = NoiseParams,
smoothDistance = number,
threshold = number?,
groups = table<string,number>?,
}
) -> nil
```
@param `layerName` - The name of the layer in which the new cavern will be included.
@param `cavernName` - The name to be assigned to the cavern. The name must be unique for each cavern.
@param `def` - Cavern description table, see details `MapGen.CavernDef`
Mark the world area between two heights as a `MapGen.Cavern` and assign the noise that the cave will be generated from.
### MapGen.initLayersTriangultaion
---
```lua
function MapGen.initLayersTriangultaion() -> nil
```
Divide all layers into triangles whose vertices are the `Mapgen.Peak` belonging to these layers.
### MapGen.initLayersNoises
---
```lua
function MapGen.initLayersNoises() -> nil
```
Initialize all layer noises. This should be called after the map object is loaded.
### MapGen.initBiomesDiagram
---
```lua
function MapGen.initBiomesDiagram() -> nil
```
Initialization of the biome diagram using the Voronoi method.
### MapGen.initCavernsNoise
---
```lua
function MapGen.initCavernsNoise() -> nil
```
Initialize caverns's noises. This should be called after the map object is loaded.
### MapGen.getNoises2dValue
---
```lua
function MapGen.getNoises2dValue(
category: MapGen.Layer.Category,
layer: MapGen.Layer {
name = string,
minY = integer,
maxY = integer,
minTemp = integer,
maxTemp = integer,
minHumidity = integer,
maxHumidity = integer,
waterLevel = integer,
peaksList = { humidity: MapGen.Peak[], landscape: MapGen.Peak[], temp: MapGen.Peak[] },
noisesByColor = { humidity: table<ColorString,ValueNoise>, landscape: table<ColorString,ValueNoise>, temp: table<ColorString,ValueNoise> },
noisesParamsByColor = { humidity: table<ColorString,NoiseParams>, landscape: table<ColorString,NoiseParams>, temp: table<ColorString,NoiseParams> },
biomesByName = table<string,MapGen.Biome>,
biomesList = MapGen.Biome[],
biomesDiagram = table,
biomesGorizontalScattering = integer,
biomesVerticalScattering = integer,
cavernsByName = table<string,MapGen.Cavern>,
cavernsList = MapGen.Cavern[],
trianglesList = { humidity: MapGen.Triangle[], landscape: MapGen.Triangle[], temp: MapGen.Triangle[] },
tetrahedronsList = MapGen.Tetrahedron[],
calcTemp = function,
calcHumidity = function,
new = function,
addPeak = function,
addNoiseParamsColor = function,
getNoiseByColor = function,
addBiome = function,
addCavern = function,
initNoises = function,
initBiomesDiagram = function,
},
x: integer,
y: integer,
z: integer
) -> number?
```
Calculates a smoothed 2D noise value based on a preliminary space partitioning.
Returns `nil` if the point is not included in any triangle.
### MapGen.onMapGenerated
---
```lua
function MapGen.onMapGenerated(
voxelManip: VoxelManip,
minPos: Position,
maxPos: Position,
blockseed: number
) -> nil
```
Chunk generation handler.
### MapGen.run
---
```lua
function MapGen.run() -> nil
```
Run world generation through this mapgen object
Note: only one instance of a `MapGen` class can be running.
**FOR MAPGEN ENVIRONMENT ONLY**
## fields
---
### MapGen.layersByName
---
```lua
MapGen.layersByName : table<string,MapGen.Layer>
```
### MapGen.layersList
---
```lua
MapGen.layersList : MapGen.Layer[]
```
### MapGen.staticsByName
---
```lua
MapGen.staticsByName : table<string,MapGen.StaticLayer>
```
### MapGen.staticsList
---
```lua
MapGen.staticsList : MapGen.StaticLayer[]
```
### MapGen.layersNoisesInitialized
---
```lua
MapGen.layersNoisesInitialized : boolean
```
Is the fractal noise of the layer initialized? This is necessary for a one-time noise initialization.
### MapGen.cavernsNoiseInitialized
---
```lua
MapGen.cavernsNoiseInitialized : boolean
```
Is the fractal noise of the caverns initialized? This is necessary for a one-time noise initialization.
### MapGen.isRunning
---
```lua
MapGen.isRunning : boolean
```
A static field that guarantees that only one instance of the `MapGen` class will work.
### MapGen.nodeIDs
---
```lua
MapGen.nodeIDs : table<string,number>
```

View File

@@ -1,39 +0,0 @@
# class MapGenDef
Definition table for the `MapGen`.
**Only for EmmyLua.**
---
## fields
---
### MapGenDef.nodes
---
```lua
MapGenDef.nodes : table<string,string>
```

View File

@@ -1,12 +0,0 @@
# alias generateFunc
---
```lua
(alias) generateFunc = fun(self, mapGenerator: MapGen, data: number[], index: number, x: number, y: number, z: number)
```

View File

@@ -1,80 +0,0 @@
site_name: Docs
theme:
name: material
font:
text: Roboto
code: Roboto Mono
search: true
features:
- quick-links
- navigation
- search
- toc
- fullscreen
- bookmarks
- tabs
- code
- edit-on-github
- language-selector
- code
- cover
- footer
- social-share
- theme-switcher
nav:
- Home: index.md
- Types:
- alias Category : types/MapGen.Layer.Category.md
- alias CircumCircleEnum : types/MapGen.Triangle.CircumCircleEnum.md
- alias ColoredDotsTable : types/ColoredDotsTable.md
- alias Neighbours : types/MapGen.Triangle.Neighbours.md
- alias PastCalcNoiseValue : types/MapGen.PastCalcNoiseValue.md
- alias generateFunc : types/generateFunc.md
- class Biome : types/MapGen.Biome.md
- class BiomeDef : types/MapGen.BiomeDef.md
- class Cavern : types/MapGen.Cavern.md
- class CavernDef : types/MapGen.CavernDef.md
- class Decoration : types/MapGen.Decoration.md
- class Edge : types/MapGen.Triangulation.Edge.md
- class FakePeak : types/MapGen.Triangulation.FakePeak.md
- class GroundNodes : types/MapGen.Biome.GroundNodes.md
- class GroundNodesIDs : types/MapGen.Biome.GroundNodesIDs.md
- class Layer : types/MapGen.Layer.md
- class LayerDef : types/MapGen.LayerDef.md
- class MapGen : types/MapGen.md
- class MapGenDef : types/MapGenDef.md
- class Peak : types/MapGen.Peak.md
- class PeakDef : types/MapGen.PeakDef.md
- class StaticLayer : types/MapGen.StaticLayer.md
- class StaticLayerDef : types/MapGen.StaticLayerDef.md
- class Tetrahedron : types/MapGen.Tetrahedron.md
- class Triangle : types/MapGen.Triangle.md
- class Triangulation : types/MapGen.Triangulation.md
- Modules:
- MapGen : modules/MapGen.md
- MapGen.Biome : modules/MapGen.Biome.md
- MapGen.Biome.GroundNodes : modules/MapGen.Biome.GroundNodes.md
- MapGen.Biome.GroundNodesIds : modules/MapGen.Biome.GroundNodesIds.md
- MapGen.Cavern : modules/MapGen.Cavern.md
- MapGen.Decoration : modules/MapGen.Decoration.md
- MapGen.Layer : modules/MapGen.Layer.md
- MapGen.Peak : modules/MapGen.Peak.md
- MapGen.StaticLayer : modules/MapGen.StaticLayer.md
- MapGen.Tetrahedron : modules/MapGen.Tetrahedron.md
- MapGen.Triangle : modules/MapGen.Triangle.md
- MapGen.Triangulation : modules/MapGen.Triangulation.md
- MapGen.Triangulation.Edge : modules/MapGen.Triangulation.Edge.md
- MapGen.Triangulation.FakePeak : modules/MapGen.Triangulation.FakePeak.md
- MapGen.ff2luat : modules/MapGen.ff2luat.md
extra:
footer: ""

Binary file not shown.

Before

Width:  |  Height:  |  Size: 2.1 MiB

After

Width:  |  Height:  |  Size: 7.3 MiB

View File

@@ -10,18 +10,29 @@ local BaseUI = {
contex = {} contex = {}
} }
---@param name string ---@param name string The name of the formspec that will be shown to the player. It is recommended that the name be unique.
---@param getFormSpecString fun(self:BaseUI,playerName:string,...):string ---@param getFormSpecString fun(self:BaseUI,playerName:string,...):string
function BaseUI:new(name, getFormSpecString) ---@param clearContex boolean? Whether to clear the context stored for a player when that player closes the form. Default `true`.
function BaseUI:new(name, getFormSpecString, clearContex)
if clearContex == nil then
clearContex = true
end
---@type BaseUI ---@type BaseUI
local instance = getInstance(self, {}) local instance = getInstance(self, {})
instance.name = name instance.name = name
instance.getFormSpecString = getFormSpecString instance.getFormSpecString = getFormSpecString
if clearContex then
-- Ensure that when the form is closed, the context is cleared. -- Ensure that when the form is closed, the context is cleared.
instance:registerOnFormQuit(function(player) instance:registerOnFormQuit(function(player)
instance:clearContex(player) instance:clearContex(player)
end) end)
end
instance:registerOnFormQuit(function(player)
Smc.clearActiveFormspec(player:get_player_name())
end)
return instance return instance
end end
@@ -110,12 +121,14 @@ end
---@param playerName string ---@param playerName string
function BaseUI:showForm(playerName, ...) function BaseUI:showForm(playerName, ...)
core.show_formspec(playerName, self.name, self:getFormSpecString(playerName, ...)) core.show_formspec(playerName, self.name, self:getFormSpecString(playerName, ...))
Smc.setActiveFormspec(playerName, self.name)
end end
---Close the player the FormSpec registered by the instance of this UI. ---Close the player the FormSpec registered by the instance of this UI.
---@param playerName string ---@param playerName string
function BaseUI:closeForm(playerName) function BaseUI:closeForm(playerName)
core.close_formspec(playerName, self.name) core.close_formspec(playerName, self.name)
Smc.clearActiveFormspec(playerName)
end end

View File

@@ -1,3 +1,5 @@
local tableJoin = table.join
local modInfo = Mod.getInfo('smc__core__craft_system') local modInfo = Mod.getInfo('smc__core__craft_system')
local require = modInfo.require local require = modInfo.require
@@ -5,24 +7,228 @@ local require = modInfo.require
local PrimitiveCraftHandler = require('CraftSystem.PrimitiveCraftHandler') local PrimitiveCraftHandler = require('CraftSystem.PrimitiveCraftHandler')
---@type CraftSystem.ImmersiveCraftHandler ---@type CraftSystem.ImmersiveCraftHandler
local ImmersiveCraftHandler= require('CraftSystem.ImmersiveCraftHandler') local ImmersiveCraftHandler= require('CraftSystem.ImmersiveCraftHandler')
---@type CraftSystem.ProcessingCraftHandler
local ProcessingCraftHandler= require('CraftSystem.ProcessingCraftHandler')
---@alias CraftSystem.CraftGroup string ---@alias CraftSystem.CraftGroup string
---@alias CraftSystem.CraftRecipe string[] ---@alias CraftSystem.CraftRecipe ItemStackString[]
---@alias CraftSystem.CraftType 'primitive'|'immersive'
---@class CraftSystem ---@class CraftSystem
local CraftSystem = {} ---@field PrimitiveCraftHandlers table<string, CraftSystem.PrimitiveCraftHandler>
---@field ImmersiveCraftHandlers table<string, CraftSystem.ImmersiveCraftHandler>
---@field ProcessingCraftHandlers table<string, CraftSystem.ProcessingCraftHandler>
local CraftSystem = {
PrimitiveCraftHandlers = {},
ImmersiveCraftHandlers = {},
ProcessingCraftHandlers = {}
}
---@param craftName string
---@param def CraftSystem.PrimitiveCraftDef
function CraftSystem.registerPrimitiveCraft(craftName, def) --- Craft Types ---
PrimitiveCraftHandler:registerCraft(craftName, def)
---@alias CraftSystem.BaseCraftType 'primitive'|'immersive'|'processing'
---@alias CraftSystem.PrimitiveCraftType 'inside_player_inventory'
---@alias CraftSystem.ImmersiveCraftType 'workbench' -- DEBUG
---@alias CraftSystem.ProcessingCraftType 'test' -- DEBUG
---@alias CraftSystem.CraftType CraftSystem.PrimitiveCraftType|CraftSystem.ImmersiveCraftType|CraftSystem.ProcessingCraftType
---@param type CraftSystem.PrimitiveCraftType
---@param def CraftSystem.PrimitiveCraftHandlerDef
local function registerPrimitiveCraftType(type, def)
assert(CraftSystem.PrimitiveCraftHandlers[type] == nil, ('A primitive craft type `%s` already exists.'):format(type))
local handler = PrimitiveCraftHandler:new('primitive', type, def)
CraftSystem.PrimitiveCraftHandlers[type] = handler
end end
---@param type CraftSystem.ImmersiveCraftType
---@param def CraftSystem.ImmersiveCraftHandlerDef
local function registerImmersiveCraftType(type, def)
assert(CraftSystem.ImmersiveCraftHandlers[type] == nil, ('A immersive craft type `%s` already exists.'):format(type))
local handler = ImmersiveCraftHandler:new('immersive', type, def)
CraftSystem.ImmersiveCraftHandlers[type] = handler
end
---@param type CraftSystem.ProcessingCraftType
---@param def CraftSystem.ProcessingCraftHandlerDef
local function registerProcessingCraftType(type, def)
assert(CraftSystem.ProcessingCraftHandlers[type] == nil, ('A processing craft type `%s` already exists.'):format(type))
local handler = ProcessingCraftHandler:new('processing', type, def)
CraftSystem.ProcessingCraftHandlers[type] = handler
end
---@param type CraftSystem.PrimitiveCraftType
---@return CraftSystem.PrimitiveCraftHandler
function CraftSystem:getPrimitiveCraftHandler(type)
local handler = self.PrimitiveCraftHandlers[type]
assert(handler ~= nil)
return handler
end
---@param type CraftSystem.ImmersiveCraftType
---@return CraftSystem.ImmersiveCraftHandler
function CraftSystem:getImmersiveCraftHandler(type)
local handler = self.ImmersiveCraftHandlers[type]
assert(handler ~= nil)
return handler
end
---@param type CraftSystem.ProcessingCraftType
---@return CraftSystem.ProcessingCraftHandler
function CraftSystem:getProcessingCraftHandler(type)
local handler = self.ProcessingCraftHandlers[type]
assert(handler ~= nil)
return handler
end
-- Registration of craft types:
registerPrimitiveCraftType('inside_player_inventory', {})
-- Debug:
registerImmersiveCraftType('workbench', {})
registerProcessingCraftType('test', {})
--- Registration methods ---
---@param type CraftSystem.PrimitiveCraftType
---@param craftName string
---@param def CraftSystem.PrimitiveCraftDef
function CraftSystem:registerPrimitiveCraft(type, craftName, def)
local handler = self:getPrimitiveCraftHandler(type)
handler:registerCraft(craftName, def)
end
---@param type CraftSystem.ImmersiveCraftType
---@param craftName string ---@param craftName string
---@param def CraftSystem.ImmersiveCraftDef ---@param def CraftSystem.ImmersiveCraftDef
function CraftSystem.registerImmersiveCraft(craftName, def) function CraftSystem:registerImmersiveCraft(type, craftName, def)
ImmersiveCraftHandler:registerCraft(craftName, def) local handler = self:getImmersiveCraftHandler(type)
handler:registerCraft(craftName, def)
end
---@param type CraftSystem.ProcessingCraftType
---@param craftName string
---@param def CraftSystem.ProcessingCraftDef
function CraftSystem:registerProcessingCraft(type, craftName, def)
local handler = self:getProcessingCraftHandler(type)
handler:registerCraft(craftName, def)
end
--- Methods for performing crafting ---
---@param craft CraftSystem.BaseCraft
---@param recipeIndex integer
---@param count integer
---@return ItemStack[] materialStacks A table containing the items required for crafting.
---@return table<string, integer> materialGroups A table containing the item groups required for crafting.
local function getMaterials(craft, recipeIndex, count)
local materialStacks = {}
local materialGroups = {}
for _, itemName in ipairs(craft:getRecipe(recipeIndex)) do
local group = itemName:match('group:(%S+)')
local materialCount = itemName:match('group:%S+ (%S+)') or 1
if group == nil then
local item = ItemStack(itemName)
item:set_count(item:get_count() * count)
table.insert(materialStacks, item)
else
materialGroups[group] = (tonumber(materialCount) or 1) * count
end
end
return materialStacks, materialGroups
end
---Check if the player has the required items.
---@param materialStacks ItemStack[]
---@param inventory InvRef
---@return boolean
local function checkMaterialStacks(materialStacks, inventory)
for _, item in ipairs(materialStacks) do
if not inventory:contains_item('main', item) then
return false
end
end
return true
end
---Check whether the player has the required number of items with the required group for crafting.
---@param materialGroups table<string, integer>
---@param inventory InvRef
---@return boolean
---@return ItemStack[] materialStacks A list of item stacks that match the required material groups.
local function checkMaterialGroups(materialGroups, inventory)
local materialStacks = {}
local mainList = inventory:get_list('main')
for group, count in pairs(materialGroups) do
for _, item in ipairs(mainList) do
if core.get_item_group(item:get_name(), group) > 0 then
local itemCount = item:get_count()
if count > itemCount then
count = count - itemCount
table.insert(materialStacks, item)
else
item:set_count(count)
table.insert(materialStacks, item)
count = 0
end
end
end
if count > 0 then
return false, {}
end
end
return true, materialStacks
end
---Checks whether the player can perform crafting (whether he has the required materials in his inventory).
---@param player Player
---@param craft CraftSystem.BaseCraft
---@param recipeIndex integer
---@param count integer
---@return boolean check true if craft can be produced
---@return ItemStack[] materialStacks list of itemStacks for crafting
function CraftSystem:checkPossiblePlayerInventoryCrafting(player, craft, recipeIndex, count, flags)
local inventory = player:get_inventory()
local OutputStack = ItemStack(craft.output)
OutputStack:set_count(OutputStack:get_count() * count)
local materialStacks, materialGroups = getMaterials(craft, recipeIndex, count)
local isHaveStacks = checkMaterialStacks(materialStacks, inventory)
if not isHaveStacks then
core.chat_send_player(player:get_player_name(), 'Not enough materials for crafting!')
return false, {}
end
local isHaveGroups, materialGroupStacks = checkMaterialGroups(materialGroups, inventory)
if not isHaveGroups then
core.chat_send_player(player:get_player_name(), 'Not enough materials for crafting!')
return false, {}
end
materialStacks = tableJoin(materialStacks, materialGroupStacks)
return true, materialStacks
end end
return CraftSystem return CraftSystem

View File

@@ -1,13 +1,156 @@
---Abstract class for craft. ---A text indicator of the presence or absence
---@class CraftSystem.BaseCraft ---of a material in the player's inventory.
local CHECK = {YES = '[x]', NO = '[ ]', EMPTY = '-'}
---@class CraftSystem.BaseCraft : Class
---@field name string ---@field name string
---@field recipe ItemStackString[]
---@field altRecipes CraftSystem.CraftRecipe[]
---@field output ItemStackString
---@field group CraftSystem.CraftGroup ---@field group CraftSystem.CraftGroup
local BaseCraft = {} local BaseCraft = Class:extend({})
---Definition table for the `CraftSystem.BaseCraft`. ---Definition table for the `CraftSystem.BaseCraft`.
---
---**Only for EmmyLua.**
---@class CraftSystem.BaseCraftDef ---@class CraftSystem.BaseCraftDef
---@field group CraftSystem.CraftGroup ---@field recipe ItemStackString[]
---@field altRecipes CraftSystem.CraftRecipe[]?
---@field output ItemStackString
---@field group CraftSystem.CraftGroup?
---@param name string
---@param def CraftSystem.BaseCraftDef
---@return CraftSystem.BaseCraft
function BaseCraft:new(name, def)
---@type CraftSystem.BaseCraft
local instance = self:getInstance({})
instance.name = name
instance.recipe = def.recipe
instance.altRecipes = def.altRecipes or {}
instance.output = def.output
instance.group = def.group
return instance
end
---@param material ItemStack
---@param count number
---@param list ItemStack[]?
---@return string
local function getCheckMaterialItem(material, count, list)
if list == nil then
return CHECK.EMPTY
end
local materialName = material:get_name()
for _, item in ipairs(list) do
if materialName == item:get_name() then
local itemCount = item:get_count()
if count > itemCount then
count = count - itemCount
else
return CHECK.YES
end
end
end
return CHECK.NO
end
---@param material string
---@param count number
---@param list ItemStack[]?
---@return string
local function getCheckMaterialGroup(material, count, list)
if list == nil then
return CHECK.EMPTY
end
for _, item in ipairs(list) do
if core.get_item_group(item:get_name(), material) > 0 then
local itemCount = item:get_count()
if count > itemCount then
count = count - itemCount
else
return CHECK.YES
end
end
end
return CHECK.NO
end
---Returns the crafting recipe corresponding to the index.
---@param index integer Recipe number. If `0` is specified,
--- the primary craft (`craft.recipe`) will be used;
--- if `1` or greater, the alternative craft
--- corresponding to the index will be used (`craft.altRecipes`).
---@return CraftSystem.CraftRecipe
function BaseCraft:getRecipe(index)
local recipe
if index == 0 or self.altRecipes == nil then
recipe = self.recipe
else
if index > #self.altRecipes then
recipe = self.altRecipes[#self.altRecipes]
else
recipe = self.altRecipes[index]
end
end
assert(recipe ~= nil)
return recipe
end
---@param recipeIndex integer?
---@param mainList ItemStack[]?
---@return string
function BaseCraft:recipeToString(recipeIndex, mainList)
local recipe
if recipeIndex == nil or recipeIndex == 0 or self.altRecipes == nil then
recipe = self.recipe
else
if recipeIndex > #self.altRecipes then
recipe = self.altRecipes[#self.altRecipes]
else
recipe = self.altRecipes[recipeIndex]
end
end
assert(recipe ~= nil)
local recipeDesc = ''
for _, itemName in ipairs(recipe) do
local group, count = itemName:match('group:(%S+)'), itemName:match('group:%S+ (%S+)') or 1
if group == nil then
local recipeItem = ItemStack(itemName)
recipeDesc = recipeDesc..('%s %s x%s\n'):format(
getCheckMaterialItem(recipeItem, recipeItem:get_count(), mainList),
core.strip_colors(recipeItem:get_definition()._title),
recipeItem:get_count())
else
recipeDesc = recipeDesc..('%s any item from the group %s x%s\n'):format(
getCheckMaterialGroup(group, count, mainList),
group,
count)
end
end
return recipeDesc
end
---@param recipeIndex integer?
---@param mainList ItemStack[]?
---@return string
function BaseCraft:toString(recipeIndex, mainList)
local outputItem = ItemStack(self.output)
local outputItemSettings = Smc.getItemDefinition(outputItem).settings
local craftDesc = ('%s\n\nNeeded:\n%s'):format(
outputItemSettings._title,
self:recipeToString(recipeIndex, mainList))
return craftDesc
end
return BaseCraft return BaseCraft

View File

@@ -1,22 +1,52 @@
local tableInsert = table.insert
local stringMatch = string.match
local PLAYERS_KNOW_ALL_RECIPES = true
---Abstract class for handling crafting. ---Abstract class for handling crafting.
---@class CraftSystem.BaseCraftHandler ---@class CraftSystem.BaseCraftHandler : Class
---@field baseType CraftSystem.BaseCraftType
---@field type CraftSystem.CraftType
---@field defaultCraftDef CraftSystem.BaseCraftDef
---
---@field craftsByName table<string, CraftSystem.BaseCraft> ---@field craftsByName table<string, CraftSystem.BaseCraft>
---@field craftsByGroup table<CraftSystem.CraftGroup, CraftSystem.BaseCraft[]> ---@field craftsByGroup table<CraftSystem.CraftGroup, CraftSystem.BaseCraft[]>
---@field craftsList CraftSystem.BaseCraft[] ---@field craftsList CraftSystem.BaseCraft[]
---@field learnedCrafts table<string, table<string, CraftSystem.BaseCraft>> ---@field groupedCrafts (CraftSystem.BaseCraft[]|CraftSystem.BaseCraft)[]
local BaseCraftHandler = { ---@field learnedCrafts table<string, CraftSystem.BaseCraft[]>
---@field learnedGroupedCrafts table<string, (CraftSystem.BaseCraft[]|CraftSystem.BaseCraft)[]>
local BaseCraftHandler = Class:extend({
craftsByName = {}, craftsByName = {},
craftsByGroup = {}, craftsByGroup = {},
craftsList = {}, craftsList = {},
groupedCrafts = {},
learnedCrafts = {}, learnedCrafts = {},
} learnedGroupedCrafts = {},
})
---@class CraftSystem.BaseCraftHandlerDef
---@field defaultCraftDef CraftSystem.BaseCraftDef?
---@param baseType CraftSystem.BaseCraftType
---@param type CraftSystem.CraftType
---@param def CraftSystem.BaseCraftHandlerDef
---@return CraftSystem.BaseCraftHandler
function BaseCraftHandler:new(baseType, type, def)
---@type CraftSystem.BaseCraftHandler
local instance = self:getInstance({})
instance.baseType = baseType
instance.type = type
instance.defaultCraftDef = def.defaultCraftDef or {}
return instance
end
---@param craftName string ---@param craftName string
---@return CraftSystem.BaseCraft ---@return CraftSystem.BaseCraft
function BaseCraftHandler:getCraftByName(craftName) function BaseCraftHandler:getCraftByName(craftName)
local craft = self.craftsByName[craftName] local craft = self.craftsByName[craftName]
assert(craft ~= nil, ('There is no primitive craft named `%s`.'):format( assert(craft ~= nil, ('A craft `%s` not exists.'):format(
craftName)) craftName))
return craft return craft
@@ -27,21 +57,69 @@ end
function BaseCraftHandler:getCraftsByGroup(craftGroup) function BaseCraftHandler:getCraftsByGroup(craftGroup)
local crafts = self.craftsByGroup[craftGroup] local crafts = self.craftsByGroup[craftGroup]
assert(crafts ~= nil, ('There are no primitive crafts with `%s` group'):format( assert(crafts ~= nil, ('A craft with group `%s` not exists.'):format(
craftGroup)) craftGroup))
return crafts return crafts
end end
---@param playerName string ---@param playerName string
---@return table<string, CraftSystem.BaseCraft> ---@return (CraftSystem.BaseCraft[]|CraftSystem.BaseCraft)[]
function BaseCraftHandler:getLearnedCrafts(playerName) function BaseCraftHandler:getLearnedCrafts(playerName)
local crafts = self.learnedCrafts[playerName] if PLAYERS_KNOW_ALL_RECIPES then
return self.groupedCrafts
end
assert(crafts ~= nil, ('There is no primitive crafting data for a player named `%s`.'):format( local crafts = self.learnedGroupedCrafts[playerName]
playerName))
if crafts == nil then
crafts = {}
self.learnedGroupedCrafts[playerName] = crafts
end
return crafts return crafts
end end
---@param crafts CraftSystem.BaseCraft[]
---@param pattern string
---@return CraftSystem.BaseCraft[]
local function getMathedCrafts(crafts, pattern)
local matchedCrafts = {}
for _, craft in ipairs(crafts) do
local outputItem = ItemStack(craft.output)
local itemSettings = Smc.getItemDefinition(outputItem).settings
local ruName = core.get_translated_string('ru', itemSettings._title)
local enName = core.get_translated_string('en', itemSettings._title)
if stringMatch(outputItem:get_name(), pattern) or
stringMatch(ruName, pattern) or
stringMatch(enName, pattern) then
tableInsert(matchedCrafts, craft)
end
end
return matchedCrafts
end
---@param playerName string
---@param pattern string
---@return CraftSystem.BaseCraft[]
function BaseCraftHandler:getLearnedCraftsMatch(playerName, pattern)
if PLAYERS_KNOW_ALL_RECIPES then
return getMathedCrafts(self.craftsList, pattern)
end
local crafts = self.learnedCrafts[playerName]
if crafts == nil then
crafts = {}
self.learnedCrafts[playerName] = crafts
end
return crafts
end
--TODO: сохранять выученные крафты игроков в сторадже
return BaseCraftHandler return BaseCraftHandler

View File

@@ -1,5 +1,3 @@
local getInstance, extend = Class.getInstance, Class.extend
local modInfo = Mod.getInfo('smc__core__craft_system') local modInfo = Mod.getInfo('smc__core__craft_system')
local require = modInfo.require local require = modInfo.require
@@ -18,47 +16,35 @@ local stageTypes = {
---Immersive crafting aimed at a more logical process of crafting items. ---Immersive crafting aimed at a more logical process of crafting items.
---@class CraftSystem.ImmersiveCraft : CraftSystem.BaseCraft ---@class CraftSystem.ImmersiveCraft : CraftSystem.BaseCraft
---@field startStageName string ---@field startStageName string
---@field triggerItem string
---@field output ItemStackString
---@field stagesByName table<string, CraftSystem.ImmersiveCraftStage> ---@field stagesByName table<string, CraftSystem.ImmersiveCraftStage>
local ImmersiveCraft = extend(BaseCraft, {}) local ImmersiveCraft = BaseCraft:extend({})
---Definition table for the `CraftSystem.ImmersiveCraft`. ---Definition table for the `CraftSystem.ImmersiveCraft`.
--- ---
---**Only for EmmyLua.** ---**Only for EmmyLua.**
---@class CraftSystem.ImmersiveCraftDef : CraftSystem.BaseCraftDef ---@class CraftSystem.ImmersiveCraftDef : CraftSystem.BaseCraftDef
---@field startStageName string ---@field startStageName string
---@field triggerItem string
---@field output string
---@field stages CraftSystem.ImmersiveCraftStageDef[] ---@field stages CraftSystem.ImmersiveCraftStageDef[]
---@param name string ---@param name string
---@param def CraftSystem.ImmersiveCraftDef ---@param def CraftSystem.ImmersiveCraftDef
---@return CraftSystem.ImmersiveCraft ---@return CraftSystem.ImmersiveCraft
function ImmersiveCraft:new(name, def) function ImmersiveCraft:new(name, def)
-- We create a table of crafting stages that the player needs to complete.
---@type table<string, CraftSystem.ImmersiveCraftStage> ---@type table<string, CraftSystem.ImmersiveCraftStage>
local stagesByName = {} local stagesByName = {}
for _, stageDef in ipairs(def.stages) do for _, stageDef in ipairs(def.stages) do
-- We get the stage class based on its type.
local StageClass = stageTypes[stageDef.type] local StageClass = stageTypes[stageDef.type]
-- Create a stage and add the craft name to the instance.
stageDef.craftName = name stageDef.craftName = name
local stage = StageClass:new(stageDef) local stage = StageClass:new(stageDef)
-- We add an instance of the stage to the table by name.
stagesByName[stageDef.name] = stage stagesByName[stageDef.name] = stage
end end
---@type CraftSystem.ImmersiveCraft ---@type CraftSystem.ImmersiveCraft
local instance = getInstance(self, {}) local instance = self:getInstance(BaseCraft:new(name, def))
instance.name = name
instance.group = def.group
instance.startStageName = def.startStageName instance.startStageName = def.startStageName
instance.triggerItem = def.triggerItem
instance.output = def.output
instance.stagesByName = stagesByName instance.stagesByName = stagesByName
-- Subscribe to an event that will determine that the player has completed the crafting stage. -- Subscribe to an event that will determine that the player has completed the crafting stage.
@@ -68,27 +54,17 @@ function ImmersiveCraft:new(name, def)
---@param pos MapPosition ---@param pos MapPosition
---@param Player Player ---@param Player Player
function(eventName, stage, pos, Player) function(eventName, stage, pos, Player)
-- From the current stage (which has been completed) we get the name of the next one.
local nextStageName = stage.nextStage local nextStageName = stage.nextStage
-- If there is no next stage...
if nextStageName == nil then if nextStageName == nil then
-- ...we are finishing the craft.
instance:endCraft(pos, Player) instance:endCraft(pos, Player)
else else
-- ...else we start the next stage.
local nextStage = instance.stagesByName[nextStageName] local nextStage = instance.stagesByName[nextStageName]
-- We get a table of temporary data. ---@type ImmersiveWorkStation.MetaData
local craftData = Smc.getCraftDataByPos(pos) local meta = core.get_meta(pos)
assert(craftData ~= nil, 'Immersive crafting data is empty.') meta:set_string('stage_name', nextStage.name)
-- We are updating the crafting stage in it.
craftData.stageName = nextStageName
-- We save it to the workstation metadata.
Smc.setCraftDataByPos(pos, craftData)
-- We are starting the next stage of crafting.
nextStage:startHandler(pos, Player) nextStage:startHandler(pos, Player)
end end
end) end)
@@ -104,10 +80,15 @@ end
---@param amount integer ---@param amount integer
---@return boolean ---@return boolean
function ImmersiveCraft:startCraft(pos, player, amount) function ImmersiveCraft:startCraft(pos, player, amount)
-- Adding craft to the counter. ---@type ImmersiveWorkStation.MetaData
-- If crafting has not been added... local meta = core.get_meta(pos)
if not ImmersiveCraftCounter:addCraft(pos, player) then local craftName = meta:get_string('craft_name')
-- ...then we don't let the player start a new craft. if craftName ~= '' then
core.chat_send_player(player:get_player_name(), 'The workbench is occupied by another craft.')
return false
end
if not ImmersiveCraftCounter:addCraft(pos, player:get_player_name()) then
core.chat_send_player(player:get_player_name(), core.chat_send_player(player:get_player_name(),
'The limit of simultaneously active crafts has been reached: '.. 'The limit of simultaneously active crafts has been reached: '..
'complete or cancel active crafts to start a new one') 'complete or cancel active crafts to start a new one')
@@ -115,41 +96,13 @@ function ImmersiveCraft:startCraft(pos, player, amount)
return false return false
end end
-- We get the material as an ItemStack.
---@type ItemStack
local stack = ItemStack(self.triggerItem)
-- We edit the amount of materials in accordance with the number of crafts being performed.
stack:set_count(stack:get_count() * amount)
-- We get the player's inventory, from where we must take the materials for crafting.
local playerInventory = player:get_inventory()
-- If the player does not have the necessary materials for crafting...
if not playerInventory:contains_item('main', stack) then
-- ...we inform him about this.
core.chat_send_player(player:get_player_name(),
'Not enough materials for crafting')
return false
end
-- If we have the materials, we take them and start initializing the craft.
playerInventory:remove_item('main', stack)
-- We get the first stage of crafting.
local stage = self.stagesByName[self.startStageName] local stage = self.stagesByName[self.startStageName]
-- Create a temporary data table for crafting. meta:set_string('player_name', player:get_player_name())
---@type ImmersiveCraftData meta:set_string('craft_name', self.name)
local craftData = { meta:set_string('stage_name', stage.name)
craftName = self.name, meta:set_float('craft_amount', amount)
stageName = stage.name,
amount = amount,
}
-- We save it to the workstation metadata.
Smc.setCraftDataByPos(pos, craftData)
-- We are starting the first stage of crafting.
stage:startHandler(pos, player) stage:startHandler(pos, player)
return true return true
@@ -157,80 +110,86 @@ end
---Complete the immersive crafting process. ---Complete the immersive crafting process.
---@param pos MapPosition ---@param pos MapPosition
---@param Player Player ---@param player Player
function ImmersiveCraft:endCraft(pos, Player) function ImmersiveCraft:endCraft(pos, player)
-- We get current data on crafting. ---@type ImmersiveWorkStation.MetaData
---@type ImmersiveCraftData? local meta = core.get_meta(pos)
local craftData = Smc.getCraftDataByPos(pos) local playerName = meta:get_string('player_name')
assert(craftData ~= nil, 'Immersive crafting data is empty.') assert(playerName ~= '')
local amount = meta:get_float('craft_amount')
assert(amount ~= 0)
-- We drop the result of crafting. -- Drop the result of crafting.
local dropPos = vector.new(pos) + vector.new(0, 0.9,0) local dropPos = vector.new(pos) + vector.new(0, 0.9,0)
for i=1, craftData.amount do for i=1, amount do
core.item_drop(ItemStack(self.output), nil, dropPos) core.item_drop(ItemStack(self.output), nil, dropPos)
end end
-- Clearing the temporary data table for crafting, freeing up the work station for new crafts. ImmersiveCraftCounter:removeCraft(pos, playerName)
Smc.setCraftDataByPos(pos)
-- Remove craft from the counter. -- Clear craft data
ImmersiveCraftCounter:removeCraft(pos, Player) meta:set_string('player_name', '')
meta:set_string('craft_name', '')
meta:set_string('stage_name', '')
meta:set_float('craft_amount', 0)
meta:set_string('stage_data', '')
end end
---Stop the crafting process and free up the workbench. ---Stop the crafting process and free up the workbench.
---@param pos MapPosition ---@param pos MapPosition
---@param Player Player function ImmersiveCraft:abortCraft(pos)
function ImmersiveCraft:abortCraft(pos, Player) ---@type ImmersiveWorkStation.MetaData
-- We get current data on crafting. local meta = core.get_meta(pos)
---@type ImmersiveCraftData? local playerName = meta:get_string('player_name')
local craftData = Smc.getCraftDataByPos(pos) assert(playerName ~= '')
assert(craftData ~= nil, 'Immersive crafting data is empty.') local stageName = meta:get_string('stage_name')
assert(stageName ~= '')
-- We get the current stage and start the abort process. local stage = self.stagesByName[stageName]
local stage = self.stagesByName[craftData.stageName] stage:abortHandler(pos)
stage:abortHandler(pos, Player)
-- Clearing the temporary data table for crafting, freeing up the work station for new crafts. -- Clear craft data
Smc.setCraftDataByPos(pos) meta:set_string('player_name', '')
meta:set_string('craft_name', '')
meta:set_string('stage_name', '')
meta:set_float('craft_amount', 0)
meta:set_string('stage_data', '')
-- Remove craft from the counter. ImmersiveCraftCounter:removeCraft(pos, playerName)
ImmersiveCraftCounter:removeCraft(pos, Player)
end end
---Returns a human-readable description of the crafting process. ---Returns a human-readable description of the crafting process.
---@return string ---@return string
function ImmersiveCraft:toString() function ImmersiveCraft:recipeToString(recipeIndex, mainList)
-- We get the material as an ItemStack. local recipeDesc = ''
---@type ItemStack
local stack = ItemStack(self.triggerItem)
-- We obtain a table of item parameters.
---@type ItemDefinition
local itemDef = stack:get_definition()
-- Let's start writing a description of the craft.
local craftDesc = ('Material: %s x%s\n\n'):format(itemDef._title, stack:get_count())..
'Crafting process:\n'
-- Let's start with the first crafting stage.
---@type string? ---@type string?
local stageName = self.startStageName local stageName = self.startStageName
local stages = self.stagesByName local stages = self.stagesByName
-- While we have a stage name...
local count = 1 local count = 1
while stageName ~= nil do while stageName ~= nil do
-- We get a crafting stage...
local stage = stages[stageName] local stage = stages[stageName]
-- ...and we add its description to the list of actions for crafting. recipeDesc = recipeDesc..tostring(count)..'. '..stage:toString()..'\n'
craftDesc = craftDesc..tostring(count)..'. '..stage:toString()..'\n'
-- We also get the name of the next stage.
stageName = stage.nextStage stageName = stage.nextStage
end end
-- If the cycle is interrupted, it means we have processed all the stages. return recipeDesc
-- Return the craft description. end
---@param recipeIndex integer?
---@param mainList ItemStack[]?
---@return string
function ImmersiveCraft:toString(recipeIndex, mainList)
local outputItem = ItemStack(self.output)
local outputItemSettings = Smc.getItemDefinition(outputItem).settings
local craftDesc = ('%s\n\nRecipe:\n%s\nActions:\n%s'):format(
outputItemSettings._title,
BaseCraft.recipeToString(self, recipeIndex, mainList),
self:recipeToString(recipeIndex, mainList))
return craftDesc return craftDesc
end end

View File

@@ -3,6 +3,20 @@ local posToString, getSize = core.pos_to_string, table.get_size
local CRAFT_LIMIT_PER_PLAYER = 2 local CRAFT_LIMIT_PER_PLAYER = 2
local CRAFT_LIMIT_PER_SERVER = 10 local CRAFT_LIMIT_PER_SERVER = 10
local modStorage = core.get_mod_storage()
---@param key string
---@return table
local function getStorageTable(key)
return core.deserialize(modStorage:get_string(key)) or {}
end
---@param key string
---@param t table
local function setStorageTable(key, t)
modStorage:set_string(key, core.serialize(t))
end
---Designed to keep track of active immersive ---Designed to keep track of active immersive
---crafts so as not to overload the server. ---crafts so as not to overload the server.
--- ---
@@ -12,18 +26,17 @@ local CRAFT_LIMIT_PER_SERVER = 10
---@field craftsCountForPlayers table<string, table<string, boolean>> ---@field craftsCountForPlayers table<string, table<string, boolean>>
---@field craftsCountForServer table<string, boolean> ---@field craftsCountForServer table<string, boolean>
local ImmersiveCraftCounter = { local ImmersiveCraftCounter = {
craftsCountForPlayers = {}, craftsCountForPlayers = getStorageTable('crafts_count_for_players'),
craftsCountForServer = {} craftsCountForServer = getStorageTable('crafts_count_for_serves')
} }
---Add craft to the counter. ---Add craft to the counter.
--- ---
---Returns `false` if the counter is already full. ---Returns `false` if the counter is already full.
---@param pos MapPosition ---@param pos MapPosition
---@param Player Player ---@param playerName string
---@return boolean ---@return boolean
function ImmersiveCraftCounter:addCraft(pos, Player) function ImmersiveCraftCounter:addCraft(pos, playerName)
local playerName = Player:get_player_name()
if self.craftsCountForPlayers[playerName] == nil then if self.craftsCountForPlayers[playerName] == nil then
self.craftsCountForPlayers[playerName] = {} self.craftsCountForPlayers[playerName] = {}
end end
@@ -45,9 +58,9 @@ end
---Remove craft from the counter. ---Remove craft from the counter.
---@param pos MapPosition ---@param pos MapPosition
---@param Player Player ---@param playerName string
function ImmersiveCraftCounter:removeCraft(pos, Player) function ImmersiveCraftCounter:removeCraft(pos, playerName)
local playerCrafts = self.craftsCountForPlayers[Player:get_player_name()] local playerCrafts = self.craftsCountForPlayers[playerName]
if playerCrafts == nil then if playerCrafts == nil then
return return
end end
@@ -57,6 +70,9 @@ function ImmersiveCraftCounter:removeCraft(pos, Player)
self.craftsCountForServer[posString] = nil self.craftsCountForServer[posString] = nil
end end
-- TODO: сделать сохранение данных во время перезагрузки сервера core.register_on_shutdown(function()
setStorageTable('crafts_count_for_players', ImmersiveCraftCounter.craftsCountForPlayers)
setStorageTable('crafts_count_for_server', ImmersiveCraftCounter.craftsCountForServer)
end)
return ImmersiveCraftCounter return ImmersiveCraftCounter

View File

@@ -1,6 +1,4 @@
local extend = Class.extend local tableInsert, tableSort, tableJoin = table.insert, table.sort, table.join
local tableInsert = table.insert
local modInfo = Mod.getInfo('smc__core__craft_system') local modInfo = Mod.getInfo('smc__core__craft_system')
local require = modInfo.require local require = modInfo.require
@@ -13,13 +11,16 @@ local ImmersiveCraft = require('CraftSystem.ImmersiveCraft')
---A handler for immersive crafting that requires the player to complete ---A handler for immersive crafting that requires the player to complete
---crafting stages and interact with entities (crafting nodes) ---crafting stages and interact with entities (crafting nodes)
---@class CraftSystem.ImmersiveCraftHandler : CraftSystem.BaseCraftHandler ---@class CraftSystem.ImmersiveCraftHandler : CraftSystem.BaseCraftHandler
---@field craftsByTriggerItem table<string, CraftSystem.ImmersiveCraft[]> ---@field defaultCraftDef CraftSystem.BaseCraftDef
---
---@field new fun(self:CraftSystem.ImmersiveCraftHandler, baseType:CraftSystem.BaseCraftType, type:CraftSystem.ImmersiveCraftType, def:CraftSystem.ImmersiveCraftHandlerDef):CraftSystem.ImmersiveCraftHandler
---@field getCraftByName fun(self, craftName:string):CraftSystem.ImmersiveCraft ---@field getCraftByName fun(self, craftName:string):CraftSystem.ImmersiveCraft
---@field getCraftsByGroup fun(self, craftGroup):CraftSystem.ImmersiveCraft[] ---@field getCraftsByGroup fun(self, craftGroup):CraftSystem.ImmersiveCraft[]
---@field getLearnedCrafts fun(self, playerName):table<string, CraftSystem.ImmersiveCraft> ---@field getLearnedCrafts fun(self, playerName):table<string, CraftSystem.ImmersiveCraft>
local ImmersiveCraftHandler = extend(BaseCraftHandler, { local ImmersiveCraftHandler = BaseCraftHandler:extend({})
craftsByTriggerItem = {},
}) ---@class CraftSystem.ImmersiveCraftHandlerDef : CraftSystem.BaseCraftHandlerDef
---@field defaultCraftDef CraftSystem.ImmersiveCraftDef?
---Register an immersive crafting experience that requires the player to complete ---Register an immersive crafting experience that requires the player to complete
---one or more crafting stages that involve interaction with entities (crafting nodes) ---one or more crafting stages that involve interaction with entities (crafting nodes)
@@ -29,43 +30,47 @@ function ImmersiveCraftHandler:registerCraft(craftName, def)
assert(self.craftsByName[craftName] == nil, ('A craft named `%s` already exists.'):format( assert(self.craftsByName[craftName] == nil, ('A craft named `%s` already exists.'):format(
craftName)) craftName))
-- We obtain a crafting instance according to the given parameters. local def = table.merge(def, self.defaultCraftDef)
local craft = ImmersiveCraft:new(craftName, def)
-- The craft group to which the craft belongs. local group = 'craft_group:' .. (def.group or 'UNDEFINED')
local group = def.group def.group = group
local craft = (ImmersiveCraft:new(craftName, def))
-- If no craft with this group has been registered before...
if self.craftsByGroup[group] == nil then if self.craftsByGroup[group] == nil then
-- ...then we create a list for this group.
self.craftsByGroup[group] = {} self.craftsByGroup[group] = {}
end end
-- The material from which crafting begins (also known as the starting item).
local triggerItem = def.triggerItem
-- If no crafting for such a starting item has been registered before...
if self.craftsByTriggerItem[triggerItem] == nil then
-- ...then we create a list for this item.
self.craftsByTriggerItem[triggerItem] = {}
end
-- Adding craft to the lists:
self.craftsByName[craftName] = craft self.craftsByName[craftName] = craft
tableInsert(self.craftsByGroup[group], craft) tableInsert(self.craftsByGroup[group], craft)
tableInsert(self.craftsByTriggerItem[triggerItem], craft)
tableInsert(self.craftsList, craft) tableInsert(self.craftsList, craft)
end end
---Returns a list of crafts that use the given item as a starting material. -- Sort the list of crafts in alphabetical order by product name and combine crafts into groups.
--- -- Provides a convenient list of crafting items in the player's inventory.
---Will return `nil` if the item is not used in any craft as a starting item. core.register_on_mods_loaded(function()
---@param triggerItem string for groupName, crafts in pairs(ImmersiveCraftHandler.craftsByGroup) do
---@return CraftSystem.ImmersiveCraft[]? tableSort(crafts, function(a, b)
function ImmersiveCraftHandler:getCraftsByTriggerItem(triggerItem) if a.output < b.output then
local crafts = self.craftsByTriggerItem[triggerItem] return true
end
end)
return crafts if groupName ~= 'craft_group:UNDEFINED' then
tableInsert(ImmersiveCraftHandler.groupedCrafts, crafts)
else
ImmersiveCraftHandler.groupedCrafts = tableJoin(ImmersiveCraftHandler.groupedCrafts, crafts)
end
end end
tableSort(ImmersiveCraftHandler.groupedCrafts, function(a, b)
local outputA = (a[1] and a[1].output) or a.output
local outputB = (b[1] and b[1].output) or b.output
if outputA < outputB then
return true
end
end)
end)
return ImmersiveCraftHandler return ImmersiveCraftHandler

View File

@@ -22,10 +22,14 @@ local tappingNode = ImmersiveCraftNode:new({
_name = 'craft_system:tapping_node', _name = 'craft_system:tapping_node',
_add_mod_name = false, _add_mod_name = false,
---@type ObjectProperties
initial_properties = { initial_properties = {
visual = 'wielditem', visual = 'wielditem',
visual_size = {x=0.4, y=0.4, z=0.4}, visual_size = {x=0.5, y=0.5, z=0.5},
--static_save = false, collisionbox = {
-0.375, -0.375, -0.375,
0.375, 0.375, 0.375
},
}, },
_item_name = '', _item_name = '',
@@ -36,11 +40,9 @@ local tappingNode = ImmersiveCraftNode:new({
callbacks = { callbacks = {
---@param luaEntity CraftSystem.ImmersiveCraftNode.LuaTappingNode ---@param luaEntity CraftSystem.ImmersiveCraftNode.LuaTappingNode
on_activate = function(luaEntity, staticdata, dtime) on_activate = function(luaEntity, staticdata, dtime)
-- We obtain a table of initial parameters for the craft node entity.
---@type CraftSystem.ImmersiveCraftStage.TappingNode.InitParams? ---@type CraftSystem.ImmersiveCraftStage.TappingNode.InitParams?
local params = core.deserialize(staticdata) local params = core.deserialize(staticdata)
-- We enter parameters into the entity's custom fields.
if params ~= nil then if params ~= nil then
luaEntity._item_name = params.targetItem luaEntity._item_name = params.targetItem
luaEntity._craft_name = params.craftName luaEntity._craft_name = params.craftName

View File

@@ -7,10 +7,10 @@ local getInstance = Class.getInstance
---@field name string ---@field name string
---@field type CraftSystem.ImmersiveCraftStage.Type ---@field type CraftSystem.ImmersiveCraftStage.Type
---@field craftName string ---@field craftName string
---@field startHandler fun(self, pos:Position, Player:Player) ---@field startHandler fun(self, pos:Position, player:Player)
---@field processHandler fun(self, pos:Position, Player:Player) ---@field processHandler fun(self, pos:Position, player:Player)
---@field endHandler fun(self, pos:Position, Player:Player) ---@field endHandler fun(self, pos:Position, player:Player)
---@field abortHandler fun(self, pos:Position, Player:Player) ---@field abortHandler fun(self, pos:Position)
---@field toString fun(self):string ---@field toString fun(self):string
---@field nextStage string? ---@field nextStage string?
---@field returnItems ItemStackString[]? ---@field returnItems ItemStackString[]?

View File

@@ -1,7 +1,5 @@
local extend = Class.extend local extend = Class.extend
local getStageDataByPos, setStageDataByPos = Smc.getStageDataByPos, Smc.setStageDataByPos
local require = Mod.getInfo('smc__core__craft_system').require local require = Mod.getInfo('smc__core__craft_system').require
---@type CraftSystem.ImmersiveCraftStage ---@type CraftSystem.ImmersiveCraftStage
@@ -11,6 +9,7 @@ local ImmersiveCraftStage = require('CraftSystem.ImmersiveCraftStage')
---@class CraftSystem.ImmersiveCraftStage.TappingStage : CraftSystem.ImmersiveCraftStage ---@class CraftSystem.ImmersiveCraftStage.TappingStage : CraftSystem.ImmersiveCraftStage
---@field targetItem string ---@field targetItem string
---@field clicksNeed string ---@field clicksNeed string
---@field toolGroup string?
---@field startHandler fun(self:CraftSystem.ImmersiveCraftStage.TappingStage, pos:MapPosition, Player:Player) ---@field startHandler fun(self:CraftSystem.ImmersiveCraftStage.TappingStage, pos:MapPosition, Player:Player)
---@field processHandler fun(self:CraftSystem.ImmersiveCraftStage.TappingStage, pos:MapPosition, Player:Player) ---@field processHandler fun(self:CraftSystem.ImmersiveCraftStage.TappingStage, pos:MapPosition, Player:Player)
---@field endHandler fun(self:CraftSystem.ImmersiveCraftStage.TappingStage, pos:MapPosition, Player:Player) ---@field endHandler fun(self:CraftSystem.ImmersiveCraftStage.TappingStage, pos:MapPosition, Player:Player)
@@ -23,11 +22,12 @@ local TappingStage = extend(ImmersiveCraftStage, {})
---@class CraftSystem.ImmersiveCraftStage.TappingStageDef : CraftSystem.ImmersiveCraftStageDef ---@class CraftSystem.ImmersiveCraftStage.TappingStageDef : CraftSystem.ImmersiveCraftStageDef
---@field targetItem string ---@field targetItem string
---@field clicksNeed string ---@field clicksNeed string
---@field toolGroup string?
---Data table for transferring various time parameters between calls. ---Data table for transferring various time parameters between calls.
--- ---
---**Only for EmmyLua.** ---**Only for EmmyLua.**
---@class ImmersiveStageData.TappingStageData : ImmersiveStageData ---@class CraftSystem.ImmersiveCraftStage.TappingStageData
---How many clicks were made by the player on the entity. ---How many clicks were made by the player on the entity.
---@field clickCount integer ---@field clickCount integer
---Unique identifier of the entity (craft node). ---Unique identifier of the entity (craft node).
@@ -39,13 +39,12 @@ function TappingStage:new(def)
local instance = ImmersiveCraftStage:new(def) local instance = ImmersiveCraftStage:new(def)
instance.targetItem = def.targetItem instance.targetItem = def.targetItem
instance.clicksNeed = def.clicksNeed instance.clicksNeed = def.clicksNeed
instance.toolGroup = def.toolGroup
-- Registering the crafting stage start handler. -- Registering the crafting stage start handler.
instance.startHandler = function(tappingStage , pos, Player) instance.startHandler = function(tappingStage , pos, player)
-- We determine the coordinate where we will create the crafting node (entity). local entityPos = vector.new(pos) + vector.new(0,0.875,0)
local entityPos = vector.new(pos) + vector.new(0,0.8,0)
-- We create a table of initial parameters that we will pass to the entity.
---@class CraftSystem.ImmersiveCraftStage.TappingNode.InitParams ---@class CraftSystem.ImmersiveCraftStage.TappingNode.InitParams
local params = { local params = {
targetItem = tappingStage.targetItem, targetItem = tappingStage.targetItem,
@@ -54,96 +53,95 @@ function TappingStage:new(def)
WorkStationPos = pos, WorkStationPos = pos,
} }
-- Adding an entity to the world.
local obj = core.add_entity(entityPos, 'craft_system:tapping_node', core.serialize(params)) local obj = core.add_entity(entityPos, 'craft_system:tapping_node', core.serialize(params))
-- If the entity was not returned, something went wrong.
if obj == nil then if obj == nil then
return return
end end
-- Create a temporary table of crafting stage data. ---@type CraftSystem.ImmersiveCraftStage.TappingStageData
---@type ImmersiveStageData.TappingStageData
local stageData = { local stageData = {
clickCount = 0, clickCount = 0,
entityGUID = obj:get_guid() entityGUID = obj:get_guid()
} }
-- Saving temporary data in work station metadata. --@type ImmersiveWorkStation.MetaData
setStageDataByPos(pos, stageData) local meta = core.get_meta(pos)
meta:set_string('stage_data', core.serialize(stageData))
end end
-- Registering the crafting stage process handler. -- Registering the crafting stage process handler.
-- Called when a player clicks on a crafting node (entity). -- Called when a player clicks on a crafting node (entity).
instance.processHandler = function(tappingStage, pos, Player) instance.processHandler = function(tappingStage, pos, player)
-- Obtaining stage time data from work station metadata. ---@type ImmersiveWorkStation.MetaData
---@type ImmersiveStageData.TappingStageData? local meta = core.get_meta(pos)
local stageData = getStageDataByPos(pos) ---@type CraftSystem.ImmersiveCraftStage.TappingStageData?
assert(stageData ~= nil, 'Immersive stage data is empty.') local stageData = core.deserialize(meta:get_string('stage_data'))
assert(stageData ~= nil)
-- Increasing the click counter
local clickCount = stageData.clickCount local clickCount = stageData.clickCount
clickCount = clickCount + 1 clickCount = clickCount + 1
-- If the number of clicks is greater than required to complete the step...
if clickCount >= tappingStage.clicksNeed then if clickCount >= tappingStage.clicksNeed then
-- ...we are completing the stage. tappingStage:endHandler(pos, player)
tappingStage:endHandler(pos, Player)
else else
-- ...else we save the number of clicks in the temporary data table.
stageData.clickCount = clickCount stageData.clickCount = clickCount
Smc.setStageDataByPos(pos, stageData) meta:set_string('stage_data', core.serialize(stageData))
end end
end end
-- Registering the crafting stage end handler. -- Registering the crafting stage end handler.
instance.endHandler = function(tappingStage, pos, Player) instance.endHandler = function(tappingStage, pos, player)
-- Obtaining stage time data from work station metadata. ---@type ImmersiveWorkStation.MetaData
---@type ImmersiveStageData.TappingStageData? local meta = core.get_meta(pos)
local stageData = getStageDataByPos(pos) ---@type CraftSystem.ImmersiveCraftStage.TappingStageData?
assert(stageData ~= nil, 'Immersive stage data is empty.') local stageData = core.deserialize(meta:get_string('stage_data'))
assert(stageData ~= nil)
-- We get the entity object.
local entity = Smc.getObjectByGUID(stageData.entityGUID) local entity = Smc.getObjectByGUID(stageData.entityGUID)
assert(entity ~= nil, 'The entity for immersive crafting is nil.') assert(entity ~= nil, 'The entity for immersive crafting is nil.')
-- Removing an entity from the world.
entity:remove() entity:remove()
-- We trigger an event that the crafting stage has been completed. Events.call('craft_system:next_immersive_stage:'..tappingStage.craftName, tappingStage, pos, player)
Events.call('craft_system:next_immersive_stage:'..tappingStage.craftName, tappingStage, pos, Player)
end end
-- Registering the aborting the crafting process handler. -- Registering the aborting the crafting process handler.
---@param tappingStage CraftSystem.ImmersiveCraftStage.TappingStage ---@param tappingStage CraftSystem.ImmersiveCraftStage.TappingStage
instance.abortHandler = function(tappingStage, pos, Player) instance.abortHandler = function(tappingStage, pos)
-- We receive current data on crafting. ---@type ImmersiveWorkStation.MetaData
---@type ImmersiveCraftData? local meta = core.get_meta(pos)
local craftData = Smc.getCraftDataByPos(pos) ---@type CraftSystem.ImmersiveCraftStage.TappingStageData?
assert(craftData ~= nil, 'Immersive crafting data is empty.') local stageData = core.deserialize(meta:get_string('stage_data'))
assert(stageData ~= nil)
local amount = meta:get_float('craft_amount')
assert(amount ~= 0)
-- Obtaining stage time data from work station metadata. ---@type CraftSystem.ImmersiveCraftStage.TappingStageData?
---@type ImmersiveStageData.TappingStageData? local stageData = stageData
local stageData = craftData.stageData
assert(stageData ~= nil, 'Immersive stage data is empty.') assert(stageData ~= nil, 'Immersive stage data is empty.')
-- We get the entity object.
local entity = Smc.getObjectByGUID(stageData.entityGUID) local entity = Smc.getObjectByGUID(stageData.entityGUID)
assert(entity ~= nil, 'The entity for immersive crafting is nil.') assert(entity ~= nil, 'The entity for immersive crafting is nil.')
-- Removing an entity from the world.
entity:remove() entity:remove()
-- We drop the item as it was before processing. -- We drop the item as it was before processing.
local dropPos = vector.new(pos)+vector.new(0, 0.9,0) local dropPos = vector.new(pos)+vector.new(0, 0.9,0)
for i=1, craftData.amount do for i=1, amount do
core.item_drop(ItemStack(tappingStage.targetItem), nil, dropPos) core.item_drop(ItemStack(tappingStage.targetItem), nil, dropPos)
end end
end end
-- Returns a human-readable description of the crafting stage. -- Returns a human-readable description of the crafting stage.
instance.toString = function(tappingStage) instance.toString = function(tappingStage)
local stageDesc = ('Tapping x%s'):format(tappingStage.clicksNeed) local stageDesc
if tappingStage.toolGroup ~= nil then
stageDesc = ('Tapping x%s tool with a group "%s"'):format(tappingStage.clicksNeed, tappingStage.toolGroup)
else
stageDesc = ('Tapping x%s'):format(tappingStage.clicksNeed)
end
return stageDesc return stageDesc
end end
@@ -151,7 +149,15 @@ function TappingStage:new(def)
-- Subscribe to an event that means the player hit the entity. -- Subscribe to an event that means the player hit the entity.
Events.subscribe(('craft_system:punch_tapping_node:%s:%s'):format(instance.craftName, instance.name), Events.subscribe(('craft_system:punch_tapping_node:%s:%s'):format(instance.craftName, instance.name),
---@param craftNode LuaEntity ---@param craftNode LuaEntity
function(eventName, pos, Player, craftNode) ---@param player Player
function(eventName, pos, player, craftNode)
local toolDef = player:get_wielded_item():get_definition()
-- If a crafting stage requires a specific tool group and he doesn't have it then we don't do anything.
if instance.toolGroup and (not toolDef.groups or not toolDef.groups[instance.toolGroup]) then
return
end
-- DRAFT START: -- DRAFT START:
-- Creating particles -- Creating particles
for i=0, 10 do for i=0, 10 do
@@ -171,8 +177,7 @@ function TappingStage:new(def)
core.after(0.2, function() craftNode.object:set_rotation(vector.new(0,0,0))end) core.after(0.2, function() craftNode.object:set_rotation(vector.new(0,0,0))end)
-- DRAFT END -- DRAFT END
-- Calling the crafting stage process handler. instance:processHandler(pos, player)
instance:processHandler(pos, Player)
end) end)
return instance return instance

View File

@@ -7,31 +7,22 @@ local require = modInfo.require
local BaseCraft = require('CraftSystem.BaseCraft') local BaseCraft = require('CraftSystem.BaseCraft')
---@class CraftSystem.PrimitiveCraft : CraftSystem.BaseCraft ---@class CraftSystem.PrimitiveCraft : CraftSystem.BaseCraft
---@field output string ---@field returnItems ItemStackString[]?
---@field recipe CraftSystem.CraftRecipe local PrimitiveCraft = BaseCraft:extend({})
---@field returnItems ItemStackString[]
local PrimitiveCraft = extend(BaseCraft, {})
---Definition table for the `CraftSystem.PrimitiveCraft`. ---Definition table for the `CraftSystem.PrimitiveCraft`.
--- ---
---**Only for EmmyLua.** ---**Only for EmmyLua.**
---@class CraftSystem.PrimitiveCraftDef : CraftSystem.BaseCraftDef ---@class CraftSystem.PrimitiveCraftDef : CraftSystem.BaseCraftDef
---@field output string ---@field returnItems ItemStackString[]?
---@field recipe CraftSystem.CraftRecipe
---@field returnItems ItemStackString[]
---@param name string ---@param name string
---@param def CraftSystem.PrimitiveCraftDef ---@param def CraftSystem.PrimitiveCraftDef
---@return CraftSystem.PrimitiveCraft ---@return CraftSystem.PrimitiveCraft
function PrimitiveCraft:new(name, def) function PrimitiveCraft:new(name, def)
---@type CraftSystem.PrimitiveCraft ---@type CraftSystem.PrimitiveCraft
local instance = getInstance(self, { local instance = self:getInstance(BaseCraft:new(name, def))
name = name, instance.returnItems = def.returnItems
group = def.group,
output = def.output,
recipe = def.recipe,
returnItems = def.returnItems or {}
})
return instance return instance
end end

View File

@@ -1,6 +1,6 @@
local extend = Class.extend local extend = Class.extend
local tableInsert = table.insert local tableInsert, tableSort, tableJoin = table.insert, table.sort, table.join
local modInfo = Mod.getInfo('smc__core__craft_system') local modInfo = Mod.getInfo('smc__core__craft_system')
local require = modInfo.require local require = modInfo.require
@@ -14,10 +14,19 @@ local PrimitiveCraft = require('CraftSystem.PrimitiveCraft')
---A primitive crafting processor that doesn't require much interaction and provides ---A primitive crafting processor that doesn't require much interaction and provides
---simple crafting based on a recipe-result scheme. ---simple crafting based on a recipe-result scheme.
---@class CraftSystem.PrimitiveCraftHandler : CraftSystem.BaseCraftHandler ---@class CraftSystem.PrimitiveCraftHandler : CraftSystem.BaseCraftHandler
---@field defaultCraftDef CraftSystem.PrimitiveCraftDef
---
---@field craftsByGroup table<CraftSystem.CraftGroup, CraftSystem.PrimitiveCraft[]>
---@field groupedCrafts (CraftSystem.PrimitiveCraft[]|CraftSystem.PrimitiveCraft)[]
---
---@field new fun(self:CraftSystem.PrimitiveCraftHandler, baseType:CraftSystem.BaseCraftType, type:CraftSystem.PrimitiveCraftType, def:CraftSystem.PrimitiveCraftHandlerDef):CraftSystem.PrimitiveCraftHandler
---@field getCraftByName fun(self, craftName:string):CraftSystem.PrimitiveCraft ---@field getCraftByName fun(self, craftName:string):CraftSystem.PrimitiveCraft
---@field getCraftsByGroup fun(self, craftGroup):CraftSystem.PrimitiveCraft[] ---@field getCraftsByGroup fun(self, craftGroup:string):CraftSystem.PrimitiveCraft[]
---@field getLearnedCrafts fun(self, playerName):table<string, CraftSystem.PrimitiveCraft> ---@field getLearnedCrafts fun(self, playerName:string):(CraftSystem.PrimitiveCraft[]|CraftSystem.PrimitiveCraft)[]
local PrimitiveCraftHandler = extend(BaseCraftHandler, {}) local PrimitiveCraftHandler = BaseCraftHandler:extend({})
---@class CraftSystem.PrimitiveCraftHandlerDef : CraftSystem.BaseCraftHandlerDef
---@field defaultCraftDef CraftSystem.PrimitiveCraftDef?
---Register a primitive craft that does not require special interaction. ---Register a primitive craft that does not require special interaction.
---@param craftName string ---@param craftName string
@@ -26,9 +35,12 @@ function PrimitiveCraftHandler:registerCraft(craftName, def)
assert(self.craftsByName[craftName] == nil, ('A craft named `%s` already exists.'):format( assert(self.craftsByName[craftName] == nil, ('A craft named `%s` already exists.'):format(
craftName)) craftName))
local craft = PrimitiveCraft:new(craftName, def) local def = table.merge(def, self.defaultCraftDef)
local group = def.group local group = 'craft_group:' .. (def.group or 'UNDEFINED')
def.group = group
local craft = PrimitiveCraft:new(craftName, def)
if self.craftsByGroup[group] == nil then if self.craftsByGroup[group] == nil then
self.craftsByGroup[group] = {} self.craftsByGroup[group] = {}
@@ -39,4 +51,42 @@ function PrimitiveCraftHandler:registerCraft(craftName, def)
tableInsert(self.craftsList, craft) tableInsert(self.craftsList, craft)
end end
---Adds alternative recipes to the craft with the specified name.
---
---If a craft with the specified name does not exist, an error will call.
---@param craftName string
---@param recipes CraftSystem.CraftRecipe[]
function PrimitiveCraftHandler:registerAlternativeRecipes(craftName, recipes)
local craft = PrimitiveCraftHandler:getCraftByName(craftName)
craft.altRecipes = tableJoin(craft.altRecipes or {}, recipes)
end
-- Sort the list of crafts in alphabetical order by product name and combine crafts into groups.
-- Provides a convenient list of crafting items in the player's inventory.
core.register_on_mods_loaded(function()
for groupName, crafts in pairs(PrimitiveCraftHandler.craftsByGroup) do
tableSort(crafts, function(a, b)
if a.output < b.output then
return true
end
end)
if groupName ~= 'craft_group:UNDEFINED' then
tableInsert(PrimitiveCraftHandler.groupedCrafts, crafts)
else
PrimitiveCraftHandler.groupedCrafts = tableJoin(PrimitiveCraftHandler.groupedCrafts, crafts)
end
end
tableSort(PrimitiveCraftHandler.groupedCrafts, function(a, b)
local outputA = (a[1] and a[1].output) or a.output
local outputB = (b[1] and b[1].output) or b.output
if outputA < outputB then
return true
end
end)
end)
return PrimitiveCraftHandler return PrimitiveCraftHandler

View File

@@ -0,0 +1,41 @@
local getInstance, extend = Class.getInstance, Class.extend
local modInfo = Mod.getInfo('smc__core__craft_system')
local require = modInfo.require
---@type CraftSystem.BaseCraft
local BaseCraft = require('CraftSystem.BaseCraft')
---@class CraftSystem.ProcessingCraft : CraftSystem.BaseCraft
---@field recipe CraftSystem.CraftRecipe
---@field time number
---@field startHandler fun()
---@field processHandler fun()
---@field endHandler fun()
local ProcessingCraft = BaseCraft:extend({})
---Definition table for the `CraftSystem.ProcessingCraft`.
---
---**Only for EmmyLua.**
---@class CraftSystem.ProcessingCraftDef : CraftSystem.BaseCraftDef
---@field recipe CraftSystem.CraftRecipe
---@field time number
---@field startHandler fun()?
---@field processHandler fun()?
---@field endHandler fun()?
---@param name string
---@param def CraftSystem.ProcessingCraftDef
---@return CraftSystem.ProcessingCraft
function ProcessingCraft:new(name, def)
---@type CraftSystem.ProcessingCraft
local instance = self:getInstance(BaseCraft:new(name, def))
instance.time = def.time
instance.startHandler = def.startHandler or function() end
instance.processHandler = def.processHandler or function() end
instance.endHandler = def.endHandler or function() end
return instance
end
return ProcessingCraft

View File

@@ -0,0 +1,89 @@
local HASH_SEPARATOR = ','
local tableInsert, tableCopy, tableSort, tableConcat, tableIsEmpty = table.insert, table.copy, table.sort, table.concat, table.is_empty
local modInfo = Mod.getInfo('smc__core__craft_system')
local require = modInfo.require
---@type CraftSystem.BaseCraftHandler
local BaseCraftHandler = require('CraftSystem.BaseCraftHandler')
---@type CraftSystem.ProcessingCraft
local ProcessingCraft = require('CraftSystem.ProcessingCraft')
---A primitive crafting processor that doesn't require much interaction and provides
---simple crafting based on a recipe-result scheme.
---@class CraftSystem.ProcessingCraftHandler : CraftSystem.BaseCraftHandler
---@field defaultCraftDef CraftSystem.ProcessingCraftDef
---
---@field craftsByHash table<string, CraftSystem.ProcessingCraft>
---
---@field new fun(self:CraftSystem.ProcessingCraftHandler, baseType:CraftSystem.BaseCraftType, type:CraftSystem.ProcessingCraftType, def:CraftSystem.ProcessingCraftHandlerDef):CraftSystem.ProcessingCraftHandler
---@field getCraftByName fun(self, craftName:string):CraftSystem.ProcessingCraft
---@field getCraftsByGroup fun(self, craftGroup:string):CraftSystem.ProcessingCraft[]
---@field getLearnedCrafts fun(self, playerName:string):(CraftSystem.ProcessingCraft[]|CraftSystem.ProcessingCraft)[]
local ProcessingCraftHandler = BaseCraftHandler:extend({
craftsByHash = {}
})
---@class CraftSystem.ProcessingCraftHandlerDef : CraftSystem.BaseCraftHandlerDef
---@field defaultCraftDef CraftSystem.ProcessingCraftDef?
---@param recipe CraftSystem.CraftRecipe
local function getCraftHash(recipe)
recipe = tableCopy(recipe)
tableSort(recipe)
return tableConcat(recipe, HASH_SEPARATOR)
end
---Register a primitive craft that does not require special interaction.
---@param craftName string
---@param def CraftSystem.ProcessingCraftDef
function ProcessingCraftHandler:registerCraft(craftName, def)
assert(self.craftsByName[craftName] == nil, ('A craft named `%s` already exists.'):format(
craftName))
local def = table.merge(def, self.defaultCraftDef)
local group = 'craft_group:' .. (def.group or 'UNDEFINED')
def.group = group
local craft = ProcessingCraft:new(craftName, def)
if self.craftsByGroup[group] == nil then
self.craftsByGroup[group] = {}
end
local craftHash = getCraftHash(craft.recipe)
assert(self.craftsByHash[craftHash] == nil, 'A craft with this recipe already exists.')
self.craftsByName[craftName] = craft
tableInsert(self.craftsByGroup[group], craft)
tableInsert(self.craftsList, craft)
self.craftsByHash[craftHash] = craft
end
---@param input ItemStack[]
---@return CraftSystem.ProcessingCraft?
function ProcessingCraftHandler:getCraftByRecipe(input)
local recipe = {}
for _, item in ipairs(input) do
if not item:is_empty() then
tableInsert(recipe, item:get_name())
end
end
if tableIsEmpty(recipe) then
return nil
end
-- TODO: добавить поиск по группам крафтов
local craftHash = getCraftHash(recipe)
local craft = self.craftsByHash[craftHash]
return craft
end
return ProcessingCraftHandler

View File

@@ -203,6 +203,24 @@ function Formspec:list(inventoryLocation, listName, x, y, w, h, startingItemInde
return self return self
end end
---A wrapper around `Formspec:list` that allows access to the inventory of a node,
---specified by the coordinates of its position in the world.
---@param nodePos MapPosition
---@param listName string
---@param x number
---@param y number
---@param w number Are in inventory slots, not in coordinates.
---@param h number Are in inventory slots, not in coordinates.
---@param startingItemIndex number? The index of the first (upper-left) item to draw. Indices start at `0`. Default is `0`.
---@return Formspec
function Formspec:listNodeMetaLocation(nodePos, listName, x, y, w, h, startingItemIndex)
local inventoryLocation = ('nodemeta:%s,%s,%s'):format(nodePos.x, nodePos.y, nodePos.z)
self:list(inventoryLocation, listName, x, y, w, h, startingItemIndex)
return self
end
---Creates and appends a list of `listring[<inventory location>;<list name>]` items based on the passed inventory list. ---Creates and appends a list of `listring[<inventory location>;<list name>]` items based on the passed inventory list.
--- ---
---**Elements:** `listring[<inventory location>;<list name>]` or `listring[]` ---**Elements:** `listring[<inventory location>;<list name>]` or `listring[]`
@@ -296,7 +314,7 @@ end
---@param w number ---@param w number
---@param h number ---@param h number
---@param textureName string ---@param textureName string
---@param middle boolean? Makes the image render in 9-sliced mode and defines the middle rect. ---@param middle string? Makes the image render in 9-sliced mode and defines the middle rect.
---@return Formspec ---@return Formspec
function Formspec:image(x, y, w, h, textureName, middle) function Formspec:image(x, y, w, h, textureName, middle)
local element = ('image[%s,%s;%s,%s;%s;%s]'):format( local element = ('image[%s,%s;%s,%s;%s;%s]'):format(
@@ -441,7 +459,7 @@ end
--- * All numbers in middle are integers. --- * All numbers in middle are integers.
---@return Formspec ---@return Formspec
function Formspec:background9(x, y, w, h, textureName, autoClip, middle) function Formspec:background9(x, y, w, h, textureName, autoClip, middle)
local element = ('background9[%s,%s;%s,%s;%s;%s]'):format( local element = ('background9[%s,%s;%s,%s;%s;%s;%s]'):format(
x, y, w, h, textureName, autoClip, middle) x, y, w, h, textureName, autoClip, middle)
self:addElement(element) self:addElement(element)
@@ -491,7 +509,7 @@ end
---@return Formspec ---@return Formspec
function Formspec:field(x, y, w, h, name, label, default) function Formspec:field(x, y, w, h, name, label, default)
local element = ('field[%s,%s;%s,%s;%s;%s;%s]'):format( local element = ('field[%s,%s;%s,%s;%s;%s;%s]'):format(
x, y, w, h, name, label or '', default or '') x, y, w, h, name, label or '', core.formspec_escape(default) or '')
self:addElement(element) self:addElement(element)
return self return self
@@ -545,7 +563,7 @@ end
--- Defaults to true when not specified (i.e. no tag for a field). --- Defaults to true when not specified (i.e. no tag for a field).
---@return Formspec ---@return Formspec
function Formspec:fieldCloseOnEnter(name, closeOnEnter) function Formspec:fieldCloseOnEnter(name, closeOnEnter)
local element = ('field_enter_after_edit[%s;%s]'):format( local element = ('field_close_on_enter[%s;%s]'):format(
name, closeOnEnter or false) name, closeOnEnter or false)
self:addElement(element) self:addElement(element)
@@ -572,7 +590,7 @@ end
---@return Formspec ---@return Formspec
function Formspec:textArea(x, y, w, h, name, label, default) function Formspec:textArea(x, y, w, h, name, label, default)
local element = ('textarea[%s,%s;%s,%s;%s;%s;%s]'):format( local element = ('textarea[%s,%s;%s,%s;%s;%s;%s]'):format(
x, y, w, h, name or '', label or '', default or '') x, y, w, h, name or '', label or '', core.formspec_escape(default) or '')
self:addElement(element) self:addElement(element)
return self return self
@@ -592,7 +610,7 @@ end
---@return Formspec ---@return Formspec
function Formspec:label(x, y, label) function Formspec:label(x, y, label)
local element = ('label[%s,%s;%s]'):format( local element = ('label[%s,%s;%s]'):format(
x, y, label) x, y, core.formspec_escape(label))
self:addElement(element) self:addElement(element)
return self return self
@@ -612,7 +630,7 @@ end
---@return Formspec ---@return Formspec
function Formspec:areaLabel(x, y, w, h, label) function Formspec:areaLabel(x, y, w, h, label)
local element = ('label[%s,%s;%s,%s;%s]'):format( local element = ('label[%s,%s;%s,%s;%s]'):format(
x, y, w, h, label) x, y, w, h, core.formspec_escape(label))
self:addElement(element) self:addElement(element)
return self return self
@@ -646,7 +664,7 @@ end
---@return Formspec ---@return Formspec
function Formspec:vertlabel(x, y, label) function Formspec:vertlabel(x, y, label)
local element = ('vertlabel[%s,%s;%s]'):format( local element = ('vertlabel[%s,%s;%s]'):format(
x, y, label) x, y, core.formspec_escape(label))
self:addElement(element) self:addElement(element)
return self return self
@@ -700,7 +718,7 @@ end
--- ---
---**Elements:** `image_button[<X>,<Y>;<W>,<H>;<texture name>;<name>;<label>]` or ---**Elements:** `image_button[<X>,<Y>;<W>,<H>;<texture name>;<name>;<label>]` or
---`image_button[<X>,<Y>;<W>,<H>;<texture name>;<name>;<label>;<noclip>;<drawborder>;<pressed texture name>]` ---`image_button[<X>,<Y>;<W>,<H>;<texture name>;<name>;<label>;<noclip>;<drawborder>;<pressed texture name>]`
---@overload fun(x:number, y:number, w:number, h:number, textureName:string, name:string, label:string) ---@overload fun(x:number, y:number, w:number, h:number, textureName:string, name:string, label:string?):Formspec
---@param x number ---@param x number
---@param y number ---@param y number
---@param w number ---@param w number
@@ -708,7 +726,7 @@ end
---@param textureName string Is the filename of an image. ---@param textureName string Is the filename of an image.
---@param name string ---@param name string
---@param label string? ---@param label string?
---@param pressedTextureName string Is the filename of an image on pressed state. ---@param pressedTextureName string? Is the filename of an image on pressed state.
---@param noclip boolean? Means the image button doesn't need to be within specified formsize. Default: `true` ---@param noclip boolean? Means the image button doesn't need to be within specified formsize. Default: `true`
---@param drawborder boolean? Draw button border or not. Default `false` ---@param drawborder boolean? Draw button border or not. Default `false`
---@return Formspec ---@return Formspec
@@ -720,7 +738,7 @@ function Formspec:imageButton(x, y, w, h, textureName, name, label, pressedTextu
x, y, w, h, textureName, name, label or '') x, y, w, h, textureName, name, label or '')
else else
element = ('image_button[%s,%s;%s,%s;%s;%s;%s;%s;%s;%s]'):format( element = ('image_button[%s,%s;%s,%s;%s;%s;%s;%s;%s;%s]'):format(
x, y, w, h, textureName, name, label or '', pressedTextureName, noclip or true, drawborder or false) x, y, w, h, textureName, name, label or '', noclip or true, drawborder or false, pressedTextureName)
end end
self:addElement(element) self:addElement(element)

View File

@@ -0,0 +1,4 @@
local modInfo = Mod.getInfo('smc__core__immersive_work_station')
local require = modInfo.require
return require('ImmersiveWorkStation')

View File

@@ -1,2 +1,2 @@
name = smc__core__work_station name = smc__core__immersive_work_station
depends = smc__core__craft_system, smc__core__node, smc__ui__work_station depends = smc__core__craft_system, smc__core__node, smc__ui__work_station

View File

@@ -0,0 +1,218 @@
local getInstance = Class.getInstance
local CraftSystem = Smc.requireCraftSystem()
local PlayerInventoryUI = Smc.requirePlayerInventoryUI()
local Node = Smc.requireNode()
-- Default settings that a work station node should have.
local ImmersiveWorkStationNode = Node:getExtended({
settings = {
name = '',
drawtype = 'normal',
paramtype = 'light',
groups = { immersive_station = 1, dig_immediate = 2 }
}
})
---A work station (node) that enables player interaction
---with the immersive crafting mechanics.
---@class ImmersiveWorkStation
---@field name string
---@field craftType CraftSystem.ImmersiveCraftType
---@field handler CraftSystem.ImmersiveCraftHandler
---@field tab PlayerInventoryUI.getTabFunc
local ImmersiveWorkStation = {}
---Definition table for the `ImmersiveWorkStation`.
---
---**Only for EmmyLua.**
---@class ImmersiveWorkStationDef
---@field craftType CraftSystem.ImmersiveCraftType
---@field tab PlayerInventoryUI.getTabFunc
---@param name string
---@param def ImmersiveWorkStationDef
---@param nodeDef Node.NodeDefinition
function ImmersiveWorkStation:new(name, def, nodeDef)
local handler = CraftSystem:getImmersiveCraftHandler(def.craftType)
---@type ImmersiveWorkStation
local instance = getInstance(self, {})
instance.name = name
instance.craftType = def.craftType
instance.handler = handler
instance.tab = def.tab
if nodeDef.callbacks == nil then
---@type Node.Callbacks
nodeDef.callbacks = {}
end
local settings = nodeDef.settings
local callbacks = nodeDef.callbacks
-- Callback when the work station block is installed in the world
-- Ensures initialization of necessary parameters
callbacks.on_construct = function(pos)
instance:init(pos)
end
-- Callback for interaction with a work station (start of crafting)
callbacks.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
instance:showForm(pos, clicker)
end
callbacks.on_punch = function(pos, node, puncher, pointed_thing)
instance:abortCraft(pos)
end
callbacks.on_dig = function(pos, node, digger)
---@type ImmersiveWorkStation.MetaData
local meta = core.get_meta(pos)
local craftName = meta:get_string('craft_name')
if craftName == '' then
return core.node_dig(pos, node, digger)
else
return false
end
end
-- Registering a node for Luanti.
ImmersiveWorkStationNode:new(nodeDef)
return instance
end
function ImmersiveWorkStation:showForm(pos, player)
local playerName = player:get_player_name()
---@type ImmersiveWorkStation.MetaData
local meta = core.get_meta(pos)
local craftName = meta:get_string('craft_name')
if craftName ~= '' then
core.chat_send_player(playerName, 'The workbench is occupied by another craft.')
return
end
PlayerInventoryUI:addActiveNodeForm(pos, playerName)
PlayerInventoryUI:setContex(playerName, 'left_tab_name', 'node_tab')
PlayerInventoryUI:setContex(playerName, 'node_tab_pos', pos)
PlayerInventoryUI:setContex(playerName, 'node_tab', self.tab)
PlayerInventoryUI:showForm(playerName)
end
---@param pos MapPosition
function ImmersiveWorkStation:init(pos)
---@type ImmersiveWorkStation.MetaData
local meta = core.get_meta(pos)
end
---@param pos MapPosition
function ImmersiveWorkStation:abortCraft(pos)
---@type ImmersiveWorkStation.MetaData
local meta = core.get_meta(pos)
local craftName = meta:get_string('craft_name')
if craftName == '' then
return
end
local craft = self.handler:getCraftByName(craftName)
craft:abortCraft(pos)
end
-- --- DEBUG ---
local handler = CraftSystem:getImmersiveCraftHandler('workbench')
local require = Mod.getInfo('smc__ui__player_inventory').require
local baseGetCraftTab = require('PlayerInventoryUI.baseGetCraftTab')
---@param self PlayerInventoryUI
---@param playerName string
---@param tabType PlayerInventoryUI.TabType
---@return Formspec
local function tab(self, playerName, tabType)
return baseGetCraftTab(self, playerName, tabType, 'node_tab', handler)
end
ImmersiveWorkStation:new('test_station', {
craftType = 'workbench',
tab = tab,
},
{
settings = {
name = 'test_station',
tiles = {'test_station.png'}
}
}
)
handler:registerCraft('bricks', {
output = 'rocks:sylite_bricks',
recipe = {'rocks:sylite'},
startStageName = 'tapping',
group = 'test',
stages = {
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping',
targetItem = 'rocks:sylite',
type = 'tapping',
clicksNeed = 3,
nextStage = 'tapping_2',
},
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping_2',
targetItem = 'rocks:sylite_block',
type = 'tapping',
clicksNeed = 5,
nextStage = 'tapping_3',
},
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping_3',
targetItem = 'rocks:sylite_bricks',
type = 'tapping',
clicksNeed = 1,
}
},
})
handler:registerCraft('block', {
output = 'rocks:sylite_block',
recipe = {'rocks:sylite'},
startStageName = 'tapping',
group = 'test',
stages = {
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping',
targetItem = 'rocks:sylite',
type = 'tapping',
clicksNeed = 5,
}
},
})
handler:registerCraft('marentine_planks', {
output = 'wood:marentine_planks',
recipe = {'rocks:sylite'},
startStageName = 'tapping',
group = 'test',
stages = {
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping',
targetItem = 'wood:marentine_log',
type = 'tapping',
clicksNeed = 5,
}
},
})
--]]
return ImmersiveWorkStation

View File

@@ -0,0 +1,9 @@
---@alias ImmersiveWorkStation.MetaData.StringKey 'player_name'|'craft_name'|'stage_name'|'stage_data'
---@alias ImmersiveWorkStation.MetaData.FloatKey 'craft_amount'
---**Only for EmmyLua.**
---@class ImmersiveWorkStation.MetaData : NodeMetaRef
---@field get_string fun(self, key:ImmersiveWorkStation.MetaData.StringKey):string
---@field set_string fun(self, key:ImmersiveWorkStation.MetaData.StringKey, value:string)
---@field get_float fun(self, key:ImmersiveWorkStation.MetaData.FloatKey):number
---@field set_float fun(self, key:ImmersiveWorkStation.MetaData.FloatKey, value:number)

View File

Before

Width:  |  Height:  |  Size: 1.2 KiB

After

Width:  |  Height:  |  Size: 1.2 KiB

View File

@@ -2,10 +2,15 @@ local getInstance, extend = Class.getInstance, Class.extend
local tableCopy, tableMerge, colorize = table.copy, table.merge, core.colorize local tableCopy, tableMerge, colorize = table.copy, table.merge, core.colorize
local modInfo = Mod.getInfo('smc__core__item') local ItemFactory = Smc.requireItemFactory()
local require = modInfo.require
local ItemFactory = Mod.getInfo('smc__core__item_factory').require('ItemFactory') ---Colors the title according to the rarity of the item.
---
---Note: that if `true`, the `_title_color` will be ignored.
local TITLE_RARITY_COLOR = true
---Shows rarity on a separate line.
local SHOW_RARITY = false
---Determines whether common rarity will be shown in item descriptions or not. ---Determines whether common rarity will be shown in item descriptions or not.
local SHOW_COMMON_RARITY = true local SHOW_COMMON_RARITY = true
@@ -37,7 +42,7 @@ local RARITY_INDEX = {
---@class Item ---@class Item
---@field itemDef Item.ItemDefinition ---@field itemDef Item.ItemDefinition
---@field luantiDef ItemDefinition ---@field luantiDef ItemDefinition
---@field getVisual fun(): string ---@field getType fun():string
---@field defaultDef Item.ItemDefinition ---@field defaultDef Item.ItemDefinition
local Item = { local Item = {
defaultDef = { defaultDef = {
@@ -46,9 +51,10 @@ local Item = {
_title = '', _title = '',
_description = '', _description = '',
_title_color = '#FFFFFF', _title_color = '#FFFFFF',
_description_color = '#C0C0C0', _description_color = '#838383',
_rarity = 'common', _rarity = 'common',
_add_mod_name = true, _add_mod_name = true,
stack_max = 128,
}, },
callbacks = {} callbacks = {}
} }
@@ -59,6 +65,10 @@ local Item = {
---@param desc string ---@param desc string
---@return string ---@return string
local function addRarityToDesc(rarity, desc) local function addRarityToDesc(rarity, desc)
if not SHOW_RARITY then
return desc
end
if not SHOW_COMMON_RARITY and rarity == 'common' then if not SHOW_COMMON_RARITY and rarity == 'common' then
return desc return desc
end end
@@ -87,12 +97,10 @@ local function itemDefToLuantiDef(itemDef)
local modName = Mod.getInfo().shortName local modName = Mod.getInfo().shortName
local S = core.get_translator(modName) local S = core.get_translator(modName)
itemDef = tableCopy(itemDef)
local s = itemDef.settings local s = itemDef.settings
local c = itemDef.callbacks local c = itemDef.callbacks
local title = s._title local title, description = s._title, s._description
local description = s._description
if title == nil or title == '' then if title == nil or title == '' then
title = string.match(s.name, '%S:(%S+)')..'-title' title = string.match(s.name, '%S:(%S+)')..'-title'
@@ -102,28 +110,32 @@ local function itemDefToLuantiDef(itemDef)
description = string.match(s.name, '%S:(%S+)')..'-desc' description = string.match(s.name, '%S:(%S+)')..'-desc'
end end
assert(s._rarity ~= nil, 'The rarity of an item cannot be empty.')
if s._title_color ~= nil and s._description_color ~= nil then if s._title_color ~= nil and s._description_color ~= nil then
if TITLE_RARITY_COLOR then
title = colorize(RARITY_COLORS[s._rarity], S(title))
else
title = colorize(s._title_color, S(title)) title = colorize(s._title_color, S(title))
end
description = colorize(s._description_color, S(description)) description = colorize(s._description_color, S(description))
else else
error('Item description color parameters cannot be empty.') error('Item description color parameters cannot be empty.')
end end
assert(s._rarity ~= nil, 'The rarity of an item cannot be empty.')
local luantiDescription = addRarityToDesc(s._rarity, title..'\n '..description) local luantiDescription = addRarityToDesc(s._rarity, title..'\n '..description)
s._title = title s._title = title
s._description = description s._description = description
s.description = luantiDescription..core.get_background_escape_sequence('#110F13') s.description = luantiDescription..core.get_background_escape_sequence('#110F13')
local luantiDef = defMerge(s, c) local luantiDef = defMerge(s, c, true)
return luantiDef return luantiDef
end end
---@param luantiDef NodeDefinition ---@param luantiDef NodeDefinition
local function register3dItem(luantiDef) local function registerNode(luantiDef)
local name = luantiDef.name local name = luantiDef.name
luantiDef.name = nil luantiDef.name = nil
@@ -131,17 +143,19 @@ local function register3dItem(luantiDef)
end end
---@param luantiDef ItemDefinition ---@param luantiDef ItemDefinition
local function registerFlatItem(luantiDef) local function registerCraftitem(luantiDef)
local name = luantiDef.name local name = luantiDef.name
luantiDef.name = nil luantiDef.name = nil
core.register_craftitem(':'..name, luantiDef) core.register_craftitem(':'..name, luantiDef)
end end
---The alias `table.merge` for EmmyLua ---@param luantiDef ItemDefinition
---@type fun(...):(Item.ItemDefinition) local function registerTool(luantiDef)
local defMerge = function(...) local name = luantiDef.name
return tableMerge(...) luantiDef.name = nil
core.register_tool(':'..name, luantiDef)
end end
---@param itemDef Item.ItemDefinition|Node.NodeDefinition ---@param itemDef Item.ItemDefinition|Node.NodeDefinition
@@ -152,40 +166,49 @@ function Item:new(itemDef)
'Please note that the `description` field should not be used when registering an item. '.. 'Please note that the `description` field should not be used when registering an item. '..
'Use `_title` and `_description` instead.') 'Use `_title` and `_description` instead.')
-- Adding default parameters itemDef = tableCopy(itemDef)
itemDef = defMerge(itemDef, self.defaultDef, true)
-- Adding default parameterss
---@type Item.ItemDefinition
itemDef = tableMerge(itemDef, self.defaultDef, true)
local s = itemDef.settings local s = itemDef.settings
local shortModName = Mod.getInfo().shortName
if s._add_mod_name then if s._add_mod_name then
s.name = Mod.getInfo().shortName .. ':' .. s.name s.name = shortModName .. ':' .. s.name
end end
---@type Item ---@type Item
local instance = getInstance(self, {}) local instance = getInstance(self, {})
local luantiDef = itemDefToLuantiDef(itemDef) local luantiDef = itemDefToLuantiDef(itemDef)
local visual = itemDef.settings._visual local type = itemDef.settings._type
if visual == nil then if type == nil then
visual = 'item_2d' type = 'craftitem'
end end
itemDef.settings._visual = nil itemDef.settings._type = nil
if visual == 'item_3d' then if type == 'node' then
register3dItem(luantiDef) registerNode(luantiDef)
elseif type == 'craftitem' then
registerCraftitem(luantiDef)
elseif type == 'tool' then
registerTool(luantiDef)
else else
visual = 'item_2d' error(('Unknown item type: `%s`.'):format(type))
registerFlatItem(luantiDef)
end end
function instance:getVisual() function instance:getType()
return visual return type
end end
instance.itemDef = itemDef instance.itemDef = itemDef
instance.luantiDef = luantiDef instance.luantiDef = luantiDef
Smc.addRegisteredItem(shortModName, instance)
return instance return instance
end end
@@ -195,7 +218,7 @@ end
---@param defaultDef Item.ItemDefinition ---@param defaultDef Item.ItemDefinition
---@return Item ---@return Item
function Item:getExtended(defaultDef) function Item:getExtended(defaultDef)
defaultDef = defMerge(defaultDef, self.defaultDef) defaultDef = tableMerge(defaultDef, self.defaultDef, true)
---@type Item ---@type Item
local ChildClass = extend(self, { local ChildClass = extend(self, {
@@ -212,7 +235,7 @@ function Item:getFactory(defaultDef)
if defaultDef == nil then if defaultDef == nil then
defaultDef = self.defaultDef defaultDef = self.defaultDef
else else
defaultDef = defMerge(self.defaultDef, defaultDef) defaultDef = tableMerge(self.defaultDef, defaultDef, true)
end end
---@type ItemFactory ---@type ItemFactory

View File

@@ -33,8 +33,8 @@ Settings._title_color = nil
Settings._description_color = nil Settings._description_color = nil
---Visual node type. ---Visual node type.
---@type Item.Visual? ---@type Item.Type?
Settings._visual = nil Settings._type = nil
---Formal (lore) rarity of an item. Default `common`. ---Formal (lore) rarity of an item. Default `common`.
---@type Item.Rarity? ---@type Item.Rarity?
@@ -48,6 +48,27 @@ Settings._rarity = nil
---@type table<string,number>? ---@type table<string,number>?
Settings.groups = nil Settings.groups = nil
---The number of inventory slots that can be stored in an ItemStack.
---@type integer?
Settings._itemstack_inventory_size = nil
---The name of the texture that will be displayed as the background
---for the item when it is equipped on the player as a bag.
---@type string?
Settings._itemstack_inventory_background = nil
---Defines a list of group names that items
---with which can be placed in an item's inventory.
---
---If it is `nil`, then any items will be allowed except those disallowed in `_itemstack_inventory_disallowed_groups`.
---@type string[]?
Settings._itemstack_inventory_allowed_groups = nil
---Defines a list of group names that items
---with which cannot be placed in an item's inventory.
---@type string[]?
Settings._itemstack_inventory_disallowed_groups = nil
---Texture shown in the inventory GUI. ---Texture shown in the inventory GUI.

View File

@@ -0,0 +1 @@
---@alias Item.Type 'craftitem'|'node'|'tool'

View File

@@ -1 +0,0 @@
---@alias Item.Visual 'item_2d'|'item_3d'

File diff suppressed because it is too large Load Diff

View File

@@ -18,9 +18,10 @@ local getInstance = Class.getInstance
---@field generateTurf generateFunc ---@field generateTurf generateFunc
---@field generateSoil generateFunc ---@field generateSoil generateFunc
---@field generateBottom generateFunc ---@field generateBottom generateFunc
---@field postProcessing fun(self, mapGenerator:MapGen, factors:MapGen.factors, data:number[], data2:number[], index:number, x:number, y:number, z:number, nodeType:MapGen.nodeType, area:VoxelArea)?
local Biome = {} local Biome = {}
---@alias generateFunc fun(self, mapGenerator:MapGen, data:number[], index:number, x:number, y:number, z:number) ---@alias generateFunc fun(self, mapGenerator:MapGen, factors:MapGen.factors, data:number[], data2:number[], index:number, x:number, y:number, z:number)
---Definition table for the `MapGen.Biome`. ---Definition table for the `MapGen.Biome`.
--- ---
@@ -39,84 +40,98 @@ local Biome = {}
---@field generateTurf generateFunc? ---@field generateTurf generateFunc?
---@field generateSoil generateFunc? ---@field generateSoil generateFunc?
---@field generateBottom generateFunc? ---@field generateBottom generateFunc?
---@field postProcessing fun(self, mapGenerator:MapGen, factors:MapGen.factors, data:number[], data2:number[], index:number, x:number, y:number, z:number, nodeType:MapGen.nodeType, area:VoxelArea)?
-- Default generate functions -- Default generate functions
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param data2 number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateAir = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateAir = function(self, mapGenerator, factors, data, data2, index, x, y, z)
data[index] = mapGenerator.nodeIDs.air data[index] = mapGenerator.nodeIDs.air
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param data2 number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateCavernAir = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateCavernAir = function(self, mapGenerator, factors, data, data2, index, x, y, z)
self:generateAir(mapGenerator, data, index, x, y, z) self:generateAir(mapGenerator, factors, data, data2, index, x, y, z)
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param data2 number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateWater = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateWater = function(self, mapGenerator, factors, data, data2, index, x, y, z)
data[index] = mapGenerator.nodeIDs.water data[index] = mapGenerator.nodeIDs.water
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param data2 number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateRock = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateRock = function(self, mapGenerator, factors, data, data2, index, x, y, z)
data[index] = self.groundNodesIDs.rock data[index] = self.groundNodesIDs.rock
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param data2 number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateTurf = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateTurf = function(self, mapGenerator, factors, data, data2, index, x, y, z)
data[index] = self.groundNodesIDs.turf data[index] = self.groundNodesIDs.turf
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param data2 number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateSoil = function(self, mapGenerator,data, index, x, y, z) local defaultGenerateSoil = function(self, mapGenerator, factors, data, data2, index, x, y, z)
data[index] = self.groundNodesIDs.soil data[index] = self.groundNodesIDs.soil
end end
---@param self MapGen.Biome ---@param self MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param data2 number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateBottom = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateBottom = function(self, mapGenerator, factors, data, data2, index, x, y, z)
data[index] = self.groundNodesIDs.bottom data[index] = self.groundNodesIDs.bottom
end end
@@ -167,23 +182,23 @@ function Biome:new(name, def)
end end
---@type MapGen.Biome ---@type MapGen.Biome
local instance = getInstance(self, { local instance = getInstance(self, {})
name = name, instance.name = name
tempPoint = def.tempPoint, instance.tempPoint = def.tempPoint
humidityPoint = def.humidityPoint, instance.humidityPoint = def.humidityPoint
minY = def.minY, instance.minY = def.minY
maxY = def.maxY, instance.maxY = def.maxY
groundNodes = def.groundNodes, instance.groundNodes = def.groundNodes
groundNodesIDs = groundNodesIDs, instance.groundNodesIDs = groundNodesIDs
soilHeight = def.soilHeight, instance.soilHeight = def.soilHeight
generateAir = def.generateAir, instance.generateAir = def.generateAir
generateCavernAir = def.generateCavernAir, instance.generateCavernAir = def.generateCavernAir
generateWater = def.generateWater, instance.generateWater = def.generateWater
generateRock = def.generateRock, instance.generateRock = def.generateRock
generateSoil = def.generateSoil, instance.generateSoil = def.generateSoil
generateTurf = def.generateTurf, instance.generateTurf = def.generateTurf
generateBottom = def.generateBottom, instance.generateBottom = def.generateBottom
}) instance.postProcessing = def.postProcessing
return instance return instance
end end

View File

@@ -1,18 +1,20 @@
local getInstance = Class.getInstance local getInstance = Class.getInstance
---@class MapGen.Triangulation.Edge ---@class MapGen.Edge
---@field p1 MapGen.Peak ---@field p1 MapGen.Peak
---@field p2 MapGen.Peak ---@field p2 MapGen.Peak
---@field vec vector
local Edge = {} local Edge = {}
---@param p1 MapGen.Peak ---@param p1 MapGen.Peak
---@param p2 MapGen.Peak ---@param p2 MapGen.Peak
---@return MapGen.Triangulation.Edge ---@return MapGen.Edge
function Edge:new( p1, p2 ) function Edge:new( p1, p2 )
---@type MapGen.Triangulation.Edge ---@type MapGen.Edge
local instance = getInstance(self, { local instance = getInstance(self, {
p1 = p1, p1 = p1,
p2 = p2 p2 = p2,
vec = p2.pos - p1.pos
}, },
{ {
__tostring = self.toString, __tostring = self.toString,
@@ -29,14 +31,14 @@ function Edge:toString()
end end
---Returns true if the edges are equivalent. ---Returns true if the edges are equivalent.
---@param other MapGen.Triangulation.Edge ---@param other MapGen.Edge
---@return boolean ---@return boolean
function Edge:eq(other) function Edge:eq(other)
return self.p1 == other.p1 and self.p2 == other.p2 return self.p1 == other.p1 and self.p2 == other.p2
end end
---Returns true if the edges are similar. ---Returns true if the edges are similar.
---@param other MapGen.Triangulation.Edge ---@param other MapGen.Edge
---@return boolean ---@return boolean
function Edge:same(other) function Edge:same(other)
return (self.p1 == other.p1 and self.p2 == other.p2) return (self.p1 == other.p1 and self.p2 == other.p2)
@@ -46,14 +48,14 @@ end
---Returns the length of an edge. ---Returns the length of an edge.
---@return number ---@return number
function Edge:length() function Edge:length()
return (self.p1.getPeakPos() - self.p2.getPeakPos()):length() return (self.p1.pos - self.p2.pos):length()
end end
---Returns the vector of the point located in the middle of the edge. ---Returns the vector of the point located in the middle of the edge.
---@return vector ---@return vector
function Edge:getMidPoint() function Edge:getMidPoint()
local pos1 = self.p1:getPeakPos() local pos1 = self.p1.pos
local pos2 = self.p2:getPeakPos() local pos2 = self.p2.pos
return (pos1 + pos2 )/2 return (pos1 + pos2 )/2
end end

View File

@@ -7,7 +7,7 @@ local Peak = require('MapGen.Peak')
---Allows you to create a `MapGen.Peak` without specifying a noise parameter. ---Allows you to create a `MapGen.Peak` without specifying a noise parameter.
--- ---
---**WARNING: MUST NOT BE PARTICIPATED IN GENERATION** ---**WARNING: MUST NOT BE PARTICIPATED IN GENERATION**
---@class MapGen.Triangulation.FakePeak : MapGen.Peak ---@class MapGen.FakePeak : MapGen.Peak
---@field id number ---@field id number
---@field getPeakPos fun():vector ---@field getPeakPos fun():vector
local FakePeak = Class.extend(Peak, {}) local FakePeak = Class.extend(Peak, {})

View File

@@ -1,5 +1,13 @@
local getInstance = Class.getInstance local getInstance = Class.getInstance
local modInfo = Mod.getInfo('smc__core__map_gen')
local require = modInfo.require
---@type MapGen.Peak
local Peak = require('MapGen.Peak')
---@type MapGen.Triangle
local Triangle = require('MapGen.Triangle')
---@class MapGen.Layer ---@class MapGen.Layer
---@field name string ---@field name string
---@field minY integer ---@field minY integer
@@ -11,9 +19,10 @@ local getInstance = Class.getInstance
---@field waterLevel integer ---@field waterLevel integer
---@field calcTemp fun(self:MapGen.Layer, value:number, height:number):number ---@field calcTemp fun(self:MapGen.Layer, value:number, height:number):number
---@field calcHumidity fun(self:MapGen.Layer, value:number, height:number):number ---@field calcHumidity fun(self:MapGen.Layer, value:number, height:number):number
---@field peaksList {['landscape']:MapGen.Peak[],['temp']:MapGen.Peak[],['humidity']:MapGen.Peak[]} ---@field peaksList MapGen.Peak[]
---@field noisesByColor {['landscape']:table<ColorString, ValueNoise>,['temp']:table<ColorString, ValueNoise>,['humidity']:table<ColorString, ValueNoise>} ---@field peaksByPos table<string, MapGen.Peak>
---@field noisesParamsByColor {['landscape']:table<ColorString, NoiseParams>,['temp']:table<ColorString, NoiseParams>,['humidity']:table<ColorString, NoiseParams>} ---@field noisesByColor table<MapGen.Layer.Category, table<ColorString, ValueNoise>>
---@field noisesParamsByColor table<MapGen.Layer.Category, table<ColorString, NoiseParams>>
---@field biomesByName table<string, MapGen.Biome> ---@field biomesByName table<string, MapGen.Biome>
---@field biomesList MapGen.Biome[] ---@field biomesList MapGen.Biome[]
---@field biomesDiagram table ---@field biomesDiagram table
@@ -22,14 +31,10 @@ local getInstance = Class.getInstance
---@field cavernsByName table<string, MapGen.Cavern> ---@field cavernsByName table<string, MapGen.Cavern>
---@field cavernsList MapGen.Cavern[] ---@field cavernsList MapGen.Cavern[]
---@field regionsByName table<string, MapGen.Region> ---@field regionsByName table<string, MapGen.Region>
---@field trianglesList {['landscape']:MapGen.Triangle[],['temp']:MapGen.Triangle[],['humidity']:MapGen.Triangle[]} ---@field trianglesList MapGen.Triangle[]
---@field tetrahedronsList MapGen.Tetrahedron[] **Not supported**
local Layer = { local Layer = {
peaksList = { peaksList = {},
landscape = {}, peaksByPos = {},
temp = {},
humidity = {},
},
noisesByColor = { noisesByColor = {
landscape = {}, landscape = {},
temp = {}, temp = {},
@@ -46,11 +51,7 @@ local Layer = {
cavernsByName = {}, cavernsByName = {},
cavernsList = {}, cavernsList = {},
regionsByName = {}, regionsByName = {},
trianglesList = { trianglesList = {},
landscape = {},
temp = {},
humidity = {},
},
tetrahedronsList = {}, tetrahedronsList = {},
} }
@@ -58,17 +59,23 @@ local Layer = {
--- ---
---**Only for EmmyLua.** ---**Only for EmmyLua.**
---@class MapGen.LayerDef ---@class MapGen.LayerDef
---@field minY number ---@field minY integer
---@field maxY number ---@field maxY integer
---@field minTemp number ---@field minTemp integer
---@field maxTemp number ---@field maxTemp integer
---@field minHumidity number ---@field minHumidity integer
---@field maxHumidity number ---@field maxHumidity integer
---@field waterLevel? number ---@field waterLevel? integer
---@field calcTemp (fun(self:MapGen.Layer, value:number, height:number):number)? ---@field calcTemp (fun(self:MapGen.Layer, value:number, height:number):number)?
---@field calcHumidity (fun(self:MapGen.Layer, value:number, height:number):number)? ---@field calcHumidity (fun(self:MapGen.Layer, value:number, height:number):number)?
---@field biomesGorizontalScattering number? ---@field biomesGorizontalScattering integer?
---@field biomesVerticalScattering number? ---@field biomesVerticalScattering integer?
---@field triangulationLandscapeFile string
---@field triangulationTempFile string
---@field triangulationHumidityFile string
---@field landscapeMapScale number
---@field tempMapScale number
---@field humidityMapScale number
---@param self MapGen.Layer ---@param self MapGen.Layer
---@param value number ---@param value number
@@ -78,6 +85,73 @@ local function defaultCalcFunc(self, value, height)
return value return value
end end
---Checks `def` for compliance with `MapGen.PeakDef` and creates a new peak
---if a peak with such coordinates has not yet been registered or returns an existing one.
---
---**Note:** If the colors of the new peak and the existing one at the same coordinates
---are different, an error will be called.
---@param def MapGen.PeakDef
---@param scale number
---@return MapGen.Peak
function Layer:registerPeak(def, scale)
assert(def.pos ~= nil)
assert(def.pos.x ~= nil)
assert(def.pos.z ~= nil)
assert(def.color ~= nil)
assert(type(def.color) == 'string')
def.pos.x = def.pos.x * scale
def.pos.z = def.pos.z * scale
def.pos.y = 0
local positionStr = core.pos_to_string(def.pos)
local peak = self.peaksByPos[positionStr]
if peak == nil then
peak = Peak:new(def)
self.peaksByPos[positionStr] = peak
elseif peak.color ~= def.color then
error('There cannot be two peaks with the same coordinates but different colors.')
end
return peak
end
function Layer:initTrianglesNeighbours()
local triangles = self.trianglesList
for _, triangle in pairs(triangles) do
for _, id in ipairs(triangle.neighboursIDs) do
table.insert(triangle.neighbours, triangles[id])
end
end
end
---@param fileName string
---@param category MapGen.Layer.Category
---@param scale number
function Layer:getTriaglesFromFile(fileName, category, scale)
local file = io.open(core.get_modpath(core.get_current_modname())..'/maps/'..fileName, 'r')
assert(file ~= nil)
local json = core.parse_json(file:read('*a')) or {}
file:close()
local triangles = json.triangles
assert(triangles ~= nil)
for _, tr in ipairs(triangles) do
local p1 = self:registerPeak( tr.vertices[1], scale)
local p2 = self:registerPeak( tr.vertices[2], scale)
local p3 = self:registerPeak( tr.vertices[3], scale)
local triangle = Triangle:new(tr.id,p1, p2, p3, tr.adjacent_triangle_ids)
self:addTriangle(category, triangle)
end
end
---@param name string ---@param name string
---@param def MapGen.LayerDef ---@param def MapGen.LayerDef
---@return MapGen.Layer ---@return MapGen.Layer
@@ -93,20 +167,34 @@ function Layer:new(name, def)
end end
---@type MapGen.Layer ---@type MapGen.Layer
local instance = getInstance(self, { local instance = getInstance(self, {})
name = name, instance.name = name
minY = def.minY, instance.minY = def.minY
maxY = def.maxY, instance.maxY = def.maxY
minTemp = def.minTemp, instance.minTemp = def.minTemp
maxTemp = def.maxTemp, instance.maxTemp = def.maxTemp
minHumidity = def.minHumidity, instance.minHumidity = def.minHumidity
maxHumidity = def.maxHumidity, instance.maxHumidity = def.maxHumidity
waterLevel = def.waterLevel or 0, instance.waterLevel = def.waterLevel or 0
calcTemp = def.calcTemp, instance.calcTemp = def.calcTemp
calcHumidity = def.calcHumidity, instance.calcHumidity = def.calcHumidity
biomesGorizontalScattering = def.biomesGorizontalScattering or 0, instance.biomesGorizontalScattering = def.biomesGorizontalScattering or 0
biomesVerticalScattering = def.biomesVerticalScattering or 0, instance.biomesVerticalScattering = def.biomesVerticalScattering or 0
})
instance:getTriaglesFromFile(
def.triangulationLandscapeFile,
'landscape',
def.landscapeMapScale)
instance:getTriaglesFromFile(
def.triangulationTempFile,
'temp',
def.tempMapScale)
instance:getTriaglesFromFile(
def.triangulationHumidityFile,
'humidity',
def.humidityMapScale)
instance:initTrianglesNeighbours()
return instance return instance
end end
@@ -114,35 +202,35 @@ end
---A category of noise that affects specific map generation objects. ---A category of noise that affects specific map generation objects.
---@alias MapGen.Layer.Category 'landscape'|'temp'|'humidity' ---@alias MapGen.Layer.Category 'landscape'|'temp'|'humidity'
---Adds a peak to the `Layer.peaksList` ---Adds a triangle to the `Layer.trianglesList`
---@param category MapGen.Layer.Category ---@param category MapGen.Layer.Category
---@param peak MapGen.Peak ---@param triangle MapGen.Triangle
function Layer:addPeak(category, peak) function Layer:addTriangle(category, triangle)
if category == 'landscape' then local triangles = self.trianglesList
table.insert(self.peaksList.landscape, peak) if triangles ~= nil then
elseif category == 'temp' then triangles[triangle.id] = triangle
table.insert(self.peaksList.temp, peak)
elseif category == 'humidity' then
table.insert(self.peaksList.humidity, peak)
else else
error(('There is no peak category named %s.'):format(category)) error(('There is no peak category named %s.'):format(category))
end end
end end
---Adds a peak to the `Layer.peaksList`
---@param category MapGen.Layer.Category
---@param peak MapGen.Peak
function Layer:addPeak(category, peak)
table.insert(self.peaksList, peak)
end
---Returns the `MapGen.Peak` at the coordinates. If there is no peak at these coordinates, it returns `nil`. ---Returns the `MapGen.Peak` at the coordinates. If there is no peak at these coordinates, it returns `nil`.
---@param category MapGen.Layer.Category The category in which the peak is located.
---@param pos Position Coordinate of the desired peak. ---@param pos Position Coordinate of the desired peak.
---@return MapGen.Peak? ---@return MapGen.Peak?
function Layer:getPeakByPos(category, pos) function Layer:getPeakByPos(pos)
pos = vector.new(pos) local positionStr = core.pos_to_string(pos)
local peak = self.peaksByPos[positionStr]
---@param peak MapGen.Peak
for _, peak in ipairs(self.peaksList[category]) do
if peak:getPeakPos() == pos then
return peak return peak
end end
end
end
---Adds a NoiseParams color to the `Layer.noisesParamsByColor` ---Adds a NoiseParams color to the `Layer.noisesParamsByColor`
---@param category MapGen.Layer.Category ---@param category MapGen.Layer.Category

View File

@@ -2,8 +2,8 @@ local getInstance = Class.getInstance
---@class MapGen.Peak ---@class MapGen.Peak
---@field id number ---@field id number
---@field getPeakPos fun(self):vector ---@field pos vector
---@field getColor fun(self):ColorString ---@field color ColorString
---@field getGroups fun(self):table<string, number> ---@field getGroups fun(self):table<string, number>
---@field addGroups fun(self, groups:table<string, number>) ---@field addGroups fun(self, groups:table<string, number>)
local Peak = { local Peak = {
@@ -23,7 +23,6 @@ local Peak = {
---@param def MapGen.PeakDef ---@param def MapGen.PeakDef
---@return MapGen.Peak ---@return MapGen.Peak
function Peak:new(def) function Peak:new(def)
local _pos = vector.new(def.pos)
local _color = def.color local _color = def.color
local _groups local _groups
@@ -39,14 +38,8 @@ function Peak:new(def)
__tostring = self.toString, __tostring = self.toString,
__eq = self.eq __eq = self.eq
}) })
instance.pos = vector.new(def.pos)
function instance:getPeakPos() instance.color = def.color
return _pos:copy()
end
function instance:getColor()
return _color
end
function instance:getGroups() function instance:getGroups()
return table.copy_with_metatables(_groups) return table.copy_with_metatables(_groups)
@@ -66,7 +59,7 @@ end
---Returns a string describing the object in a readable form. ---Returns a string describing the object in a readable form.
---@return string ---@return string
function Peak:toString() function Peak:toString()
local pos = self:getPeakPos() local pos = self.pos
return ('Peak (%s) x: %.2f y: %.2f z: %.2f'):format( self.id, pos.x, pos.y, pos.z) return ('Peak (%s) x: %.2f y: %.2f z: %.2f'):format( self.id, pos.x, pos.y, pos.z)
end end
@@ -74,8 +67,8 @@ end
---@param other MapGen.Peak ---@param other MapGen.Peak
---@return boolean ---@return boolean
function Peak:eq(other) function Peak:eq(other)
local pos1 = self:getPeakPos() local pos1 = self.pos
local pos2 = other:getPeakPos() local pos2 = other.pos
return pos1.x == pos2.x and pos1.z == pos2.z return pos1.x == pos2.x and pos1.z == pos2.z
end end

View File

@@ -8,7 +8,7 @@ local getInstance = Class.getInstance
---@field maxY number ---@field maxY number
---@field staticNode string ---@field staticNode string
---@field staticNodeID number ---@field staticNodeID number
---@field generateStaticNode generateFunc ---@field generateStaticNode fun(self, mapGenerator:MapGen, data:number[], data2:number[], index:number, x:number, y:number, z:number)
local StaticLayer = {} local StaticLayer = {}
---Definition table for the `MapGen.StaticLayer`. ---Definition table for the `MapGen.StaticLayer`.
@@ -18,16 +18,17 @@ local StaticLayer = {}
---@field minY number ---@field minY number
---@field maxY number ---@field maxY number
---@field staticNode string ---@field staticNode string
---@field generateStaticNode generateFunc ---@field generateStaticNode fun(self, mapGenerator:MapGen, data:number[], data2:number[], index:number, x:number, y:number, z:number)
---@param self MapGen.StaticLayer ---@param self MapGen.StaticLayer
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param data number[] ---@param data number[]
---@param data2 number[]
---@param index number ---@param index number
---@param x number ---@param x number
---@param y number ---@param y number
---@param z number ---@param z number
local defaultGenerateStaticNode = function(self, mapGenerator, data, index, x, y, z) local defaultGenerateStaticNode = function(self, mapGenerator, data, data2, index, x, y, z)
data[index] = self.staticNodeID data[index] = self.staticNodeID
end end

View File

@@ -1,155 +0,0 @@
---@diagnostic disable: param-type-not-match
local mathAbs = math.abs
local getInstance = Class.getInstance
local modInfo = Mod.getInfo('smc__core__map_gen')
local require = modInfo.require
---@type MapGen.Triangle
local Triangle = require('MapGen.Triangle')
---@type MapGen.Triangulation.Edge
local Edge = require('MapGen.Triangulation.Edge')
---@type MapGen.Triangulation.FakePeak
local FakePeak = require('MapGen.Triangulation.FakePeak')
---@class MapGen.Tetrahedron
---@field p1 MapGen.Peak
---@field p2 MapGen.Peak
---@field p3 MapGen.Peak
---@field p4 MapGen.Peak
---@field h1 MapGen.Triangulation.Edge
---@field h2 MapGen.Triangulation.Edge
---@field h3 MapGen.Triangulation.Edge
---@field h4 MapGen.Triangulation.Edge
---@field f1 MapGen.Triangle
---@field f2 MapGen.Triangle
---@field f3 MapGen.Triangle
---@field f4 MapGen.Triangle
local Tetrahedron = {}
---@param p1 MapGen.Peak
---@param p2 MapGen.Peak
---@param p3 MapGen.Peak
---@param p4 MapGen.Peak
---@return MapGen.Tetrahedron
function Tetrahedron:new(p1, p2, p3, p4)
local instance = getInstance(self, {
p1 = p1,
p2 = p2,
p3 = p3,
p4 = p4,
h1 = self:getHeight(p1, p2, p3, p4),
h2 = self:getHeight(p2, p3, p4, p1),
h3 = self:getHeight(p3, p4, p1, p2),
h4 = self:getHeight(p4, p1, p2, p3),
f1 = Triangle:new(p1, p2, p3),
f2 = Triangle:new(p1, p2, p4),
f3 = Triangle:new(p1, p3, p4),
f4 = Triangle:new(p2, p3, p4),
},
{
__tostring = self.toString
})
return instance
end
---Returns a string describing the object in a readable form.
---@return string
function Tetrahedron:toString()
return ('Tetrahedron: \n %s\n %s\n %s\n %s'):format(
tostring(self.p1.getPeakPos()),
tostring(self.p2.getPeakPos()),
tostring(self.p3.getPeakPos()),
tostring(self.p4.getPeakPos())
)
end
---@param p1 MapGen.Peak
---@param p2 MapGen.Peak
---@param p3 MapGen.Peak
---@param p4 MapGen.Peak
function Tetrahedron:getHeight(p1, p2, p3, p4)
local pos1 = p1:getPeakPos()
local pos2 = p2:getPeakPos()
local pos3 = p3:getPeakPos()
local pos4 = p4:getPeakPos()
-- Векторы, лежащие в плоскости
local AB = pos3 - pos2
local AC = pos4 - pos2
-- Нормаль к плоскости
local normal = AB:cross(AC)
local normal_length = normal:length()
-- Если плоскость вырождена (точки на одной прямой)
if normal_length < 1e-10 then
return nil -- или другая обработка ошибки
end
-- Вектор от точки на плоскости к нашей точке
local AP = pos1 - pos2
-- Расстояние от точки до плоскости
local distance = AP:dot(normal) / normal_length
-- Проекция точки на плоскость (вектор!)
local projection = pos1 - (normal * (distance / normal_length))
return Edge:new(p1, FakePeak:new(projection))
end
---Returns the center of the circumscribed sphere.
---@return vector
function Tetrahedron:getCircumSphereCenter()
local pos1 = self.p1.getPeakPos()
local pos2 = self.p2.getPeakPos()
local pos3 = self.p3.getPeakPos()
local pos4 = self.p4.getPeakPos()
local a = pos2 - pos1
local b = pos3 - pos1
local c = pos4 - pos1
local a2 = a:dot(a)
local b2 = b:dot(b)
local c2 = c:dot(c)
local cross_bc = b:cross(c)
local cross_ca = c:cross(a)
local cross_ab = a:cross(b)
local det = a:dot(b:cross(c)) * 2
if mathAbs(det) < 0 then
return (pos1 + pos2 + pos3 + pos4) / 4
end
local center = pos1 + (cross_bc * a2 + cross_ca * b2 + cross_ab * c2) / det
return center
end
---Returns the radius of the circumscribed sphere.
---@return number
function Tetrahedron:getCircumSphereRadius()
local center = self:getCircumSphereCenter()
local pos1 = self.p1.getPeakPos()
return (pos1 - center):length()
end
---Checks whether a given point lies within the circumscribed sphere of a tetrahedron.
---@param p MapGen.Peak
function Tetrahedron:inCircumSphere(p)
local pos = p.getPeakPos()
local c = self:getCircumSphereCenter()
local r = self:getCircumSphereRadius()
local distance = (pos - c):length()
return distance <= r
end
return Tetrahedron

View File

@@ -6,10 +6,10 @@ local getInstance = Class.getInstance
local modInfo = Mod.getInfo('smc__core__map_gen') local modInfo = Mod.getInfo('smc__core__map_gen')
local require = modInfo.require local require = modInfo.require
---@type MapGen.Triangulation.Edge ---@type MapGen.Edge
local Edge = require('MapGen.Triangulation.Edge') local Edge = require('MapGen.Edge')
---@type MapGen.Triangulation.FakePeak ---@type MapGen.FakePeak
local FakePeak = require('MapGen.Triangulation.FakePeak') local FakePeak = require('MapGen.FakePeak')
-- --- Helpers functions --- -- --- Helpers functions ---
@@ -29,9 +29,9 @@ end
---@param p3 MapGen.Peak ---@param p3 MapGen.Peak
---@return boolean ---@return boolean
local function isFlatAngle(p1, p2, p3) local function isFlatAngle(p1, p2, p3)
local pos1 = p1:getPeakPos() local pos1 = p1.pos
local pos2 = p2:getPeakPos() local pos2 = p2.pos
local pos3 = p3:getPeakPos() local pos3 = p3.pos
local vec1 = pos1 - pos2 -- Vector from p2 to p1 local vec1 = pos1 - pos2 -- Vector from p2 to p1
local vec2 = pos3 - pos2 -- Vector from p2 to p3 local vec2 = pos3 - pos2 -- Vector from p2 to p3
@@ -63,16 +63,18 @@ end
---@alias MapGen.Triangle.Neighbours {t1:MapGen.Triangle?,t2:MapGen.Triangle?,t3:MapGen.Triangle?} ---@alias MapGen.Triangle.Neighbours {t1:MapGen.Triangle?,t2:MapGen.Triangle?,t3:MapGen.Triangle?}
---@class MapGen.Triangle ---@class MapGen.Triangle
---@field id integer
---@field p1 MapGen.Peak ---@field p1 MapGen.Peak
---@field p2 MapGen.Peak ---@field p2 MapGen.Peak
---@field p3 MapGen.Peak ---@field p3 MapGen.Peak
---@field e1 MapGen.Triangulation.Edge ---@field e1 MapGen.Edge
---@field e2 MapGen.Triangulation.Edge ---@field e2 MapGen.Edge
---@field e3 MapGen.Triangulation.Edge ---@field e3 MapGen.Edge
---@field h1 MapGen.Triangulation.Edge ---@field h1 MapGen.Edge
---@field h2 MapGen.Triangulation.Edge ---@field h2 MapGen.Edge
---@field h3 MapGen.Triangulation.Edge ---@field h3 MapGen.Edge
---@field neighbours MapGen.Triangle.Neighbours ---@field neighboursIDs integer[]
---@field neighbours MapGen.Triangle[]
---@field color ColorString? ---@field color ColorString?
local Triangle = { local Triangle = {
neighbours = {} neighbours = {}
@@ -82,20 +84,21 @@ local Triangle = {
---@param p2 MapGen.Peak ---@param p2 MapGen.Peak
---@param p3 MapGen.Peak ---@param p3 MapGen.Peak
---@return MapGen.Triangle ---@return MapGen.Triangle
function Triangle:new(p1, p2, p3) function Triangle:new(id, p1, p2, p3, neighboursIDs)
assert(not isFlatAngle(p1, p2, p3), ("angle (p1, p2, p3) is flat:\n %s\n %s\n %s") assert(not isFlatAngle(p1, p2, p3), ("angle (p1, p2, p3) is flat:\n %s\n %s\n %s")
:format(tostring(p1), tostring(p2), tostring(p3))) :format(tostring(p1), tostring(p2), tostring(p3)))
---@type ColorString? ---@type ColorString?
local color = nil local color = nil
local c1, c2, c3 = p1.getColor(), p2.getColor(), p3.getColor() local c1, c2, c3 = p1.color, p2.color, p3.color
if c1 == c2 and c2 == c3 and c3 == c1 then if c1 == c2 and c2 == c3 and c3 == c1 then
color = c1 color = c1
end end
local instance = getInstance(self, { local instance = getInstance(self, {
id = id,
p1 = p1, p1 = p1,
p2 = p2, p2 = p2,
p3 = p3, p3 = p3,
@@ -105,7 +108,8 @@ function Triangle:new(p1, p2, p3)
e1 = Edge:new(p1, p2), e1 = Edge:new(p1, p2),
e2 = Edge:new(p2, p3), e2 = Edge:new(p2, p3),
e3 = Edge:new(p3, p1), e3 = Edge:new(p3, p1),
color = color neighboursIDs = neighboursIDs,
color = color,
}, },
{ {
__tostring = self.toString, __tostring = self.toString,
@@ -119,9 +123,9 @@ end
---@return string ---@return string
function Triangle:toString() function Triangle:toString()
return ('Triangle: \n %s\n %s\n %s'):format( return ('Triangle: \n %s\n %s\n %s'):format(
tostring(self.p1.getPeakPos()), tostring(self.p1.pos),
tostring(self.p2.getPeakPos()), tostring(self.p2.pos),
tostring(self.p3.getPeakPos()) tostring(self.p3.pos)
) )
end end
@@ -144,9 +148,9 @@ end
---Returns the coordinates of the triangle's center. ---Returns the coordinates of the triangle's center.
---@return vector ---@return vector
function Triangle:getCenter() function Triangle:getCenter()
local pos1 = self.p1:getPeakPos() local pos1 = self.p1.pos
local pos2 = self.p2:getPeakPos() local pos2 = self.p2.pos
local pos3 = self.p3:getPeakPos() local pos3 = self.p3.pos
return (pos1 + pos2 + pos3) / 3 return (pos1 + pos2 + pos3) / 3
end end
@@ -163,11 +167,11 @@ end
---@param p1 MapGen.Peak ---@param p1 MapGen.Peak
---@param p2 MapGen.Peak ---@param p2 MapGen.Peak
---@param p3 MapGen.Peak ---@param p3 MapGen.Peak
---@return MapGen.Triangulation.Edge ---@return MapGen.Edge
function Triangle:getHeight(p1, p2, p3) function Triangle:getHeight(p1, p2, p3)
local pos1 = p1:getPeakPos() local pos1 = p1.pos
local pos2 = p2:getPeakPos() local pos2 = p2.pos
local pos3 = p3:getPeakPos() local pos3 = p3.pos
local v = pos3 - pos2 local v = pos3 - pos2
---@type vector ---@type vector
@@ -189,11 +193,11 @@ end
---@param p1 MapGen.Peak ---@param p1 MapGen.Peak
---@param p2 MapGen.Peak ---@param p2 MapGen.Peak
---@param p3 MapGen.Peak ---@param p3 MapGen.Peak
---@return MapGen.Triangulation.Edge ---@return MapGen.Edge
function Triangle:getHeight2D(p1, p2, p3) function Triangle:getHeight2D(p1, p2, p3)
local pos1 = p1:getPeakPos() local pos1 = p1.pos
local pos2 = p2:getPeakPos() local pos2 = p2.pos
local pos3 = p3:getPeakPos() local pos3 = p3.pos
pos1.y = 0 pos1.y = 0
pos2.y = 0 pos2.y = 0
@@ -224,9 +228,9 @@ end
---that is, the calculation is performed on the projection of the triangle XZ. ---that is, the calculation is performed on the projection of the triangle XZ.
---@return number, number, number ---@return number, number, number
function Triangle:getSidesLength2D() function Triangle:getSidesLength2D()
local pos1 = self.p1:getPeakPos() local pos1 = self.p1.pos
local pos2 = self.p2:getPeakPos() local pos2 = self.p2.pos
local pos3 = self.p3:getPeakPos() local pos3 = self.p3.pos
pos1.y = 0 pos1.y = 0
pos2.y = 0 pos2.y = 0
@@ -241,9 +245,9 @@ end
---that is, the calculation is performed on the projection of the triangle XZ. ---that is, the calculation is performed on the projection of the triangle XZ.
---@return vector ---@return vector
function Triangle:getCircumCenter2D() function Triangle:getCircumCenter2D()
local pos1 = self.p1:getPeakPos() local pos1 = self.p1.pos
local pos2 = self.p2:getPeakPos() local pos2 = self.p2.pos
local pos3 = self.p3:getPeakPos() local pos3 = self.p3.pos
local D = ( pos1.x * (pos2.z - pos3.z) + local D = ( pos1.x * (pos2.z - pos3.z) +
pos2.x * (pos3.z - pos1.z) + pos2.x * (pos3.z - pos1.z) +
@@ -290,7 +294,7 @@ end
---@param p MapGen.Peak ---@param p MapGen.Peak
---@return boolean ---@return boolean
function Triangle:inCircumCircle2D(p) function Triangle:inCircumCircle2D(p)
local pos = p:getPeakPos() local pos = p.pos
local c, r = self:getCircumCircle2D() local c, r = self:getCircumCircle2D()

View File

@@ -1,327 +0,0 @@
---@diagnostic disable: param-type-not-match
-- Tringulation lib
-- Original code: https://github.com/iskolbin/Triangulation/blob/master/Triangulation.lua
-- Date of copying: 07.11.2025
-- Commit: e8d26241767cd6af377b5eda0c1e27122b6afe8a
-- Main changes:
-- * refactoring code to our standard;
-- * splitting code into different files (classes);
-- * Adapting the code to the mapgen concept;
-- * Adding tetrahedralization;
-- * Fixed non-determinism by sorting vertices before processing;
local assert, mathMax, tableRemove, tableSort
= assert, math.max, table.remove, table.sort
local modInfo = Mod.getInfo('smc__core__map_gen')
local require = modInfo.require
---@type MapGen.Triangle
local Triangle = require('MapGen.Triangle')
---@type MapGen.Tetrahedron
local Tetrahedron = require('MapGen.Tetrahedron')
---@type MapGen.Triangulation.FakePeak
local FakePeak = require('MapGen.Triangulation.FakePeak')
---@class MapGen.Triangulation
---@field convexMultiplier number
local Triangulation = {
convexMultiplier = 1e3,
}
---Finds and writes adjacent triangles into triangles.
---@param triangles MapGen.Triangle[]
local function findTrianglesNeighbours(triangles)
for _, triangle in ipairs(triangles) do
for _, t in ipairs(triangles) do
if triangle.e1 == t.e1 and triangle.p3 ~= t.p3 then
triangle.neighbours.t1 = t
elseif triangle.e2 == t.e2 and triangle.p3 ~= t.p1 then
triangle.neighbours.t2 = t
elseif triangle.e3 == t.e3 and triangle.p3 ~= t.p2 then
triangle.neighbours.t3 = t
end
end
end
end
---Filter vertices by group and return a new table
---@param vertices table<integer, MapGen.Peak>
---@param groupKey string
---@return table<integer, MapGen.Peak>
local function filterVerticesByGroup(vertices, groupKey)
local result = {}
for i = 1, #vertices do
local vertex = vertices[i]
if vertex:getGroups()[groupKey] ~= nil then
result[#result + 1] = vertex
end
end
return result
end
---Sort vertices deterministically by position to ensure consistent triangulation
---@param vertices table<integer, MapGen.Peak>
local function sortVerticesDeterministically(vertices)
tableSort(vertices, function(a, b)
local posA = a:getPeakPos()
local posB = b:getPeakPos()
-- Sort by X first
if posA.x ~= posB.x then
return posA.x < posB.x
end
-- Then by Z
if posA.z ~= posB.z then
return posA.z < posB.z
end
-- Then by Y
if posA.y ~= posB.y then
return posA.y < posB.y
end
-- Fallback to unique identifier if positions are identical
-- This handles potential duplicate positions
local nameA = a.getName and a:getName() or ""
local nameB = b.getName and b:getName() or ""
return nameA < nameB
end)
end
---The Delaunay method divides a plane into triangles based on a list of their vertices.
---
---Doesn't take into account the Y coordinate of the vertices.
---That is, all triangles that don't lie in the XZ plane will be projected onto it.
---
---Vertices that do not have a `is2d` group will not participate in the triangulation.
---@param vertices table<integer, MapGen.Peak>
function Triangulation.triangulate(vertices)
-- Filter vertices with is2d group (creates a new table)
vertices = filterVerticesByGroup(vertices, "is2d")
-- Sort deterministically to ensure consistent results across sessions
sortVerticesDeterministically(vertices)
local nvertices = #vertices
assert(nvertices > 2, "Cannot triangulate, needs more than 3 vertices")
if nvertices == 3 then
return {Triangle:new(vertices[1], vertices[2], vertices[3])}
end
local minPos = vertices[1]:getPeakPos()
local minX, minY = minPos.x, minPos.z
local maxX, maxY = minX, minY
for i = 1, nvertices do
local vertex = vertices[i]
local vertexPos = vertex:getPeakPos()
vertex.id = i
if vertexPos.x < minX then
minX = vertexPos.x
end
if vertexPos.z < minY then
minY = vertexPos.z
end
if vertexPos.x > maxX then
maxX = vertexPos.x
end
if vertexPos.z > maxY then
maxY = vertexPos.z
end
end
-- Finding the vertices of a supertriangle
local convex_mult = Triangulation.convexMultiplier
local dx, dy = (maxX - minX) * convex_mult, (maxY - minY) * convex_mult
local deltaMax = mathMax(dx, dy)
local midx, midy = (minX + maxX) * 0.5, (minY + maxY) * 0.5
local p1 = FakePeak:new(vector.new(midx - 2 * deltaMax, 0, midy - deltaMax))
local p2 = FakePeak:new(vector.new(midx, 0, midy + 2 * deltaMax))
local p3 = FakePeak:new(vector.new(midx + 2 * deltaMax, 0, midy - deltaMax))
p1.id, p2.id, p3.id = nvertices + 1, nvertices + 2, nvertices + 3
vertices[p1.id], vertices[p2.id], vertices[p3.id] = p1, p2, p3
---@type MapGen.Triangle[]
local triangles = {Triangle:new(vertices[nvertices + 1], vertices[nvertices + 2], vertices[nvertices + 3])}
for i = 1, nvertices do
---@type MapGen.Triangulation.Edge[]
local edges = {}
-- Finding bad triangles.
for j = #triangles, 1, -1 do
local curTriangle = triangles[j]
if curTriangle:inCircumCircle2D(vertices[i]) then
edges[#edges + 1] = curTriangle.e1
edges[#edges + 1] = curTriangle.e2
edges[#edges + 1] = curTriangle.e3
tableRemove(triangles, j)
end
end
-- Removing duplicate edges.
for j = #edges - 1, 1, -1 do
for k = #edges, j + 1, -1 do
if edges[j] and edges[k] and edges[j]:same(edges[k]) then
tableRemove(edges, j)
tableRemove(edges, k - 1)
end
end
end
-- Create new triangles.
for j = 1, #edges do
triangles[#triangles + 1] = Triangle:new(edges[j].p1, edges[j].p2, vertices[i])
end
end
-- Remove triangles associated with the vertices of a supertriangle.
for i = #triangles, 1, -1 do
local triangle = triangles[i]
if triangle.p1.id > nvertices or triangle.p2.id > nvertices or triangle.p3.id > nvertices then
tableRemove(triangles, i)
end
end
-- Removing the vertices of a supertriangle.
for _ = 1, 3 do
tableRemove(vertices)
end
findTrianglesNeighbours(triangles)
return triangles
end
---The Delaunay method divides space into tetrahedra based on a list of their vertices.
---
---Vertices that do not have a `is3d` group will not participate in the triangulation.
---@param vertices table<integer, MapGen.Peak>
function Triangulation.tetrahedralize(vertices)
-- Filter vertices with is3d group (creates a new table)
vertices = filterVerticesByGroup(vertices, "is3d")
-- Sort deterministically to ensure consistent results across sessions
sortVerticesDeterministically(vertices)
local nvertices = #vertices
assert(nvertices > 3, "Cannot tetrahedralize, needs more than 4 vertices")
if nvertices == 4 then
return {Tetrahedron:new(vertices[1], vertices[2], vertices[3], vertices[4])}
end
local minPos = vertices[1]:getPeakPos()
local minX, minY, minZ = minPos.x, minPos.y, minPos.z
local maxX, maxY, maxZ = minX, minY, minZ
for i = 1, nvertices do
local vertex = vertices[i]
local vertexPos = vertex:getPeakPos()
vertex.id = i
if vertexPos.x < minX then
minX = vertexPos.x
end
if vertexPos.y < minY then
minY = vertexPos.y
end
if vertexPos.z < minZ then
minZ = vertexPos.z
end
if vertexPos.x > maxX then
maxX = vertexPos.x
end
if vertexPos.y > maxY then
maxY = vertexPos.y
end
if vertexPos.z > maxZ then
maxZ = vertexPos.z
end
end
-- Finding the vertices of a supertetrahedron
local convex_mult = Triangulation.convexMultiplier
local dx, dy, dz = (maxX - minX) * convex_mult, (maxY - minY) * convex_mult, (maxZ - minZ) * convex_mult
local deltaMax = mathMax(dx, dy, dz)
local midx, midy, midz = (minX + maxX) * 0.5, (minY + maxY) * 0.5, (minZ + maxZ) * 0.5
local p1 = FakePeak:new(vector.new(midx - 2 * deltaMax, midy - deltaMax, midz - deltaMax))
local p2 = FakePeak:new(vector.new(midx + 2 * deltaMax, midy - deltaMax, midz - deltaMax))
local p3 = FakePeak:new(vector.new(midx, midy + 2 * deltaMax, midz - deltaMax))
local p4 = FakePeak:new(vector.new(midx, midy, midz + 2 * deltaMax))
p1.id, p2.id, p3.id, p4.id = nvertices + 1, nvertices + 2, nvertices + 3, nvertices + 4
vertices[p1.id], vertices[p2.id], vertices[p3.id], vertices[p4.id] = p1, p2, p3, p4
---@type MapGen.Tetrahedron[]
local tetrahedrons = {Tetrahedron:new(p1, p2, p3, p4)}
for i = 1, nvertices do
---@type MapGen.Triangle[]
local faces = {}
-- Finding bad tetrahedrons.
for j = #tetrahedrons, 1, -1 do
local curTetrahedron = tetrahedrons[j]
if curTetrahedron:inCircumSphere(vertices[i]) then
faces[#faces + 1] = curTetrahedron.f1
faces[#faces + 1] = curTetrahedron.f2
faces[#faces + 1] = curTetrahedron.f3
faces[#faces + 1] = curTetrahedron.f4
tableRemove(tetrahedrons, j)
end
end
-- Removing duplicate faces.
for j = #faces - 1, 1, -1 do
for k = #faces, j + 1, -1 do
if faces[j] and faces[k] and faces[j]:same(faces[k]) then
tableRemove(faces, j)
tableRemove(faces, k - 1)
end
end
end
-- Create new tetrahedrons.
for j = 1, #faces do
tetrahedrons[#tetrahedrons + 1] = Tetrahedron:new(faces[j].p1, faces[j].p2, faces[j].p3, vertices[i])
end
end
-- Remove tetrahedra associated with the vertices of a supertetrahedron.
for i = #tetrahedrons, 1, -1 do
local tetrahedron = tetrahedrons[i]
if tetrahedron.p1.id > nvertices or tetrahedron.p2.id > nvertices or tetrahedron.p3.id > nvertices or tetrahedron.p4.id > nvertices then
tableRemove(tetrahedrons, i)
end
end
-- Removing the vertices of a supertetrahedron.
for _ = 1, 4 do
tableRemove(vertices)
end
return tetrahedrons
end
return Triangulation

View File

@@ -1,28 +1,92 @@
local itemRequire = Mod.getInfo('smc__core__item').require local tableMerge = table.merge
---@type Item local Item, ItemFactory = Smc.requireItem(), Smc.requireItemFactory()
local Item = itemRequire('Item')
---@type ItemFactory
local ItemFactory = Mod.getInfo('smc__core__item_factory').require('ItemFactory')
---@class Node : Item ---@class Node : Item
---@field defaultDef Node.NodeDefinition ---@field defaultDef Node.NodeDefinition
local Node = Class.extend(Item, {}) local Node = Class.extend(Item, {})
---The alias `table.merge` for EmmyLua ---@param nodeDef Node.NodeDefinition
---@type fun(...):(Node.NodeDefinition) local function registerSlab(nodeDef)
local defMerge = function(...) nodeDef = table.copy_with_metatables(nodeDef)
return table.merge(...)
local settings = nodeDef.settings
assert(settings.groups ~= nil)
settings._title = nil
settings._description = nil
settings.name = settings.name..'_slab'
settings.node_box = {
type = 'fixed',
fixed = {-0.5, -0.5, -0.5, 0.5, 0, 0.5},
}
settings.drawtype = 'nodebox'
settings.paramtype = 'light'
settings.paramtype2 = 'facedir'
settings.groups['segments'] = nil
settings.groups['slabs'] = 1
if nodeDef.callbacks ~= nil then
nodeDef.callbacks.on_place = core.rotate_and_place
else
nodeDef.callbacks = {on_place = core.rotate_and_place}
end
Node:new(nodeDef)
end
---@param nodeDef Node.NodeDefinition
local function registerStair(nodeDef)
nodeDef = table.copy_with_metatables(nodeDef)
local settings = nodeDef.settings
assert(settings.groups ~= nil)
settings._title = nil
settings._description = nil
settings.name = settings.name..'_stair'
settings.node_box = {
type = 'fixed',
fixed = {
{-0.5, -0.5, -0.5, 0.5, 0.0, 0.5},
{-0.5, 0.0, 0.0, 0.5, 0.5, 0.5},
},
}
settings.drawtype = 'nodebox'
settings.paramtype = 'light'
settings.paramtype2 = 'facedir'
settings.groups['segments'] = nil
settings.groups['slabs'] = 1
if nodeDef.callbacks ~= nil then
nodeDef.callbacks.on_place = core.rotate_and_place
else
nodeDef.callbacks = {on_place = core.rotate_and_place}
end
Node:new(nodeDef)
end end
---@param nodeDef Node.NodeDefinition ---@param nodeDef Node.NodeDefinition
---@return Node ---@return Node
function Node:new(nodeDef) function Node:new(nodeDef)
---Adding default parameters -- Adding default parameters.
nodeDef = defMerge(nodeDef, self.defaultDef, true) nodeDef = tableMerge(nodeDef, self.defaultDef, true)
nodeDef.settings._visual = 'item_3d' local settings = nodeDef.settings
settings._type = 'node'
-- Registration of segmented blocks.
-- If you specify a specific group with a specific index for a node,
-- the slabs and stairs will be registered automatically.
local segmentsIndex = settings.groups and settings.groups['segments']
if segmentsIndex == 1 then
-- Only slabs
registerSlab(nodeDef)
elseif segmentsIndex == 2 then
-- Only stairs
registerStair(nodeDef)
elseif segmentsIndex == 3 then
-- Slabs & stairs
registerSlab(nodeDef)
registerStair(nodeDef)
end
---@type Node ---@type Node
local instance = Item:new(nodeDef) local instance = Item:new(nodeDef)
@@ -35,7 +99,7 @@ end
---@param defaultDef Node.NodeDefinition ---@param defaultDef Node.NodeDefinition
---@return Node ---@return Node
function Node:getExtended(defaultDef) function Node:getExtended(defaultDef)
defaultDef = defMerge(defaultDef, self.defaultDef) defaultDef = tableMerge(defaultDef, self.defaultDef, true)
---@type Node ---@type Node
local ChildClass = Class.extend(self, { local ChildClass = Class.extend(self, {
@@ -52,7 +116,7 @@ function Node:getFactory(defaultDef)
if defaultDef == nil then if defaultDef == nil then
defaultDef = self.defaultDef defaultDef = self.defaultDef
else else
defaultDef = defMerge(self.defaultDef, defaultDef) defaultDef = tableMerge(self.defaultDef, defaultDef, true)
end end
---@type ItemFactory ---@type ItemFactory

View File

@@ -13,7 +13,7 @@ local Callbacks = Class.extend(ItemCallbacks, {})
--- ---
---default: nil ---default: nil
---* `pos`: node position ---* `pos`: node position
---@type fun(pos:Position)? ---@type fun(pos:MapPosition)?
Callbacks.on_construct = nil Callbacks.on_construct = nil
---Node destructor; called before removing node. ---Node destructor; called before removing node.
@@ -21,7 +21,7 @@ Callbacks.on_construct = nil
--- ---
---default: nil ---default: nil
---* `pos`: node position ---* `pos`: node position
---@type fun(pos:Position)? ---@type fun(pos:MapPosition)?
Callbacks.on_destruct = nil Callbacks.on_destruct = nil
---Node destructor; called after removing node. ---Node destructor; called after removing node.
@@ -30,7 +30,7 @@ Callbacks.on_destruct = nil
---default: nil ---default: nil
---* `pos`: node position ---* `pos`: node position
---* `oldnode`: node table of node before it was deleted ---* `oldnode`: node table of node before it was deleted
---@type fun(pos:Position, old_node)? ---@type fun(pos:MapPosition, old_node)?
Callbacks.after_destruct = nil Callbacks.after_destruct = nil
---Called when a liquid (newnode) is about to flood oldnode, if it has ---Called when a liquid (newnode) is about to flood oldnode, if it has
@@ -45,7 +45,7 @@ Callbacks.after_destruct = nil
---* `pos`: table node position ---* `pos`: table node position
---* `oldnode`: table node table of node before it was deleted ---* `oldnode`: table node table of node before it was deleted
---* `newnode`: TODO: какой тут тип? ---* `newnode`: TODO: какой тут тип?
---@type fun(pos:Position, old_node, new_node)? ---@type fun(pos:MapPosition, old_node, new_node)?
Callbacks.on_flood = nil Callbacks.on_flood = nil
@@ -61,7 +61,7 @@ Callbacks.on_flood = nil
---* `drops`: a table of `ItemStack`s, so any metadata to be preserved can ---* `drops`: a table of `ItemStack`s, so any metadata to be preserved can
--- be added directly to one or more of the dropped items. See --- be added directly to one or more of the dropped items. See
--- "ItemStackMetaRef". --- "ItemStackMetaRef".
---@type fun(pos:Position, old_node, new_node, old_meta, drops:ItemStack[])? ---@type fun(pos:MapPosition, old_node, new_node, old_meta, drops:ItemStack[])?
Callbacks.preserve_metadata = nil Callbacks.preserve_metadata = nil
---Called after constructing node when node was placed using ---Called after constructing node when node was placed using
@@ -73,7 +73,7 @@ Callbacks.preserve_metadata = nil
---* `placer`: may be any valid ObjectRef or nil ---* `placer`: may be any valid ObjectRef or nil
---* `itemstack`: TODO: сделать описание ---* `itemstack`: TODO: сделать описание
---* `pointed_thing`: Vector of the direction of the gaze of the person who placed the block ---* `pointed_thing`: Vector of the direction of the gaze of the person who placed the block
---@type fun(pos:Position, placer:Player|ObjectRef|nil, itemstack:ItemStack, pointed_thing:pointed_thing)? ---@type fun(pos:MapPosition, placer:Player|ObjectRef|nil, itemstack:ItemStack, pointed_thing:pointed_thing)?
Callbacks.after_place_node = nil Callbacks.after_place_node = nil
---Called after destructing the node when node was dug using ---Called after destructing the node when node was dug using
@@ -92,7 +92,7 @@ Callbacks.after_dig_node = nil
---default: nil ---default: nil
---* `pos`: node position ---* `pos`: node position
---* player: ObjectRef of digger ---* player: ObjectRef of digger
---@type fun(pos:Position, player:Player|ObjectRef|nil)? ---@type fun(pos:MapPosition, player:Player|ObjectRef|nil)?
Callbacks.can_dig = nil Callbacks.can_dig = nil
---Called when puncher (an ObjectRef) punches the node at pos. ---Called when puncher (an ObjectRef) punches the node at pos.
@@ -103,7 +103,7 @@ Callbacks.can_dig = nil
---* `node`: node being hit ---* `node`: node being hit
---* `puncher`: ObjectRef of punch ---* `puncher`: ObjectRef of punch
---* `pointed_thing`: Vector of the direction of the gaze of the person who placed the block ---* `pointed_thing`: Vector of the direction of the gaze of the person who placed the block
---@type fun(pos:Position, node:NodeTable, puncher:Player|ObjectRef|nil, pointed_thing:pointed_thing)? ---@type fun(pos:MapPosition, node:NodeTable, puncher:Player|ObjectRef|nil, pointed_thing:pointed_thing)?
Callbacks.on_punch = nil Callbacks.on_punch = nil
---Called when clicker (an ObjectRef) used the 'place/build' key ---Called when clicker (an ObjectRef) used the 'place/build' key
@@ -115,7 +115,7 @@ Callbacks.on_punch = nil
---Note: pointed_thing can be nil, if a mod calls this function. ---Note: pointed_thing can be nil, if a mod calls this function.
--- ---
---default: nil ---default: nil
---@type (fun(pos:Position, node:NodeTable, clicker:Player|ObjectRef, itemstack:ItemStack, pointed_thing:pointed_thing|nil):ItemStack|nil)? ---@type (fun(pos:MapPosition, node:NodeTable, clicker:Player|ObjectRef, itemstack:ItemStack, pointed_thing:pointed_thing|nil):ItemStack|nil)?
Callbacks.on_rightclick = core.node_punch Callbacks.on_rightclick = core.node_punch
@@ -124,7 +124,7 @@ Callbacks.on_rightclick = core.node_punch
---Deprecated: returning nil is the same as returning true. ---Deprecated: returning nil is the same as returning true.
--- ---
---default: core.node_dig ---default: core.node_dig
---@type (fun(pos:Position, node:NodeTable, digger:Player): boolean)? ---@type (fun(pos:MapPosition, node:NodeTable, digger:Player): boolean)?
Callbacks.on_dig = minetest.node_dig Callbacks.on_dig = minetest.node_dig
---called by NodeTimers, see core.get_node_timer and NodeTimerRef. ---called by NodeTimers, see core.get_node_timer and NodeTimerRef.
@@ -134,7 +134,7 @@ Callbacks.on_dig = minetest.node_dig
---return true to run the timer for another cycle with the same timeout value. ---return true to run the timer for another cycle with the same timeout value.
--- ---
---default: nil ---default: nil
---@type (fun(pos:Position, elapsed:number): boolean)? ---@type (fun(pos:MapPosition, elapsed:number, node:NodeTable, timeout:number):boolean?)?
Callbacks.on_timer = nil Callbacks.on_timer = nil
---fields = {name1 = value1, name2 = value2, ...} ---fields = {name1 = value1, name2 = value2, ...}
@@ -144,7 +144,7 @@ Callbacks.on_timer = nil
---See `core.register_on_player_receive_fields` for more info. ---See `core.register_on_player_receive_fields` for more info.
--- ---
---default: nil ---default: nil
---@type fun(pos:Position, formname:string, fields:table, sender:Player)? ---@type fun(pos:MapPosition, formname:string, fields:table, sender:Player)?
Callbacks.on_receive_fields = nil Callbacks.on_receive_fields = nil
---Called when a player wants to put something into the inventory. ---Called when a player wants to put something into the inventory.
@@ -152,7 +152,7 @@ Callbacks.on_receive_fields = nil
---Return value: number of items allowed to put. ---Return value: number of items allowed to put.
--- ---
---Return value -1: Allow and don't modify item count in inventory. ---Return value -1: Allow and don't modify item count in inventory.
---@type (fun(pos:Position, from_list:string, from_index:number, to_list:string, to_index:number, count:number, player:Player): number)? ---@type (fun(pos:MapPosition, from_list:string, from_index:number, to_list:string, to_index:number, count:number, player:Player): number)?
Callbacks.allow_metadata_inventory_move = nil Callbacks.allow_metadata_inventory_move = nil
---Called when a player wants to take something out of the inventory. ---Called when a player wants to take something out of the inventory.
@@ -160,31 +160,31 @@ Callbacks.allow_metadata_inventory_move = nil
---Return value: number of items allowed to take. ---Return value: number of items allowed to take.
--- ---
---Return value -1: Allow and don't modify item count in inventory. ---Return value -1: Allow and don't modify item count in inventory.
---@type (fun(pos:Position, listname:string, index:number, stack:ItemStack, player:Player): number)? ---@type (fun(pos:MapPosition, listname:string, index:number, stack:ItemStack, player:Player): number)?
Callbacks.allow_metadata_inventory_take = nil Callbacks.allow_metadata_inventory_take = nil
---Called after the actual action has happened, according to what was allowed. ---Called after the actual action has happened, according to what was allowed.
--- ---
---No return value. ---No return value.
---@type (fun(pos:Position, from_list:string, from_index:number, to_list:string, to_index:number, count:number, player:Player): void)? ---@type (fun(pos:MapPosition, from_list:string, from_index:number, to_list:string, to_index:number, count:number, player:Player): void)?
Callbacks.on_metadata_inventory_move = nil Callbacks.on_metadata_inventory_move = nil
---Called after the actual action has happened, according to what was allowed. ---Called after the actual action has happened, according to what was allowed.
--- ---
---No return value. ---No return value.
---@type (fun(pos:Position, listname:string, index:number, stack:ItemStack, player:Player): void)? ---@type (fun(pos:MapPosition, listname:string, index:number, stack:ItemStack, player:Player): void)?
Callbacks.on_metadata_inventory_put = nil Callbacks.on_metadata_inventory_put = nil
---Called after the actual action has happened, according to what was allowed. ---Called after the actual action has happened, according to what was allowed.
--- ---
---No return value. ---No return value.
---@type (fun(pos:Position, listname:string, index:number, stack:ItemStack, player:Player): void)? ---@type (fun(pos:MapPosition, listname:string, index:number, stack:ItemStack, player:Player): void)?
Callbacks.on_metadata_inventory_take = nil Callbacks.on_metadata_inventory_take = nil
---If defined, called when an explosion touches the node, instead of ---If defined, called when an explosion touches the node, instead of
---removing the node. ---removing the node.
---* `intensity`: 1.0 = mid range of regular TNT. ---* `intensity`: 1.0 = mid range of regular TNT.
---@type (fun(pos:Position, intensity:number): void)? ---@type (fun(pos:MapPosition, intensity:number): void)?
Callbacks.on_blast = nil Callbacks.on_blast = nil
return Callbacks return Callbacks

View File

@@ -1,10 +1,4 @@
local nodeRequire = Mod.getInfo('smc__core__node').require local Node = Smc.requireNode()
---@type Node
local Node = nodeRequire('Node')
-- -@type ItemFactory
---local ItemFactory = Mod.getInfo('smc__core__item_factory').require('ItemFactory')
---@class Plant : Node ---@class Plant : Node
local Plant = Node:getExtended({ local Plant = Node:getExtended({
@@ -15,6 +9,7 @@ local Plant = Node:getExtended({
paramtype = "light", paramtype = "light",
paramtype2 = "meshoptions", paramtype2 = "meshoptions",
walkable = false, walkable = false,
waving = 1,
buildable_to = true, buildable_to = true,
groups = {dig_immediate = 3}, groups = {dig_immediate = 3},
selection_box = { selection_box = {

View File

@@ -1,2 +1,2 @@
name = smc__core__player name = smc__core__player
depends = smc__system__system_loader depends = smc__system__system_loader, smc__ui__player_inventory

View File

@@ -1,4 +1,36 @@
---@class Player ---@class Player
local Player = {} local Player = {}
---@type PlayerInventoryUI
local PlayerInventoryUI = Mod.getInfo('smc__ui__player_inventory').require('PlayerInventoryUI')
core.register_on_joinplayer(function(player)
player:set_inventory_formspec(PlayerInventoryUI:getFormSpecString(player:get_player_name()))
player:hud_set_hotbar_itemcount(9)
local inv = player:get_inventory()
inv:set_size('main', 18)
-- Player equipment slots:
inv:set_size('equip_head', 2)
inv:set_size('equip_torso', 2)
inv:set_size('equip_legs', 2)
inv:set_size('equip_feet', 2)
inv:set_size('listring_equip', 1) -- Slot for correct listring.
inv:set_size('equip_back', 1)
inv:set_size('equip_left_thigh', 1)
inv:set_size('equip_right_thigh', 1)
end)
core.register_chatcommand('show_inv',
{
func = function(name, param)
PlayerInventoryUI:showForm(name)
return true
end
}
)
local require = Mod.getInfo('smc__core__player').require
require('Player.inventory')
return Player return Player

View File

@@ -1,4 +0,0 @@
---@class Player.GUI
local GUI = {}
return GUI

View File

@@ -0,0 +1,6 @@
---@type PlayerInventoryUI
local PlayerInventoryUI = Mod.getInfo('smc__ui__player_inventory').require('PlayerInventoryUI')
-- TODO: перенести обработки в PlayerUI

View File

@@ -0,0 +1,4 @@
local modInfo = Mod.getInfo('smc__core__processing_station')
local require = modInfo.require
return require('ProcessingStation')

View File

@@ -0,0 +1,2 @@
name = smc__core__processing_station
depends = smc__core__craft_system, smc__core__node

View File

@@ -0,0 +1,385 @@
local FUEL_ENERGY_FACTOR = 0.1
local getInstance = Class.getInstance
local CraftSystem = Smc.requireCraftSystem()
local PlayerInventoryUI = Smc.requirePlayerInventoryUI()
local Node = Smc.requireNode()
local ProcessingStationNode = Node:getExtended({
settings = {
name = '',
drawtype = 'normal',
paramtype = 'light',
groups = { processing_station = 1, dig_immediate = 2 }
},
})
---@class ProcessingStation
---@field name string
---@field timeout number
---@field enableRegression boolean?
---@field enableIdling boolean?
---@field craftType CraftSystem.ProcessingCraftType
---@field fuelGroup string
---@field inputSlots integer
---@field outputSlots integer
---@field fuelSlots integer
---@field handler CraftSystem.ProcessingCraftHandler
---@field tab PlayerInventoryUI.getTabFunc
---@field nodeName string
---@field activeNodeName string?
local ProcessingStation = {}
---Definition table for the `ProcessingStation`.
---
---**Only for EmmyLua.**
---@class ProcessingStationDef
---@field timeout number?
---@field enableRegression boolean?
---@field enableIdling boolean?
---@field craftType CraftSystem.ProcessingCraftType
---@field fuelGroup string?
---@field inputSlots integer?
---@field outputSlots integer?
---@field fuelSlots integer?
---@field tab PlayerInventoryUI.getTabFunc
---@alias ProcessingStation.NodesDef {settings:Node.Settings, activeSettings?:Node.Settings, callbacks:Node.Callbacks?}
---@param name string
---@param def ProcessingStationDef
---@param nodesDef ProcessingStation.NodesDef
function ProcessingStation:new(name, def, nodesDef)
local handler = CraftSystem:getProcessingCraftHandler(def.craftType)
---@type ProcessingStation
local instance = getInstance(self, {})
instance.name = name
instance.timeout = def.timeout or 1
instance.enableRegression = def.enableRegression
instance.enableIdling = def.enableIdling
instance.craftType = def.craftType
instance.fuelGroup = def.fuelGroup or 'fuel'
instance.inputSlots = def.inputSlots or 1
instance.outputSlots = def.outputSlots or 1
instance.fuelSlots = def.outputSlots or 1
instance.handler = handler
instance.tab = def.tab
local settings = nodesDef.settings
local activeSettings = nodesDef.activeSettings
local callbacks = nodesDef.callbacks or {}
local oldCallback = callbacks.on_construct or function(...) end
-- When we install a station in the world,
-- we initialize the metadata, set the inventory size, and start the timer.
callbacks.on_construct = function(pos)
oldCallback(pos)
instance:init(pos)
end
oldCallback = callbacks.on_rightclick or function(...) end
-- Right-clicking on a station opens the player's inventory, adding context to the station tab.
-- Note: we do not use formspec via node metadata.
callbacks.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
oldCallback(pos, node, clicker, itemstack, pointed_thing)
instance:showForm(pos, clicker)
end
oldCallback = callbacks.on_metadata_inventory_move or function(...) end
-- Whenever we change items, we start the station timer,
-- because it can be stopped (if the crafting or fuel runs out).
callbacks.on_metadata_inventory_move = function(pos, from_list, from_index, to_list, to_index, count, player)
oldCallback(pos, from_list, from_index, to_list, to_index, count, player)
instance:startTimer(pos)
end
oldCallback = callbacks.on_metadata_inventory_put or function(...) end
callbacks.on_metadata_inventory_put = function(pos, listname, index, stack, player)
oldCallback(pos, listname, index, stack, player)
instance:startTimer(pos)
end
oldCallback = callbacks.on_metadata_inventory_take or function(...) end
callbacks.on_metadata_inventory_take = function(pos, listname, index, stack, player)
oldCallback(pos, listname, index, stack, player)
instance:startTimer(pos)
end
oldCallback = callbacks.on_timer or function(...) end
-- The basic logic of the station's work.
callbacks.on_timer = function(pos, elapsed, node, timeout)
oldCallback(pos, elapsed, node, timeout)
return instance:onTimer(pos, elapsed, node, timeout)
end
-- Registering a nodes for Luanti.
local node = ProcessingStationNode:new({ settings = settings, callbacks = callbacks })
instance.nodeName = node.itemDef.settings.name
if activeSettings ~= nil then
local activeNode = ProcessingStationNode:new({ settings = activeSettings, callbacks = callbacks })
instance.activeNodeName = activeNode.itemDef.settings.name
end
return instance
end
---Opens the player's inventory, adding the tab described in `self.tab`.
---@param pos MapPosition
---@param player Player
function ProcessingStation:showForm(pos, player)
local playerName = player:get_player_name()
PlayerInventoryUI:addActiveNodeForm(pos, playerName)
PlayerInventoryUI:setContex(playerName, 'left_tab_name', 'node_tab')
PlayerInventoryUI:setContex(playerName, 'node_tab_pos', pos)
PlayerInventoryUI:setContex(playerName, 'node_tab', self.tab)
PlayerInventoryUI:showForm(playerName)
end
---@param pos MapPosition
function ProcessingStation:init(pos)
---@type ProcessingStation.MetaData
local meta = core.get_meta(pos)
meta:set_float('remaining_fuel', 0.0)
meta:set_float('processing_time', 0.0)
local inventory = meta:get_inventory()
inventory:set_size('input', self.inputSlots)
inventory:set_size('output', self.outputSlots)
inventory:set_size('fuel', self.fuelSlots)
self:startTimer(pos)
end
---Starts the station timer only if it is not running.
---
---The timer timeout is set to the timeout specified `self.timeout`.
---
---Returns `true` if the timer has been started.
---@param pos MapPosition
---@return boolean
function ProcessingStation:startTimer(pos)
local timer = core.get_node_timer(pos)
if not timer:is_started() then
timer:start(self.timeout)
return true
end
return false
end
---@param pos MapPosition
---@param elapsed number
---@param node NodeTable
---@param timeout number
---@return boolean
function ProcessingStation:onTimer(pos, elapsed, node, timeout)
---An indicator of whether the station
---is processing resources in this iteration.
local isProcessing = true
---@type ProcessingStation.MetaData
local meta = core.get_meta(pos)
local inventory = meta:get_inventory()
---An indicator of how many units of fuel are currently remaining.
local remainingFuel = meta:get_float('remaining_fuel')
---An indicator of how long the station has been processing the materials.
local processingTime = meta:get_float('processing_time')
local craft = self.handler:getCraftByRecipe(inventory:get_list('input'))
-- If the materials in the input slot are not a recipe for any crafting,
-- then we will not process them.
if craft == nil then
isProcessing = false
end
-- If there is no space in the output slots for the crafting result, then we stop processing.
if isProcessing and craft ~= nil and not inventory:room_for_item('output', craft.output) then
isProcessing = false
end
-- If we are in the process of processing and we run out of fuel,
-- but there are still items in the fuel slot...
if isProcessing and remainingFuel <= 0 and not inventory:is_empty('fuel') then
-- ... then we will convert the first itemstack into station fuel
-- if it has the required fuel group.
local fuelList = inventory:get_list('fuel')
for index, fuelStack in ipairs(fuelList) do
if not fuelStack:is_empty() then
---Fuel units contained in the itemstack.
---
-- Note: since item groups can only contain integers,
-- we divide the fuel units by a constant to convert seconds to smaller units.
local fuelEnergy = core.get_item_group(fuelStack:get_name(), self.fuelGroup or 'fuel') / FUEL_ENERGY_FACTOR
if fuelEnergy > 0 then
local itemCount = fuelStack:get_count()
-- If the energy of one item is not enough for one iteration,
-- we calculate how many items we need to take
if fuelEnergy < timeout then
itemCount = math.min(math.ceil(timeout/fuelEnergy), itemCount)
else
itemCount = 1
end
remainingFuel = remainingFuel + (fuelEnergy * itemCount)
fuelStack:set_count(itemCount)
inventory:remove_item('fuel', fuelStack)
end
end
end
end
if self.enableIdling and isProcessing then
remainingFuel = remainingFuel - timeout
else
remainingFuel = remainingFuel - timeout
end
-- If we don't have fuel remaining,
-- we don't process the materials.
if remainingFuel < 0 then
remainingFuel = 0
isProcessing = false
end
-- If we process materials...
if isProcessing == true then
-- ...then we add the processing progress for this iteration.
processingTime = processingTime + timeout
else
-- ...else we take away progress
-- (if there was progress, but the fuel ran out,
-- the crafting progress will gradually decrease).
if self.enableRegression then
processingTime = processingTime - timeout
end
end
-- If the station is working and the progress time is longer than required for crafting, we produce the craft
-- (we take the item stacks needed for crafting and put the result of the crafting into the output)
if isProcessing and craft ~= nil and processingTime >= craft.time then
for _, item in ipairs(craft.recipe) do
inventory:remove_item('input', item)
end
inventory:add_item('output', craft.output)
processingTime = 0
end
if processingTime < 0 then
processingTime = 0
end
-- If the processing is in progress and the station has an active node type, then we use it.
if self.activeNodeName ~= nil then
if isProcessing then
core.swap_node(pos, {name = self.activeNodeName})
else
core.swap_node(pos, {name = self.nodeName})
end
end
meta:set_float('processing_time', processingTime)
meta:set_float('remaining_fuel', remainingFuel)
PlayerInventoryUI:updateNodeForm(pos)
-- If we not processing we stop the timer so as not to overload the server.
--
-- The timer will have to start again
-- if the player interacts with any items in the station's inventory.
if not isProcessing and (not self.enableRegression or processingTime == 0) and (not self.enableIdling or remainingFuel == 0) then
core.log('timer stop')
return false
else
core.log('timer work')
return true
end
end
--- DEBUG ---
local Formspec = Smc.requireFormspec()
local TileSheet = Smc.requireTileSheet()
local tileSheet = TileSheet:new('debug_processing_station_sheet.png', 16, 16)
local handler = CraftSystem:getProcessingCraftHandler('test')
handler:registerCraft('test_pro_craft', {
output = 'wood:allwhere_log',
recipe = {'wood:allwhere_stick', 'rocks:sylite'},
time = 5,
})
---@param self PlayerInventoryUI
---@param playerName string
---@param tabType PlayerInventoryUI.TabType
---@return Formspec
local tab = function(self, playerName, tabType)
local form = Formspec:new()
local pos = self:getContex(playerName, 'node_tab_pos')
local inventoryLocation = ('nodemeta:%s,%s,%s'):format(pos.x, pos.y, pos.z)
---@type ProcessingStation.MetaData
local meta = core.get_meta(pos)
form
:image(0, 0, 11, 9, 'player_inventory_tab_background.png')
:list(inventoryLocation, 'input', 1, 1, 1, 2)
:list(inventoryLocation, 'output', 3, 1, 1, 1)
:list(inventoryLocation, 'fuel', 1, 4, 1, 1)
:label(4, 3, tostring(meta:get_float('remaining_fuel')))
:label(4.5, 3, tostring(meta:get_float('processing_time')))
return form
end
ProcessingStation:new('test_processing_node', {
craftType = 'test',
tab = tab,
inputSlots = 2,
fuelGroup = 'wood',
enableIdling = true,
enableRegression = false,
},
{
settings = {
name = 'test_processing_node',
tiles = {
tileSheet:t(0, 0),
tileSheet:t(0, 0),
tileSheet:t(0, 1),
tileSheet:t(0, 2),
tileSheet:t(0, 2),
tileSheet:t(0, 2)
}
},
activeSettings = {
name = 'test_processing_node_active',
tiles = {
tileSheet:t(0, 0),
tileSheet:t(0, 0),
tileSheet:t(1, 1),
tileSheet:t(0, 2),
tileSheet:t(0, 2),
tileSheet:t(0, 2)
}
}
})
return ProcessingStation

View File

@@ -0,0 +1,6 @@
---@alias ProcessingStation.MetaData.FloatKey 'remaining_fuel'|'processing_time'
---**Only for EmmyLua.**
---@class ProcessingStation.MetaData : NodeMetaRef
---@field get_float fun(self, key:ProcessingStation.MetaData.FloatKey):number
---@field set_float fun(self, key:ProcessingStation.MetaData.FloatKey, value:number)

Binary file not shown.

After

Width:  |  Height:  |  Size: 6.2 KiB

4
mods/CORE/Tool/init.lua Normal file
View File

@@ -0,0 +1,4 @@
local modInfo = Mod.getInfo('smc__core__tool')
local require = modInfo.require
return require('Tool')

2
mods/CORE/Tool/mod.conf Normal file
View File

@@ -0,0 +1,2 @@
name = smc__core__tool
depends = smc__core__item

View File

@@ -0,0 +1,54 @@
local tableMerge = table.merge
local Item, ItemFactory = Smc.requireItem(), Smc.requireItemFactory()
---@class Tool : Item
---@field defaultDef Item.ItemDefinition
local Tool = Class.extend(Item, {})
---@param ToolDef Item.ItemDefinition
---@return Tool
function Tool:new(ToolDef)
---Adding default parameters
ToolDef = tableMerge(ToolDef, self.defaultDef, true)
ToolDef.settings._type = 'tool'
---@type Tool
local instance = Item:new(ToolDef)
return instance
end
---Allows you to create a child class of an tool by specifying
---default parameters that will be added to the tool's parameters
---when an instance is received.
---@param defaultDef Item.ItemDefinition
---@return Tool
function Tool:getExtended(defaultDef)
defaultDef = tableMerge(defaultDef, self.defaultDef, true)
---@type Tool
local ChildClass = Class.extend(self, {
defaultDef = defaultDef,
})
return ChildClass
end
---Returns an instance of the `ItemFactory` class that can be used to mass-register identical items.
---@param defaultDef? Item.ItemDefinition
---@return ItemFactory
function Tool:getFactory(defaultDef)
if defaultDef == nil then
defaultDef = self.defaultDef
else
defaultDef = tableMerge(self.defaultDef, defaultDef, true)
end
---@type ItemFactory
local instance = ItemFactory:new(self, defaultDef)
return instance
end
return Tool

View File

@@ -1,4 +0,0 @@
local modInfo = Mod.getInfo('smc__core__work_station')
local require = modInfo.require
return require('WorkStation')

View File

@@ -1,229 +0,0 @@
local getInstance = Class.getInstance
---@type CraftSystem.ImmersiveCraftHandler
local ImmersiveCraftHandler = Mod.getInfo('smc__core__craft_system').require('CraftSystem.ImmersiveCraftHandler')
---@type WorkStationUI
local WorkStationUI = Mod.getInfo('smc__ui__work_station').require('WorkStationUI')
---@type Node
local Node = Mod.getInfo('smc__core__node').require('Node')
-- Default settings that a work station node should have.
local WorkStationNode = Node:getExtended({
settings = {
name = 'work_station',
drawtype = 'normal',
paramtype = 'light',
groups = {work_station = 1, dig_immediate = 2,}
}
})
---A work station (node) that enables player interaction
---with the immersive crafting mechanics.
---@class WorkStation
---@field name string
---@field group CraftSystem.CraftGroup
---@field nodeDef Node.NodeDefinition
local WorkStation = {}
---Definition table for the `CraftSystem.WorkStation`.
---
---**Only for EmmyLua.**
---@class WorkStationDef
---@field group CraftSystem.CraftGroup
---@field nodeDef Node.NodeDefinition
---@param name string
---@param def WorkStationDef
function WorkStation:new(name, def)
local nodeDef = def.nodeDef
if nodeDef.callbacks == nil then
---@type Node.Callbacks
nodeDef.callbacks = {}
end
local settings = nodeDef.settings
local callbacks = nodeDef.callbacks
-- Callback when the work station block is installed in the world
-- Ensures initialization of necessary parameters
callbacks.on_construct = function(pos)
-- Getting node metadata
local meta = core.get_meta(pos)
-- Initializing the table of temporary parameters for crafting.
Smc.setCraftDataByMeta(meta)
end
-- Callback for interaction with a work station (start of crafting)
callbacks.on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
-- If the workstation is occupied by another craft...
if not Smc.workStationIsFree(pos) then
-- ...we inform the player about this...
core.chat_send_player(clicker:get_player_name(), 'The workbench is occupied by another craft.')
-- ...and do nothing.
return
end
-- We get a list of crafts that can be produced using the item that the player was holding in his hand.
local crafts = ImmersiveCraftHandler:getCraftsByTriggerItem(itemstack:get_name())
-- If the list is empty...
if crafts == nil then
-- ..this means there are no crafts for this item,
-- so we don't do anything.
return
else
-- ...else we show the player the formspec for choosing a craft.
self:showSelectionCraftForm(clicker, crafts, pos)
end
end
callbacks.on_dig = function(pos, node, digger)
if Smc.workStationIsFree(pos) then
return core.node_dig(pos, node, digger)
else
return false
end
end
---@type WorkStation
local instance = getInstance(self, {})
instance.name = name
instance.group = def.group
instance.nodeDef = nodeDef
-- Registering a node for Luanti.
WorkStationNode:new(nodeDef)
return instance
end
---Show the player the initial workstation interface for choosing a craft.
---@param player Player
---@param crafts CraftSystem.ImmersiveCraft[]
---@param pos Position
function WorkStation:showSelectionCraftForm(player, crafts, pos)
-- Create a table in the format craft result - craft name.
local outputs = {}
for _, craft in ipairs(crafts) do
outputs[craft.output] = craft.name
end
-- We get the name of the player who wants to start crafting.
local playerName = player:get_player_name()
-- We set the context for transferring data about the workstation coordinates and the list of crafts.
WorkStationUI:setContex(playerName, 'pos', pos)
WorkStationUI:setContex(playerName, 'outputs', outputs)
-- Showing the desktop interface to the player.
WorkStationUI:showForm(playerName,false)
end
-- Registering a callback for player choice of craft (this does not start crafting).
WorkStationUI:registerOnFormFieldActionMatch('%S+::item_button',function(player, fieldName, fieldValue)
-- We get the name of the craft from the name of the button the player pressed.
local craftName = string.match(fieldName, '(%S+)::item_button')
assert(craftName ~= nil, 'Craft name cannot be empty')
-- We get a craft object.
local craft = ImmersiveCraftHandler:getCraftByName(craftName)
-- We get the name of the player who wants to start crafting.
local playerName = player:get_player_name()
-- We enter into the context the craft that the player has chosen.
WorkStationUI:setContex(playerName, 'craft', craft)
-- We show the player a new interface with a crafting description tab.
WorkStationUI:showForm(playerName, true)
end)
-- We register a callback when the player starts crafting.
WorkStationUI:registerOnFormFieldAction('work_station:start_craft', function(player, fieldName, fieldValue)
-- We get the name of the player who wants to start crafting.
local playerName = player:get_player_name()
-- We get the workstation position and craft from the context.
local pos = WorkStationUI:getContex(playerName, 'pos')
---@type CraftSystem.ImmersiveCraft
local craft = WorkStationUI:getContex(playerName, 'craft')
-- We process the amount of crafting.
local isCraftStart = false
if fieldValue == 'x1' then
-- Single craft
isCraftStart = craft:startCraft(pos, player, 1)
elseif fieldValue == 'x10' then
-- Ten crafts at a time.
isCraftStart = craft:startCraft(pos, player, 10)
end
-- If the craft was started...
if isCraftStart then
-- ...we are closing the formspec.
WorkStationUI:closeForm(playerName)
end
end)
-- --- DEBUG ---
WorkStation:new('test_station', {
group = 'test',
nodeDef = {
settings = {
name = 'test_station',
tiles = {'test_station.png'}
}
}
})
ImmersiveCraftHandler:registerCraft('bricks', {
triggerItem = 'rocks:sylite',
output = 'rocks:sylite_bricks',
startStageName = 'tapping',
group = 'test',
stages = {
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping',
targetItem = 'rocks:sylite',
type = 'tapping',
clicksNeed = 3,
}
},
})
ImmersiveCraftHandler:registerCraft('block', {
triggerItem = 'rocks:sylite',
output = 'rocks:sylite_block',
startStageName = 'tapping',
group = 'test',
stages = {
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping',
targetItem = 'rocks:sylite',
type = 'tapping',
clicksNeed = 5,
}
},
})
ImmersiveCraftHandler:registerCraft('marentine_planks', {
triggerItem = 'wood:marentine_log',
output = 'wood:marentine_planks',
startStageName = 'tapping',
group = 'test',
stages = {
---@type CraftSystem.ImmersiveCraftStage.TappingStageDef
{
name = 'tapping',
targetItem = 'wood:marentine_log',
type = 'tapping',
clicksNeed = 5,
}
},
})
return WorkStation

View File

@@ -1,73 +0,0 @@
local modInfo = Mod.getInfo('smc__core__formspec')
local require = modInfo.require
---@type Formspec
local Formspec = require('Formspec')
local listForm = Formspec:new({
size = {x=21, y=12},
})
listForm:list('current_player', 'main', 10.5, 6.5, 8, 4)
local listFormItems = Formspec:new()
local items = table.get_keys(core.registered_nodes)
table.sort(items)
local w, h = 0, 0
---@param name string
for _, name in ipairs(items) do
listFormItems:itemImageButton(w, h, 1, 1, name, name..'::item_button')
w = w + 1
if w > 9 then
w = 0
h = h + 1
end
end
--listFormItems:list('current_player', 'main', 0, 0, 1, 32)
listForm:
scrollContainer(listFormItems, 0.5, 0.5, 9, 11, 'admin_commands:list_items', 'vertical'):
scrollbar(10, 0.5, 0.25, 10, 'vertical', 'admin_commands:list_items')
core.register_chatcommand('list', {
privs = {server = true},
func = function(name, param)
local player = core.get_player_by_name(name)
core.show_formspec(name, 'admin_commands:list_form', listForm:toString())
return true, ''
end
})
core.register_on_player_receive_fields(function(player, formname, fields)
if formname ~= 'admin_commands:list_form' then
return
end
for key, value in pairs(fields) do
if string.ends_with(key, '::item_button') then
---@type ItemStackString?
local stack = string.match(key, '(%S+)::item_button')
if stack == nil then
return
end
core.log(tostring(stack))
---@type InvRef
local inv = player:get_inventory()
if inv:room_for_item("main", stack) then
inv:add_item("main", stack)
end
end
end
end)

View File

@@ -1,2 +0,0 @@
name = smc__core__admin_commands
depends = smc__system__system_loader, smc__core__formspec, smc__core__item

Some files were not shown because too many files have changed in this diff Show More