113 Commits

Author SHA1 Message Date
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
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
138 changed files with 3306 additions and 10130 deletions

View File

@@ -2,7 +2,7 @@
**The MIT License (MIT)** **The MIT License (MIT)**
Copyright (c) 2025 Apancore.Studio, Van (varttist), 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:
@@ -16,7 +16,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
**CC BY 4.0** **CC BY 4.0**
Copyright (c) 2025 Apancore.Studio, Van (varttist) 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. All textures except those listed here are copyrighted by Van (varttist) and are distributed under the CC BY 4.0.

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

@@ -24,13 +24,16 @@ function BaseUI:new(name, getFormSpecString, clearContex)
instance.getFormSpecString = getFormSpecString instance.getFormSpecString = getFormSpecString
if clearContex then if clearContex then
core.log(name)
-- 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 end
instance:registerOnFormQuit(function(player)
Smc.clearActiveFormspec(player:get_player_name())
end)
return instance return instance
end end
@@ -118,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

@@ -5,24 +5,119 @@ 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.PrimitiveCraftType 'inside_player_inventory'
---@alias CraftSystem.ImmersiveCraftType 'workbench'
---@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(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(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(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 end
return CraftSystem return CraftSystem

View File

@@ -1,13 +1,28 @@
---Abstract class for craft. ---@class CraftSystem.BaseCraft : Class
---@class CraftSystem.BaseCraft
---@field name string ---@field name string
---@field recipe ItemStackString[]
---@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 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.output = def.output
instance.group = def.group
return instance
end
return BaseCraft return BaseCraft

View File

@@ -1,22 +1,49 @@
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 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 type CraftSystem.CraftType
---@param def CraftSystem.BaseCraftHandlerDef
---@return CraftSystem.BaseCraftHandler
function BaseCraftHandler:new(type, def)
---@type CraftSystem.BaseCraftHandler
local instance = self:getInstance({})
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 +54,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

@@ -18,18 +18,16 @@ 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 triggerItem ItemStackString
---@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 triggerItem ItemStackString
---@field output string
---@field stages CraftSystem.ImmersiveCraftStageDef[] ---@field stages CraftSystem.ImmersiveCraftStageDef[]
---@param name string ---@param name string
@@ -53,12 +51,9 @@ function ImmersiveCraft:new(name, def)
end end
---@type CraftSystem.ImmersiveCraft ---@type CraftSystem.ImmersiveCraft
local instance = getInstance(self, {}) local instance = BaseCraft:new(name, def)
instance.name = name
instance.group = def.group
instance.startStageName = def.startStageName instance.startStageName = def.startStageName
instance.triggerItem = def.triggerItem 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.

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,14 +11,21 @@ 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 defaultCraftDef CraftSystem.BaseCraftDef
---
---@field craftsByTriggerItem table<string, CraftSystem.ImmersiveCraft[]> ---@field craftsByTriggerItem table<string, CraftSystem.ImmersiveCraft[]>
---
---@field new fun(self:CraftSystem.ImmersiveCraftHandler, 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 = {}, 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)
---@param craftName string ---@param craftName string
@@ -29,11 +34,14 @@ 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. -- The craft group to which the craft belongs.
local group = def.group local group = 'craft_group:' .. (def.group or 'UNDEFINED')
def.group = group
-- We obtain a crafting instance according to the given parameters.
local craft = ImmersiveCraft:new(craftName, def)
-- If no craft with this group has been registered before... -- If no craft with this group has been registered before...
if self.craftsByGroup[group] == nil then if self.craftsByGroup[group] == nil then
@@ -68,4 +76,29 @@ function ImmersiveCraftHandler:getCraftsByTriggerItem(triggerItem)
return crafts return crafts
end end
core.register_on_mods_loaded(function()
for groupName, crafts in pairs(ImmersiveCraftHandler.craftsByGroup) do
tableSort(crafts, function(a, b)
if a.output < b.output then
return true
end
end)
if groupName ~= 'craft_group:UNDEFINED' then
tableInsert(ImmersiveCraftHandler.groupedCrafts, crafts)
else
ImmersiveCraftHandler.groupedCrafts = tableJoin(ImmersiveCraftHandler.groupedCrafts, crafts)
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

@@ -7,31 +7,25 @@ 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 altRecipes CraftSystem.CraftRecipe[]
---@field recipe CraftSystem.CraftRecipe ---@field returnItems ItemStackString[]?
---@field returnItems ItemStackString[] local PrimitiveCraft = BaseCraft:extend({})
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 altRecipes CraftSystem.CraftRecipe[]?
---@field recipe CraftSystem.CraftRecipe ---@field returnItems ItemStackString[]?
---@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 = BaseCraft:new(name, def)
name = name, instance.altRecipes = def.altRecipes or {}
group = def.group, instance.returnItems = def.returnItems
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, 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,40 @@ 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
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 = 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, 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

@@ -4,6 +4,14 @@ local tableCopy, tableMerge, colorize = table.copy, table.merge, core.colorize
local ItemFactory = Smc.requireItemFactory() local ItemFactory = Smc.requireItemFactory()
---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
@@ -57,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
@@ -98,22 +110,26 @@ 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
@@ -142,12 +158,6 @@ local function registerTool(luantiDef)
core.register_tool(':'..name, luantiDef) core.register_tool(':'..name, luantiDef)
end end
---The alias `table.merge` for EmmyLua
---@type fun(...):(Item.ItemDefinition)
local defMerge = function(...)
return tableMerge(...)
end
---@param itemDef Item.ItemDefinition|Node.NodeDefinition ---@param itemDef Item.ItemDefinition|Node.NodeDefinition
---@return Item ---@return Item
function Item:new(itemDef) function Item:new(itemDef)
@@ -158,8 +168,9 @@ function Item:new(itemDef)
itemDef = tableCopy(itemDef) itemDef = tableCopy(itemDef)
-- Adding default parameters -- Adding default parameterss
itemDef = defMerge(itemDef, self.defaultDef, true) ---@type Item.ItemDefinition
itemDef = tableMerge(itemDef, self.defaultDef, true)
local s = itemDef.settings local s = itemDef.settings
local shortModName = Mod.getInfo().shortName local shortModName = Mod.getInfo().shortName
@@ -207,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, true) defaultDef = tableMerge(defaultDef, self.defaultDef, true)
---@type Item ---@type Item
local ChildClass = extend(self, { local ChildClass = extend(self, {
@@ -224,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, true) defaultDef = tableMerge(self.defaultDef, defaultDef, true)
end end
---@type ItemFactory ---@type ItemFactory

View File

@@ -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

@@ -551,7 +551,7 @@ end
-- --- GENERATION METHODS --- -- --- GENERATION METHODS ---
---@alias MapGen.nodeType 'AIR'|'WATER'|'CAVERN_AIR'|'TURF'|'SOIL'|'ROCK'|'BOTTOM' ---@alias MapGen.nodeType 'AIR'|'WATER'|'CAVERN_AIR'|'TURF'|'SOIL'|'ROCK'|'BOTTOM'
---@alias MapGen.postProcessingData {biome:MapGen.Biome, mapGenerator:MapGen, factors:MapGen.factors, data:number[], index:number, x:number, y:number, z:number, nodeType:MapGen.nodeType} ---@alias MapGen.postProcessingData {biome:MapGen.Biome, mapGenerator:MapGen, factors:MapGen.factors, index:number, x:number, y:number, z:number, nodeType:MapGen.nodeType}
---@type table<number, MapGen.postProcessingData> ---@type table<number, MapGen.postProcessingData>
local postProcessing = {} local postProcessing = {}
@@ -559,13 +559,12 @@ local postProcessing = {}
---@param biome MapGen.Biome ---@param biome MapGen.Biome
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors ---@param factors MapGen.factors
---@param data number[]
---@param index number ---@param index number
---@param x integer ---@param x integer
---@param y integer ---@param y integer
---@param z integer ---@param z integer
---@param nodeType MapGen.nodeType ---@param nodeType MapGen.nodeType
local function addPostProccessing(biome, mapGenerator, factors, data, index, x, y, z, nodeType) local function addPostProccessing(biome, mapGenerator, factors, index, x, y, z, nodeType)
if biome.postProcessing == nil then if biome.postProcessing == nil then
return return
end end
@@ -574,7 +573,6 @@ local function addPostProccessing(biome, mapGenerator, factors, data, index, x,
biome = biome, biome = biome,
mapGenerator = mapGenerator, mapGenerator = mapGenerator,
factors = factors, factors = factors,
data = data,
index = index, index = index,
x = x, x = x,
y = y, y = y,
@@ -589,11 +587,12 @@ end
---@param layer MapGen.Layer ---@param layer MapGen.Layer
---@param factors MapGen.factors ---@param factors MapGen.factors
---@param data number[] ---@param data number[]
---@param data2 number[]
---@param index number ---@param index number
---@param x integer ---@param x integer
---@param y integer ---@param y integer
---@param z integer ---@param z integer
local function generateNode(mapGenerator, layer, factors, data, index, x, y, z) local function generateNode(mapGenerator, layer, factors, data, data2, index, x, y, z)
local ids = mapGenerator.nodeIDs local ids = mapGenerator.nodeIDs
local waterLevel = layer.waterLevel local waterLevel = layer.waterLevel
@@ -629,39 +628,39 @@ local function generateNode(mapGenerator, layer, factors, data, index, x, y, z)
-- If the block is above surface height and above water level... -- If the block is above surface height and above water level...
if y > height and y > waterLevel then if y > height and y > waterLevel then
-- ... then airspace is generated. -- ... then airspace is generated.
biome:generateAir(mapGenerator, factors, data, index, x, y, z) biome:generateAir(mapGenerator, factors, data, data2, index, x, y, z)
addPostProccessing(biome, mapGenerator, factors, data, index, x, y, z, 'AIR') addPostProccessing(biome, mapGenerator, factors, index, x, y, z, 'AIR')
-- If the block is above the surface height BUT below the water level... -- If the block is above the surface height BUT below the water level...
elseif y > height and y <= waterLevel then elseif y > height and y <= waterLevel then
-- ... then underwater space is generated. -- ... then underwater space is generated.
biome:generateWater(mapGenerator, factors, data, index, x, y, z) biome:generateWater(mapGenerator, factors, data, data2, index, x, y, z)
addPostProccessing(biome, mapGenerator, factors, data, index, x, y, z, 'WATER') addPostProccessing(biome, mapGenerator, factors, index, x, y, z, 'WATER')
-- If the block is below the surface height... -- If the block is below the surface height...
elseif y <= height then elseif y <= height then
-- ... and a cavern is generated in the block... -- ... and a cavern is generated in the block...
if mapGenerator:isCavern(layer, x, y, z) then if mapGenerator:isCavern(layer, x, y, z) then
-- ... then airspace is generated. -- ... then airspace is generated.
biome:generateCavernAir(mapGenerator, factors, data, index, x, y, z) biome:generateCavernAir(mapGenerator, factors, data, data2, index, x, y, z)
addPostProccessing(biome, mapGenerator, factors, data, index, x, y, z, 'CAVERN_AIR') addPostProccessing(biome, mapGenerator, factors, index, x, y, z, 'CAVERN_AIR')
-- ... or if the surface height is above the water level... -- ... or if the surface height is above the water level...
elseif height > waterLevel then elseif height > waterLevel then
--- ... and the height of the block is equal to the height of the surface... --- ... and the height of the block is equal to the height of the surface...
if y == height then if y == height then
-- ... then turf is generated. -- ... then turf is generated.
biome:generateTurf(mapGenerator, factors, data, index, x, y, z) biome:generateTurf(mapGenerator, factors, data, data2, index, x, y, z)
addPostProccessing(biome, mapGenerator, factors, data, index, x, y, z, 'TURF') addPostProccessing(biome, mapGenerator, factors, index, x, y, z, 'TURF')
-- ... or if the height of the block falls within the thickness of the soil layer... -- ... or if the height of the block falls within the thickness of the soil layer...
elseif y > height - biome.soilHeight then elseif y > height - biome.soilHeight then
-- ... then soil is generated. -- ... then soil is generated.
biome:generateSoil(mapGenerator, factors, data, index, x, y, z) biome:generateSoil(mapGenerator, factors, data, data2, index, x, y, z)
addPostProccessing(biome, mapGenerator, factors, data, index, x, y, z, 'SOIL') addPostProccessing(biome, mapGenerator, factors, index, x, y, z, 'SOIL')
else else
-- ... else a stone is generated. -- ... else a stone is generated.
biome:generateRock(mapGenerator, factors, data, index, x, y, z) biome:generateRock(mapGenerator, factors, data, data2, index, x, y, z)
addPostProccessing(biome, mapGenerator, factors, data, index, x, y, z, 'ROCK') addPostProccessing(biome, mapGenerator, factors, index, x, y, z, 'ROCK')
end end
-- ... or if the surface height is below the water level... -- ... or if the surface height is below the water level...
@@ -669,12 +668,12 @@ local function generateNode(mapGenerator, layer, factors, data, index, x, y, z)
-- ... and if the height of the block falls within the thickness of the soil layer... -- ... and if the height of the block falls within the thickness of the soil layer...
if y > height - biome.soilHeight then if y > height - biome.soilHeight then
-- ... then the river/ocean bottom is generated. -- ... then the river/ocean bottom is generated.
biome:generateBottom(mapGenerator, factors, data, index, x, y, z) biome:generateBottom(mapGenerator, factors, data, data2, index, x, y, z)
addPostProccessing(biome, mapGenerator, factors, data, index, x, y, z, 'BOTTOM') addPostProccessing(biome, mapGenerator, factors, index, x, y, z, 'BOTTOM')
else else
-- ... else a stone is generated. -- ... else a stone is generated.
biome:generateRock(mapGenerator, factors, data, index, x, y, z) biome:generateRock(mapGenerator, factors, data, data2, index, x, y, z)
addPostProccessing(biome, mapGenerator, factors, data, index, x, y, z, 'ROCK') addPostProccessing(biome, mapGenerator, factors, index, x, y, z, 'ROCK')
end end
end end
else else
@@ -828,15 +827,16 @@ end
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param layer MapGen.Layer? ---@param layer MapGen.Layer?
---@param data number[] ---@param data number[]
---@param data2 number[]
---@param index number ---@param index number
---@param x integer ---@param x integer
---@param y integer ---@param y integer
---@param z integer ---@param z integer
local function generatorHandler(mapGenerator, layer, data, index, x, y, z) local function generatorHandler(mapGenerator, layer, data, data2, index, x, y, z)
-- If the node belongs to a static layer, then a static node is generated. -- If the node belongs to a static layer, then a static node is generated.
local static = mapGenerator:getStaticByHeight(y) local static = mapGenerator:getStaticByHeight(y)
if static ~= nil then if static ~= nil then
static:generateStaticNode(mapGenerator, data, index, x, y, z) static:generateStaticNode(mapGenerator, data, data2, index, x, y, z)
return return
end end
@@ -870,7 +870,7 @@ local function generatorHandler(mapGenerator, layer, data, index, x, y, z)
humidity = humidity, humidity = humidity,
} }
generateNode(mapGenerator, layer, factors, data, index, x, y, z) generateNode(mapGenerator, layer, factors, data, data2, index, x, y, z)
end end
---Chunk generation handler. ---Chunk generation handler.
@@ -900,7 +900,7 @@ function MapGen:onMapGenerated(voxelManip, minPos, maxPos, blockseed)
self:initCavernsNoise() self:initCavernsNoise()
end end
local data = voxelManip:get_data() local data, data2 = voxelManip:get_data(), voxelManip:get_param2_data()
-- local param2_data = voxelManip:get_param2_data() -- local param2_data = voxelManip:get_param2_data()
local area = VoxelArea:new({MinEdge = eMin, MaxEdge = eMax}) local area = VoxelArea:new({MinEdge = eMin, MaxEdge = eMax})
@@ -917,19 +917,19 @@ function MapGen:onMapGenerated(voxelManip, minPos, maxPos, blockseed)
index = area:index(x, y, z) index = area:index(x, y, z)
if data[index] == AIR_ID then if data[index] == AIR_ID then
generatorHandler(self, layer, data, index, x, y, z) generatorHandler(self, layer, data, data2, index, x, y, z)
end end
end end
end end
end end
-- Post-proccesing generation -- Post-proccesing generation
for _, ppdata in pairs(postProcessing) do for _, ppdata in pairs(postProcessing) do
if ppdata.biome.postProcessing ~= nil then if ppdata.biome.postProcessing ~= nil then
ppdata.biome:postProcessing(ppdata.mapGenerator, ppdata.biome:postProcessing(ppdata.mapGenerator,
ppdata.factors, ppdata.factors,
ppdata.data, data,
data2,
ppdata.index, ppdata.index,
ppdata.x, ppdata.x,
ppdata.y, ppdata.y,
@@ -941,17 +941,15 @@ function MapGen:onMapGenerated(voxelManip, minPos, maxPos, blockseed)
-- We make changes back to LVM and recalculate light & liquids -- We make changes back to LVM and recalculate light & liquids
voxelManip:set_data(data) voxelManip:set_data(data)
voxelManip:set_param2_data(data2)
core.generate_ores(voxelManip, minPos, maxPos) core.generate_ores(voxelManip, minPos, maxPos)
core.generate_decorations(voxelManip, minPos, maxPos) core.generate_decorations(voxelManip, minPos, maxPos)
--voxelManip:set_param2_data()
voxelManip:set_lighting({ day = 14, night = 0}) voxelManip:set_lighting({ day = 14, night = 0})
voxelManip:calc_lighting() voxelManip:calc_lighting()
voxelManip:update_liquids() voxelManip:update_liquids()
pastTriangle = nil
if PROFILE_CHUNK then if PROFILE_CHUNK then
endTime = getUsTime() endTime = getUsTime()
mglog('Chunk end:\n'.. mglog('Chunk end:\n'..

View File

@@ -18,10 +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[], index:number, x:number, y:number, z:number, nodeType:MapGen.nodeType, area:VoxelArea)? ---@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, factors:MapGen.factors, 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`.
--- ---
@@ -40,7 +40,7 @@ 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[], index:number, x:number, y:number, z:number, nodeType:MapGen.nodeType, area:VoxelArea)? ---@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
@@ -48,11 +48,12 @@ local Biome = {}
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors ---@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, factors, 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
@@ -60,23 +61,25 @@ end
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors ---@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, factors, data, index, x, y, z) local defaultGenerateCavernAir = function(self, mapGenerator, factors, data, data2, index, x, y, z)
self:generateAir(mapGenerator, factors, 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 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, factors, 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
@@ -84,11 +87,12 @@ end
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors ---@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, factors, 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
@@ -96,11 +100,12 @@ end
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors ---@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, factors, 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
@@ -108,11 +113,12 @@ end
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors ---@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, factors, 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
@@ -120,11 +126,12 @@ end
---@param mapGenerator MapGen ---@param mapGenerator MapGen
---@param factors MapGen.factors ---@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, factors, 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

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 fun(self, mapGenerator:MapGen, data:number[], index:number, x:number, y:number, z:number) ---@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 fun(self, mapGenerator:MapGen, data:number[], index:number, x:number, y:number, z:number) ---@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,22 +1,92 @@
local tableMerge = table.merge
local Item, ItemFactory = Smc.requireItem(), Smc.requireItemFactory() local Item, ItemFactory = Smc.requireItem(), Smc.requireItemFactory()
---@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._type = 'node' 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)
@@ -29,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, {
@@ -46,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

@@ -9,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

@@ -9,6 +9,15 @@ core.register_on_joinplayer(function(player)
player:hud_set_hotbar_itemcount(9) player:hud_set_hotbar_itemcount(9)
local inv = player:get_inventory() local inv = player:get_inventory()
inv:set_size('main', 18) 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) end)
core.register_chatcommand('show_inv', core.register_chatcommand('show_inv',
@@ -20,4 +29,8 @@ core.register_chatcommand('show_inv',
} }
) )
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,384 @@
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_node = 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)
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

View File

@@ -1,20 +1,16 @@
local tableMerge = table.merge
local Item, ItemFactory = Smc.requireItem(), Smc.requireItemFactory() local Item, ItemFactory = Smc.requireItem(), Smc.requireItemFactory()
---@class Tool : Item ---@class Tool : Item
---@field defaultDef Item.ItemDefinition ---@field defaultDef Item.ItemDefinition
local Tool = Class.extend(Item, {}) local Tool = Class.extend(Item, {})
---The alias `table.merge` for EmmyLua
---@type fun(...):(Item.ItemDefinition)
local defMerge = function(...)
return table.merge(...)
end
---@param ToolDef Item.ItemDefinition ---@param ToolDef Item.ItemDefinition
---@return Tool ---@return Tool
function Tool:new(ToolDef) function Tool:new(ToolDef)
---Adding default parameters ---Adding default parameters
ToolDef = defMerge(ToolDef, self.defaultDef, true) ToolDef = tableMerge(ToolDef, self.defaultDef, true)
ToolDef.settings._type = 'tool' ToolDef.settings._type = 'tool'
@@ -29,7 +25,7 @@ end
---@param defaultDef Item.ItemDefinition ---@param defaultDef Item.ItemDefinition
---@return Tool ---@return Tool
function Tool:getExtended(defaultDef) function Tool:getExtended(defaultDef)
defaultDef = defMerge(defaultDef, self.defaultDef) defaultDef = tableMerge(defaultDef, self.defaultDef, true)
---@type Tool ---@type Tool
local ChildClass = Class.extend(self, { local ChildClass = Class.extend(self, {
@@ -46,7 +42,7 @@ function Tool: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
@@ -54,17 +50,5 @@ function Tool:getFactory(defaultDef)
return instance return instance
end end
--[[
Tool:new({
settings = {
name = 'tool',
inventory_image = 'anoba.png',
tool_capabilities = {
groupcaps={
crumbly={maxlevel=2, uses=20, times={[1]=1.60, [2]=1.20, [3]=0.80}}
},
}
}
})--]]
return Tool return Tool

View File

@@ -1,10 +1,6 @@
local getInstance = Class.getInstance local getInstance = Class.getInstance
---@type CraftSystem.ImmersiveCraftHandler local CraftSystem = Smc.requireCraftSystem()
local ImmersiveCraftHandler = Mod.getInfo('smc__core__craft_system').require('CraftSystem.ImmersiveCraftHandler')
---@type WorkStationUI
local WorkStationUI = Mod.getInfo('smc__ui__work_station').require('WorkStationUI')
local Node = Smc.requireNode() local Node = Smc.requireNode()
@@ -14,7 +10,7 @@ local WorkStationNode = Node:getExtended({
name = 'work_station', name = 'work_station',
drawtype = 'normal', drawtype = 'normal',
paramtype = 'light', paramtype = 'light',
groups = {work_station = 1, dig_immediate = 2,} groups = { work_station = 1, dig_immediate = 2 }
} }
}) })
@@ -22,21 +18,32 @@ local WorkStationNode = Node:getExtended({
---with the immersive crafting mechanics. ---with the immersive crafting mechanics.
---@class WorkStation ---@class WorkStation
---@field name string ---@field name string
---@field group CraftSystem.CraftGroup ---@field craftType CraftSystem.ImmersiveCraftType
---@field nodeDef Node.NodeDefinition ---@field handler CraftSystem.ImmersiveCraftHandler
---@field UI BaseUI
local WorkStation = {} local WorkStation = {}
---Definition table for the `CraftSystem.WorkStation`. ---Definition table for the `WorkStation`.
--- ---
---**Only for EmmyLua.** ---**Only for EmmyLua.**
---@class WorkStationDef ---@class WorkStationDef
---@field group CraftSystem.CraftGroup ---@field craftType CraftSystem.ImmersiveCraftType
---@field nodeDef Node.NodeDefinition ---@field UI BaseUI
---@param name string ---@param name string
---@param def WorkStationDef ---@param def WorkStationDef
function WorkStation:new(name, def) ---@param nodeDef Node.NodeDefinition
local nodeDef = def.nodeDef function WorkStation:new(name, def, nodeDef)
local handler = CraftSystem:getImmersiveCraftHandler(def.craftType)
local UI = def.UI
---@type WorkStation
local instance = getInstance(self, {})
instance.name = name
instance.handler = handler
instance.craftType = def.craftType
instance.UI = UI
if nodeDef.callbacks == nil then if nodeDef.callbacks == nil then
---@type Node.Callbacks ---@type Node.Callbacks
nodeDef.callbacks = {} nodeDef.callbacks = {}
@@ -65,7 +72,7 @@ function WorkStation:new(name, def)
end end
-- We get a list of crafts that can be produced using the item that the player was holding in his hand. -- 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()) local crafts = handler:getCraftsByTriggerItem(itemstack:get_name())
-- If the list is empty... -- If the list is empty...
if crafts == nil then if crafts == nil then
@@ -74,7 +81,7 @@ function WorkStation:new(name, def)
return return
else else
-- ...else we show the player the formspec for choosing a craft. -- ...else we show the player the formspec for choosing a craft.
self:showSelectionCraftForm(clicker, crafts, pos) instance:showSelectionCraftForm(clicker, crafts, pos)
end end
end end
@@ -86,7 +93,7 @@ function WorkStation:new(name, def)
local craftData = Smc.getCraftDataByPos(pos) local craftData = Smc.getCraftDataByPos(pos)
assert(craftData ~= nil, 'Immersive crafting data is empty.') assert(craftData ~= nil, 'Immersive crafting data is empty.')
local craft = ImmersiveCraftHandler:getCraftByName(craftData.craftName) local craft = handler:getCraftByName(craftData.craftName)
craft:abortCraft(pos) craft:abortCraft(pos)
end end
@@ -98,11 +105,50 @@ function WorkStation:new(name, def)
end end
end end
---@type WorkStation -- Registering a callback for player choice of craft (this does not start crafting).
local instance = getInstance(self, {}) UI:registerOnFormFieldActionMatch('%S+::item_button',function(player, fieldName, fieldValue)
instance.name = name -- We get the name of the craft from the name of the button the player pressed.
instance.group = def.group local craftName = string.match(fieldName, '(%S+)::item_button')
instance.nodeDef = nodeDef assert(craftName ~= nil, 'Craft name cannot be empty')
-- We get a craft object.
local craft = handler: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.
UI:setContex(playerName, 'craft', craft)
-- We show the player a new interface with a crafting description tab.
UI:showForm(playerName, true)
end)
-- We register a callback when the player starts crafting.
UI: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 = UI:getContex(playerName, 'pos')
---@type CraftSystem.ImmersiveCraft
local craft = UI: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.
UI:closeForm(playerName)
end
end)
-- Registering a node for Luanti. -- Registering a node for Luanti.
WorkStationNode:new(nodeDef) WorkStationNode:new(nodeDef)
@@ -124,71 +170,35 @@ function WorkStation:showSelectionCraftForm(player, crafts, pos)
-- We get the name of the player who wants to start crafting. -- We get the name of the player who wants to start crafting.
local playerName = player:get_player_name() local playerName = player:get_player_name()
local UI = self.UI
-- We set the context for transferring data about the workstation coordinates and the list of crafts. -- We set the context for transferring data about the workstation coordinates and the list of crafts.
WorkStationUI:setContex(playerName, 'pos', pos) UI:setContex(playerName, 'pos', pos)
WorkStationUI:setContex(playerName, 'outputs', outputs) UI:setContex(playerName, 'outputs', outputs)
-- Showing the desktop interface to the player. -- Showing the desktop interface to the player.
WorkStationUI:showForm(playerName,false) UI:showForm(playerName,false)
end 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 --- -- --- DEBUG ---
---@type WorkStationUI
local WorkStationUI = Mod.getInfo('smc__ui__work_station').require('WorkStationUI')
local ImmersiveCraftHandler = CraftSystem:getImmersiveCraftHandler('workbench')
WorkStation:new('test_station', { WorkStation:new('test_station', {
group = 'test', craftType = 'workbench',
nodeDef = { UI = WorkStationUI
},
{
settings = { settings = {
name = 'test_station', name = 'test_station',
tiles = {'test_station.png'} tiles = {'test_station.png'}
} }
} }
}) )
ImmersiveCraftHandler:registerCraft('bricks', { ImmersiveCraftHandler:registerCraft('bricks', {
triggerItem = 'rocks:sylite', triggerItem = 'rocks:sylite',

View File

@@ -16,39 +16,4 @@ core.register_mapgen_script(core.get_modpath('smc__core__map_generator')..'/src/
-- For now, the generation does not have its own support -- For now, the generation does not have its own support
-- for the generation of ores and decorations, so vanilla ones are used. -- for the generation of ores and decorations, so vanilla ones are used.
core.register_ore({
ore_type = "scatter",
ore = "soils:rocky_soil_baren",
wherein = "rocks:sylite",
clust_scarcity = 8*8*8,
clust_num_ores = 8,
clust_size = 3,
y_min = -31000,
y_max = 64,
})
core.register_decoration({
deco_type = "simple",
place_on = "soils:turf_swamp",
sidelen = 8,
fill_ratio = 0.4,
decoration = "plants:plants",
})
core.register_decoration({
deco_type = "simple",
place_on = "soils:turf_swamp",
sidelen = 8,
fill_ratio = 0.05,
decoration = "plants:plant0",
})
core.register_decoration({
deco_type = "simple",
place_on = "soils:turf_swamp",
sidelen = 8,
fill_ratio = 0.01,
decoration = "plants:plant2",
})
return mapGenerator return mapGenerator

View File

@@ -18,13 +18,13 @@ local MapGen = mapGenRequire('MapGen')
sylite = 'rocks:sylite', sylite = 'rocks:sylite',
syliteGray = 'rocks:sylite_gray', syliteGray = 'rocks:sylite_gray',
syliteBlack = 'rocks:sylite_black', syliteBlack = 'rocks:sylite_black',
tauitite = 'rocks:tauitite', tauititeLight = 'rocks:tauitite_light',
iyellite = 'rocks:iyellite', --iyellite = 'rocks:iyellite',
falmyte = 'rocks:falmyte', --falmyte = 'rocks:falmyte',
hapcoryte = 'rocks:hapcoryte', --hapcoryte = 'rocks:hapcoryte',
burcite = 'rocks:burcite', --burcite = 'rocks:burcite',
felhor = 'rocks:felhor', --felhor = 'rocks:felhor',
malachite = 'rocks:malachite', --malachite = 'rocks:malachite',
-- Liquids -- Liquids
water = 'liquids:water_source', water = 'liquids:water_source',
@@ -91,9 +91,9 @@ local ocean = {
local common_lands = { local common_lands = {
['landscape'] = { ['landscape'] = {
offset = 0, offset = 10,
scale = 5, scale = 5,
spread = {x = 10, y = 10, z = 10}, spread = {x = 15, y = 15, z = 15},
seed = 88005553535, seed = 88005553535,
octaves = 2, octaves = 2,
persistence = 0.4, persistence = 0.4,
@@ -273,7 +273,7 @@ local rivers = {
['landscape'] = { ['landscape'] = {
offset = -5, offset = -5,
scale = 2, scale = 2,
spread = {x = 5, y = 5, z = 100}, spread = {x = 50, y = 50, z = 100},
seed = 44444, seed = 44444,
octaves = 2, octaves = 2,
persistence = 0.3, persistence = 0.3,
@@ -303,7 +303,7 @@ local lakes = {
['landscape'] = { ['landscape'] = {
offset = -8, offset = -8,
scale = 2, scale = 2,
spread = {x = 15, y = 15, z = 15}, spread = {x = 150, y = 150, z = 15},
seed = 55555, seed = 55555,
octaves = 2, octaves = 2,
persistence = 0.3, persistence = 0.3,
@@ -333,7 +333,7 @@ local rocky_shores = {
['landscape'] = { ['landscape'] = {
offset = 2, offset = 2,
scale = 4, scale = 4,
spread = {x = 8, y = 8, z = 8}, spread = {x = 80, y = 80, z = 80},
seed = 66666, seed = 66666,
octaves = 3, octaves = 3,
persistence = 0.5, persistence = 0.5,
@@ -391,9 +391,9 @@ local rocky_islands = {
local swamp_land = { local swamp_land = {
['landscape'] = { ['landscape'] = {
offset = 1, offset = 10,
scale = 2, scale = 2,
spread = {x = 12, y = 12, z = 12}, spread = {x = 120, y = 120, z = 120},
seed = 88888, seed = 88888,
octaves = 2, octaves = 2,
persistence = 0.4, persistence = 0.4,
@@ -687,6 +687,7 @@ local function postProcessing(biome, mapGenerator, factors, data, index, x, y, z
end end
end end
--[[
mapGenerator:registerBiome('midgard', 'swamp', { mapGenerator:registerBiome('midgard', 'swamp', {
tempPoint = 0, tempPoint = 0,
humidityPoint = 80, humidityPoint = 80,
@@ -703,6 +704,65 @@ mapGenerator:registerBiome('midgard', 'swamp', {
generateTurf = generateTurf, generateTurf = generateTurf,
generateSoil = generateSoil, generateSoil = generateSoil,
postProcessing = postProcessing postProcessing = postProcessing
})--]]
---@type NoiseParams
local ryeNoiseParams = {
offset = 0,
scale = 10,
spread = {x = 30, y = 30, z = 30},
seed = 88005553535,
octaves = 2,
persistence = 0.4,
lacunarity = 2,
}
local ryeNoise
---@param mapGenerator MapGen
---@param nodeType MapGen.nodeType
---@param area VoxelArea
local function meadowPostProcessing(biome, mapGenerator, factors, data, data2, index, x, y, z, nodeType, area)
if nodeType ~= 'TURF' then
return
end
if ryeNoise == nil then ryeNoise = core.get_value_noise(ryeNoiseParams) end
local value = ryeNoise:get_2d({x=x, y=z}) + math.random(0, 5)
local i = area:index(x,y+1,z)
if value > 8 then
data[i] = id('plants:rye')
data2[i] = 3
elseif value > 5 then
data[i] = id('plants:meadow_grass_1')
data2[i] = 3
elseif value > 3 then
data[i] = id('plants:meadow_grass_2')
data2[i] = 3
end
if ryeNoise:get_2d({x=x, y=z}) - math.random(0, 3) < -8 then
data[index] = mapGenerator.nodeIDs.tauititeLight
end
end
mapGenerator:registerBiome('midgard', 'green_meadow', {
tempPoint = 80,
humidityPoint = 60,
minY = 100,
maxY = -50,
groundNodes = {
soil = 'soils:humus',
turf = 'soils:turf_meadow',
rock = 'rocks:sylite',
bottom = 'soils:humus',
},
soilHeight = 5,
postProcessing = meadowPostProcessing,
--generateRock = generateRock,
--generateTurf = generateTurf,
--generateSoil = generateSoil,
--postProcessing = postProcessing
}) })
return mapGenerator return mapGenerator

View File

@@ -0,0 +1,136 @@
local Item, TileSheet = Smc.requireItem(), Smc.requireTileSheet()
local EquipTileSheet = TileSheet:new('equipment_sheet.png', 16, 16)
Item:new({
settings = {
name = 'linothorax',
inventory_image = EquipTileSheet:t(0, 1),
groups = {
equip_torso = 2
}
}
})
Item:new({
settings = {
name = 'copper_lamellar_armor',
inventory_image = EquipTileSheet:t(1, 1),
groups = {
equip_torso = 2
}
}
})
Item:new({
settings = {
name = 'bronze_breastplate',
inventory_image = EquipTileSheet:t(2, 1),
groups = {
equip_torso = 2
}
}
})
Item:new({
settings = {
name = 'bronze_knee_pads',
inventory_image = EquipTileSheet:t(2, 2),
groups = {
equip_legs = 2
}
}
})
Item:new({
settings = {
name = 'steel_boots',
inventory_image = EquipTileSheet:t(3, 3),
groups = {
equip_feet = 2
}
}
})
Item:new({
settings = {
name = 'steel_helmet',
inventory_image = EquipTileSheet:t(3, 0),
groups = {
equip_head = 2
}
}
})
Item:new({
settings = {
name = 'shapka',
inventory_image = EquipTileSheet:t(6, 0),
groups = {
equip_head = 1
}
}
})
Item:new({
settings = {
name = 'rubashka',
inventory_image = EquipTileSheet:t(6, 1),
groups = {
equip_torso = 1
}
}
})
Item:new({
settings = {
name = 'trusy',
inventory_image = EquipTileSheet:t(6, 2),
groups = {
equip_legs = 1
}
}
})
Item:new({
settings = {
name = 'noski',
inventory_image = EquipTileSheet:t(6, 3),
groups = {
equip_feet = 1
}
}
})
Item:new({
settings = {
name = 'bag',
inventory_image = EquipTileSheet:t(4, 1),
groups = {
bag = 1,
equip_back = 1,
},
_itemstack_inventory_size = 24,
stack_max = 1,
_itemstack_inventory_background = 'equipment_bag_background_24_slots.png',
_itemstack_inventory_disallowed_groups = {'bag'}
}
})
Item:new({
settings = {
name = 'bag_thigh',
inventory_image = EquipTileSheet:t(5, 1),
groups = {
bag = 1,
equip_left_thigh = 1,
equip_right_thigh = 1
},
_itemstack_inventory_size = 16,
stack_max = 1,
_itemstack_inventory_background = 'equipment_bag_background_16_slots.png',
_itemstack_inventory_disallowed_groups = {'bag'}
}
})

View File

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

Binary file not shown.

After

Width:  |  Height:  |  Size: 36 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 48 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 28 KiB

View File

@@ -8,7 +8,7 @@ Plant:new({
}, },
}) })
local ts = TileSheet:new('plants_test_sheet.png', 16, 16) local PlantsTileSheet = TileSheet:new('plants_test_sheet.png', 16, 16)
for i=0, 3 do for i=0, 3 do
@@ -16,8 +16,43 @@ for i=0, 3 do
settings = { settings = {
name = 'plant'..tostring(i), name = 'plant'..tostring(i),
_title = 'Plant', _title = 'Plant',
tiles = { ts:t(i,0) }, tiles = { PlantsTileSheet:t(i,0) },
place_param2 = 3, place_param2 = 3,
}, },
}) })
end end
Plant:new({
settings = {
name = 'rye',
tiles = {PlantsTileSheet:t(0,1)},
place_param2 = 3,
}
})
Plant:new({
settings = {
name = 'rye_small',
tiles = {PlantsTileSheet:t(0,2)},
place_param2 = 3,
}
})
Plant:new({
settings = {
name = 'meadow_grass_1',
tiles = {PlantsTileSheet:t(4,0)},
place_param2 = 3,
}
})
Plant:new({
settings = {
name = 'meadow_grass_2',
tiles = {PlantsTileSheet:t(5,0)},
place_param2 = 3,
}
})

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.2 KiB

After

Width:  |  Height:  |  Size: 36 KiB

View File

@@ -1,66 +1,175 @@
local Node, TileSheet = Smc.requireNode(), Smc.requireTileSheet() local Node, TileSheet = Smc.requireNode(), Smc.requireTileSheet()
local CraftSystem = Smc.requireCraftSystem()
---@type Node.NodeDefinition local InventoryCraftHandler = CraftSystem:getPrimitiveCraftHandler('inside_player_inventory')
local defaultRockDef = {
settings = {
name = '',
tiles = {},
groups = {
dig_immediate = 2,
}
},
}
---@type Node
local defaultRock = Node:getExtended(defaultRockDef)
local rockFactory = defaultRock:getFactory()
---@type TileSheet ---@type TileSheet
local ts = TileSheet:new("rocks_sheet.png", 16, 16) local rocksTileSheet = TileSheet:new("rocks_sheet.png", 16, 16)
local function registerRocksTypes(postfix, x) ---@class RockDef
rockFactory:registerNodesByShortDef({ ---@field rarity Item.Rarity?
{"sylite"..postfix, {ts:t(x, 0)}},
{"sylite_gray"..postfix, {ts:t(x, 1)}}, local function registerSegmentsCrafts(name, craftGroup)
{"sylite_black"..postfix, {ts:t(x, 2)}}, InventoryCraftHandler:registerCraft(name..'_slab', {
{"tauitite_light"..postfix, {ts:t(x, 3)}}, recipe = {name},
{"tauitite_pink"..postfix, {ts:t(x, 4)}}, output = name..'_slab',
{"tauitite"..postfix, {ts:t(x, 5)}}, group = craftGroup
{"falmyte_light"..postfix, {ts:t(x, 6)}}, })
{"falmyte_yellow"..postfix, {ts:t(x, 7)}},
{"falmyte_red"..postfix, {ts:t(x, 8)}}, InventoryCraftHandler:registerCraft(name..'_stair', {
{"falmyte_dark"..postfix, {ts:t(x, 9)}}, recipe = {name},
{"iyellite"..postfix, {ts:t(x, 14)}}, output = name..'_stair',
{"falmyte"..postfix, {ts:t(x, 14)}}, group = craftGroup
{"hapcoryte"..postfix, {ts:t(x, 14)}},
{"burcite"..postfix, {ts:t(x, 14)}},
{"felhor"..postfix, {ts:t(x, 14)}},
{"malachite"..postfix, {ts:t(x, 14)}}
}) })
end end
local function registerPilarStaff(rock, y) ---@param name string
local columnTop = ts:t(9, y) ---@param y number
---@param def RockDef?
---@param staff {block:boolean?,bricks:boolean?,pillar:boolean?}
local function registerRock(name, y, def, staff)
if def == nil then
def = {}
end
rockFactory:registerNodesByShortDef({ local modPrefix = Mod.getInfo().shortName..':'
{rock..'_fluted_column', {columnTop, columnTop, ts:t(6, y)}}, local craftGroup = 'rocks_'..name..'_staff'
{rock..'_ionic_chapiter', {
ts:t(3, y), -- Default rock
columnTop, local defaultRock = Node:getExtended({
ts:t(7, y), settings = {
ts:t(7, y), name = '',
ts:t(8, y), _rarity = def.rarity,
ts:t(8, y)}}, groups = {
rocks = 1,
dig_immediate = 2,
}
}
})
-- Solid rock
defaultRock:new({
settings = {
name = name,
tiles = {{ name = rocksTileSheet:t(0, y), align_style='world'}},
groups = {
segments = 3
}
}
})
registerSegmentsCrafts(modPrefix..name, craftGroup)
-- Chipped rock
local chippedRockName = name..'_chipped'
defaultRock:new({
settings = {
name = chippedRockName,
tiles = {{ name = rocksTileSheet:t(1, y), align_style='world'}},
groups = {
segments = 3
}
}
})
registerSegmentsCrafts(modPrefix..chippedRockName, craftGroup)
if staff.block == true then
-- Solid rock block
local blockName = name..'_block'
defaultRock:new({
settings = {
name = name..'_block',
tiles = {{ name = rocksTileSheet:t(3, y), align_style='world'}},
groups = {
segments = 3
}
}
})
registerSegmentsCrafts(modPrefix..blockName, craftGroup)
InventoryCraftHandler:registerCraft(blockName, {
recipe = {modPrefix..name},
output = modPrefix..blockName,
group = craftGroup,
}) })
end end
registerPilarStaff('sylite', 0) if staff.bricks == true then
registerPilarStaff('sylite_gray', 1) -- Solid rock bricks
registerPilarStaff('sylite_black', 2) local bricksName = name..'_bricks'
defaultRock:new({
settings = {
name = bricksName,
tiles = {{ name = rocksTileSheet:t(4, y), align_style='world'}},
groups = {
segments = 3
}
}
})
registerRocksTypes('', 0) registerSegmentsCrafts(modPrefix..bricksName, craftGroup)
registerRocksTypes('_chipped', 1)
registerRocksTypes('_block', 3) InventoryCraftHandler:registerCraft(bricksName, {
registerRocksTypes('_bricks', 4) recipe = {modPrefix..name},
registerRocksTypes('_bricks_2', 5) output = modPrefix..bricksName,
group = craftGroup,
})
end
if staff.pillar == true then
local columnTopTexture = rocksTileSheet:t(9, y)
-- Fluted column
defaultRock:new({
settings = {
name = name..'_fluted_column',
tiles = {
columnTopTexture,
columnTopTexture,
rocksTileSheet:t(6, y)
},
}
})
-- Ionic chapiter
defaultRock:new({
settings = {
name = name..'_ionic_chapiter',
tiles = {
rocksTileSheet:t(3, y),
columnTopTexture,
rocksTileSheet:t(7, y),
rocksTileSheet:t(7, y),
rocksTileSheet:t(8, y),
rocksTileSheet:t(8, y)
}
}
})
end
end
-- Sylite group
registerRock('sylite', 0, {}, {block = true, bricks = true, pillar = true})
registerRock('sylite_gray', 1, {}, {block = true, bricks = true, pillar = true})
registerRock('sylite_black', 2, {}, {block = true, bricks = true, pillar = true})
-- Tauitite group
registerRock('tauitite_light', 3, {}, {block = true, bricks = true})
registerRock('tauitite_pink', 4, {}, {block = true, bricks = true})
registerRock('tauitite_black', 5, {}, {block = true, bricks = true})
-- Falmyte group
registerRock('falmyte_light', 6, {}, {block = true, bricks = true})
registerRock('falmyte_yellow', 7, {}, {block = true, bricks = true})
registerRock('falmyte_red', 8, {}, {block = true, bricks = true})
registerRock('falmyte_dark', 9, {}, {block = true, bricks = true})
-- TODO:
-- iyellite
-- falmyte
-- hapcoryte
-- burcite
-- felhor
-- malachite

Binary file not shown.

Before

Width:  |  Height:  |  Size: 151 KiB

After

Width:  |  Height:  |  Size: 151 KiB

View File

@@ -1,27 +1,77 @@
local Node, TileSheet = Smc.requireNode(), Smc.requireTileSheet() local Node, TileSheet = Smc.requireNode(), Smc.requireTileSheet()
---@type Node.NodeDefinition ---@type TileSheet
local defaultSoilDef = { local soilTileSheet = TileSheet:new("soils_sheet.png", 16, 16)
---@class SoilDef
---@field rarity Item.Rarity?
---@field maxFertility integer
---@param name string
---@param x number
---@param def SoilDef
---@param turfs table<string, integer>?
local function registerSoil(name, x, def, turfs)
local defaultSoil = Node:getExtended({
settings = { settings = {
name = "", name = '',
_description = "A soil",
tiles = {},
groups = { groups = {
dig_immediate = 2, dig_immediate = 2,
soil = 1, soil = 1,
soil_fertiliry = 100, -- Soil fertility for agriculture soil_fertility = def.maxFertility,
} },
},
})
local soilTexture = soilTileSheet:t(x, 0)
defaultSoil:new({
settings = {
name = name,
tiles = {soilTexture}
},
})
defaultSoil:new({
settings = {
name = name..'_plowed',
tiles = {
soilTileSheet:t(x, 1),
soilTexture,
},
drawtype = 'nodebox',
node_box = {
type = 'fixed',
fixed = {
{-0.5, -0.5, -0.5, 0.5, 0.5625, 0.5},
},
},
selection_box = {
type = 'fixed',
fixed = {
{-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
}, },
} }
},
})
---@type Node if turfs ~= nil then
local defaultSoil = Node:getExtended(defaultSoilDef) for turfName, turfX in pairs(turfs) do
defaultSoil:new({
local soilFactory = defaultSoil:getFactory() settings = {
name = turfName,
---@type TileSheet tiles = {
local ts = TileSheet:new("soils_sheet.png", 16, 16) soilTileSheet:t(turfX,2),
soilTexture,
soilTexture..'^'..soilTileSheet:t(turfX,3)
},
},
})
end
end
end
--[[
local clayTiles = { local clayTiles = {
ts:t(0,0) ts:t(0,0)
} }
@@ -237,15 +287,9 @@ soilFactory:registerItems({
}, },
}, },
}) })--]]
---@type TileSheet ---@type TileSheet
local tsT = TileSheet:new("soils_turfs_sheet.png", 16, 16) local tsT = TileSheet:new("soils_turfs_sheet.png", 16, 16)
defaultSoil:new({ registerSoil('humus', 0, {maxFertility = 100, rarity = 'uncommon'}, {turf_meadow=0})
settings = {
name = 'turf_swamp',
tiles = {tsT:t(0,0), ts:t(6, 0), ts:t(6,0)..'^'..tsT:t(0,1)},
_rarity = 'unique'
}
})

Binary file not shown.

Before

Width:  |  Height:  |  Size: 7.2 KiB

After

Width:  |  Height:  |  Size: 35 KiB

View File

@@ -96,4 +96,3 @@ storageFactory:registerItems({
}, },
}, },
}) })

View File

@@ -1,4 +1,8 @@
local Node, TileSheet = Smc.requireNode(), Smc.requireTileSheet() local Item, Node, TileSheet = Smc.requireItem(), Smc.requireNode(), Smc.requireTileSheet()
local CraftSystem = Smc.requireCraftSystem()
local InventoryCraftHandler = CraftSystem:getPrimitiveCraftHandler('inside_player_inventory')
---@type Node.NodeDefinition ---@type Node.NodeDefinition
local defaultLogDef = { local defaultLogDef = {
@@ -6,7 +10,7 @@ local defaultLogDef = {
name = '', name = '',
tiles = {}, tiles = {},
groups = { groups = {
dig_immediate = 2, dig_immediate = 3,
wood = 1 wood = 1
}, },
} }
@@ -18,7 +22,7 @@ local defaultPlanksDef = {
name = '', name = '',
tiles = {}, tiles = {},
groups = { groups = {
dig_immediate = 2, dig_immediate = 3,
}, },
paramtype2 = 'facedir', paramtype2 = 'facedir',
}, },
@@ -31,7 +35,7 @@ local defaultLeafsDef = {
name = '', name = '',
tiles = {}, tiles = {},
groups = { groups = {
dig_immediate = 2, dig_immediate = 3,
}, },
--paramtype = 'light', --paramtype = 'light',
paramtype2 = 'facedir', paramtype2 = 'facedir',
@@ -40,26 +44,33 @@ local defaultLeafsDef = {
}, },
} }
---@type Item.ItemDefinition
local defaultStickDef = {
settings = {
name = '',
},
}
local defaultLog = Node:getExtended(defaultLogDef) local defaultLog = Node:getExtended(defaultLogDef)
local defaultPlanks = Node:getExtended(defaultPlanksDef) local defaultPlanks = Node:getExtended(defaultPlanksDef)
local defaultLeafs = Node:getExtended(defaultLeafsDef) local defaultLeafs = Node:getExtended(defaultLeafsDef)
local defaultStick = Item:getExtended(defaultStickDef)
local logFactory = defaultLog:getFactory() local logFactory = defaultLog:getFactory()
local planksFactory = defaultPlanks:getFactory() local planksFactory = defaultPlanks:getFactory()
---@type TileSheet ---@type TileSheet
local logTileSheet = TileSheet:new('wood_sheet.png', 16, 16) local woodTileSheet = TileSheet:new('wood_sheet.png', 16, 16)
local function getLogTiles(x, y) local function getLogTiles(x, y)
return { return {
logTileSheet:t(x, y), woodTileSheet:t(x, y),
logTileSheet:t(x, y), woodTileSheet:t(x, y),
logTileSheet:t(x, y+1), woodTileSheet:t(x, y+1),
} }
end end
local t = logTileSheet local t = woodTileSheet
---@class WoodDef ---@class WoodDef
---@field rarity Item.Rarity? ---@field rarity Item.Rarity?
@@ -78,6 +89,7 @@ local function registerWood(name, x, def)
tiles = getLogTiles(x, 2), tiles = getLogTiles(x, 2),
paramtype2 = 'facedir', paramtype2 = 'facedir',
_rarity = def.rarity, _rarity = def.rarity,
groups = {log = 1}
}, },
callbacks = { callbacks = {
on_place = core.rotate_node on_place = core.rotate_node
@@ -99,21 +111,21 @@ local function registerWood(name, x, def)
defaultLog:new({ defaultLog:new({
settings = { settings = {
name = name..'_timber', name = name..'_timber',
tiles = {logTileSheet:t(x, 8), logTileSheet:t(x, 8), tiles = {
logTileSheet:t(x, 7), logTileSheet:t(x, 7), woodTileSheet:t(x, 8)..'^[transformR90', woodTileSheet:t(x, 8)..'^[transformR90',
logTileSheet:t(x, 8), logTileSheet:t(x, 8),}, woodTileSheet:t(x, 8), woodTileSheet:t(x, 8),
woodTileSheet:t(x, 7), woodTileSheet:t(x, 7)
},
paramtype2 = 'facedir', paramtype2 = 'facedir',
_rarity = def.rarity, _rarity = def.rarity,
groups = {segments = 1}
}, },
callbacks = {
on_place = core.rotate_node
}
}) })
defaultLog:new({ defaultLog:new({
settings = { settings = {
name = name..'_trunk', name = name..'_trunk_6_sides',
tiles = {logTileSheet:t(x, 3)}, tiles = {woodTileSheet:t(x, 3)},
inventory_overlay = 'wood_trunk_overlay.png', inventory_overlay = 'wood_trunk_overlay.png',
drop = 'wood:'..name..'_log', drop = 'wood:'..name..'_log',
paramtype2 = 'facedir', paramtype2 = 'facedir',
@@ -126,7 +138,7 @@ local function registerWood(name, x, def)
defaultLog:new({ defaultLog:new({
settings = { settings = {
name = name..'_trunk_vertical', name = name..'_trunk_4_sides',
tiles = getLogTiles(x, 2), tiles = getLogTiles(x, 2),
inventory_overlay = 'wood_trunk_overlay.png', inventory_overlay = 'wood_trunk_overlay.png',
drop = 'wood:'..name..'_log', drop = 'wood:'..name..'_log',
@@ -138,13 +150,11 @@ local function registerWood(name, x, def)
} }
}) })
defaultLog:new({ local defaultBranch6Sides = defaultLog:getExtended({
settings = { settings = {
drawtype = 'nodebox', drawtype = 'nodebox',
name = name..'_trunk_branch', name = '',
tiles = {logTileSheet:t(x, 3)}, tiles = {woodTileSheet:t(x, 3)},
inventory_overlay = 'wood_trunk_overlay.png',
drop = 'wood:'..name..'_log',
paramtype = 'light', paramtype = 'light',
node_box = { node_box = {
type = 'connected', type = 'connected',
@@ -161,12 +171,25 @@ local function registerWood(name, x, def)
}, },
}) })
defaultLog:new({ local node = defaultBranch6Sides:new({
settings = {
name = name..'_log_branch_6_sides',
}
})
defaultBranch6Sides:new({
settings = {
name = name..'_trunk_branch_6_sides',
inventory_overlay = 'wood_trunk_overlay.png',
drop = name..'_log_branch_6_sides',
}
})
local defaultBranch4Sides = defaultLog:getExtended({
settings = { settings = {
drawtype = 'nodebox', drawtype = 'nodebox',
name = name..'_trunk_branch_vertical', name = '',
tiles = getLogTiles(x, 2), tiles = getLogTiles(x, 2),
inventory_overlay = 'wood_trunk_overlay.png',
drop = 'wood:'..name..'_log', drop = 'wood:'..name..'_log',
paramtype = 'light', paramtype = 'light',
node_box = { node_box = {
@@ -180,21 +203,101 @@ local function registerWood(name, x, def)
}, },
}) })
defaultBranch4Sides:new({
settings = {
name = name..'_log_branch_4_sides',
}
})
defaultBranch4Sides:new({
settings = {
name = name..'_trunk_branch_4_sides',
inventory_overlay = 'wood_trunk_overlay.png',
drop = name..'_log_branch_4_sides',
}
})
defaultPlanks:new({ defaultPlanks:new({
settings = { settings = {
name = name..'_planks', name = name..'_planks',
tiles = { logTileSheet:t(x, 6) }, tiles = { woodTileSheet:t(x, 6) },
_rarity = def.rarity, _rarity = def.rarity,
groups = {segments = 3},
}, },
}) })
defaultLeafs:new({ defaultLeafs:new({
settings = { settings = {
name = name..'_leafs', name = name..'_leafs',
tiles = { logTileSheet:t(x, 1) }, tiles = { woodTileSheet:t(x, 1) },
_rarity = def.rarity, _rarity = def.rarity,
}, },
}) })
defaultStick:new({
settings = {
name = name..'_stick',
inventory_image = woodTileSheet:t(x, 9)
}
})
defaultStick:new({
settings = {
name = name..'_plank',
inventory_image = woodTileSheet:t(x, 10)
}
})
defaultStick:new({
settings = {
name = name..'_bar',
inventory_image = woodTileSheet:t(x, 11)
}
})
InventoryCraftHandler:registerCraft('wood:'..name..'_planks', {
recipe = {
'wood:'..name..'_log'
},
output = 'wood:'..name..'_planks 4',
group = 'wood:planks_blocks',
})
InventoryCraftHandler:registerCraft('wood:'..name..'_log_stripped', {
recipe = {
'wood:'..name..'_log'
},
output = 'wood:'..name..'_log_stripped',
group = 'wood:logs_stripped',
})
InventoryCraftHandler:registerCraft('wood:'..name..'_bar', {
recipe = {
'wood:'..name..'_log'
},
output = 'wood:'..name..'_bar 4',
group = 'wood:bars',
})
InventoryCraftHandler:registerCraft('wood:'..name..'_plank', {
recipe = {
'wood:'..name..'_bar'
},
output = 'wood:'..name..'_plank 2',
group = 'wood:planks',
})
InventoryCraftHandler:registerCraft('wood:'..name..'_stick', {
recipe = {
'wood:'..name..'_bar'
},
altRecipes = {
{ 'wood:'..name..'_plank 2' },
{ 'wood:'..name..'_log'}
},
output = 'wood:'..name..'_stick 4',
group = 'wood:sticks',
})
end end
registerWood('marentine', 0) registerWood('marentine', 0)

Binary file not shown.

Before

Width:  |  Height:  |  Size: 16 KiB

After

Width:  |  Height:  |  Size: 133 KiB

View File

@@ -21,7 +21,9 @@ end
---@param ... any ---@param ... any
function Events.call(eventName, ...) function Events.call(eventName, ...)
local callbacks = registeredEvents[eventName] local callbacks = registeredEvents[eventName]
assert(callbacks ~= nil, ('Event %s does not exist'):format(eventName)) if callbacks == nil then
return
end
for _, func in ipairs(callbacks) do for _, func in ipairs(callbacks) do
func(eventName, ...) func(eventName, ...)

View File

@@ -1,56 +0,0 @@
# Game fonts
Description of the fonts that are pre-installed for the project and passed on to all clients for displaying text.
## Philosopher
Download site: https://fonts-online.ru/fonts/doloto.
Used in:
- `regular.ttf`
- `mono.ttf`
### Info
Designed by **Jovanny Lemonad**.
### Licence
Copyright 2011 The Philosopher Project Authors (https://github.com/alexeiva/philosopher)
This Font Software is licensed under the SIL Open Font License, Version 1.1 . This license is copied below, and is also available with a FAQ at: https://openfontlicense.org
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
#### PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others.
The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives.
#### DEFINITIONS
"Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation.
"Reserved Font Name" refers to any names specified as such after the copyright statement(s).
"Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s).
"Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment.
"Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software.
#### PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions:
- Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself.
- Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user.
- No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users.
- The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission.
- The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software.
#### TERMINATION
This license becomes null and void if any of the above conditions are not met.
#### DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.
---

Binary file not shown.

View File

@@ -3,9 +3,10 @@ Smc = {}
local modInfo = Mod.getInfo('smc__system__helper_lib') local modInfo = Mod.getInfo('smc__system__helper_lib')
local require = modInfo.require local require = modInfo.require
require('Lib.activeFormspecs')
require('Lib.globalStep') require('Lib.globalStep')
require('Lib.color') require('Lib.color')
require('Lib.immersiveCraftData') require('Lib.itemStackInventory')
require('Lib.getObjectByGUID') require('Lib.getObjectByGUID')
require('Lib.receiveFields') require('Lib.receiveFields')
require('Lib.registeredItems') require('Lib.registeredItems')

View File

@@ -0,0 +1,19 @@
---@type table<string, string>
local activeFormspecsList = {}
---@param playerName string
---@param formName string?
function Smc.setActiveFormspec(playerName, formName)
activeFormspecsList[playerName] = formName
end
---@param playerName string
---@return string?
function Smc.getActiveFormspec(playerName)
return activeFormspecsList[playerName]
end
---@param playerName string
function Smc.clearActiveFormspec(playerName)
Smc.setActiveFormspec(playerName, nil)
end

View File

@@ -41,7 +41,7 @@ local callsForEachPlayer = {}
---@param timeDelay number ---@param timeDelay number
---@param callbackFunc fun(deltaTime:number, player:Player) ---@param callbackFunc fun(deltaTime:number, player:Player)
function Smc.registerGlobalStepForEachPlayer(timeDelay, callbackFunc) function Smc.registerGlobalStepForEachPlayer(timeDelay, callbackFunc)
table.insert(callsWithDelay, { table.insert(callsForEachPlayer, {
timeDelay = timeDelay, timeDelay = timeDelay,
callbackFunc = callbackFunc, callbackFunc = callbackFunc,
timer = 0.0, timer = 0.0,

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