mirror of
https://github.com/ParadiseSS13/Paradise.git
synced 2026-01-02 05:32:16 +00:00
0f7b09ef07
This commit adds a Procedural map generating system for code and admins to use ingame. The system is modular, which means that it is fairly easy to make new generating systems. Currently, only the 'nature' unsimulated system is implemented, as a testing verb for admins to use. Admins can define the starting XYZ and ending XYZ of the generated system. Players - This means you may see content that is truely random, in the future. Coders - This system allows you to randomize map elements. Writing new modules is documented at code/modules/procedural-mapping/mapGeneratorReadme.dm Detailed information about how the system works, and how it can be integrated is also avalible there. Admins - This system will allow you to, at the touch of a button, create very complex structures and turfs that would otherwise require being spawned in manually, one by one. The nature button is a fairly good example of this, with it's randomized grass textures, randomly placed trees, and randomly placed rocks. This would normally take a good 5 minutes to do, spawning the trees and rocks and turfs, but it takes about 20 seconds to enter the coordinates and have it be completely random.
130 lines
5.4 KiB
Plaintext
130 lines
5.4 KiB
Plaintext
|
|
/*
|
|
by RemieRichards
|
|
|
|
//////////////////////////////
|
|
// CODER INFORMATIVE README //
|
|
//////////////////////////////
|
|
(See below for Mapper Friendly Readme)
|
|
|
|
mapGenerator:
|
|
Desc: a mapGenerator is a master datum that collects
|
|
and syncs all mapGeneratorModules in it's modules list
|
|
|
|
defineRegion(var/list/startList, var/list/endList)
|
|
Example: defineRegion(locate(1,1,1),locate(5,5,5))
|
|
Desc: Sets the bounds of the mapGenerator's "map"
|
|
|
|
checkRegion(var/turf/Start, var/turf/End)
|
|
Example: checkRegion(locate(1,1,1), locate(5,5,5))
|
|
Desc: Checks if a rectangle between Start's coords and End's coords is valid
|
|
Existing Calls: mapGenerator/defineRegion()
|
|
|
|
generate()
|
|
Example: generate()
|
|
Desc: Orders all mapGeneratorModules in the modules list to generate()
|
|
|
|
generateOneTurf(var/turf/T)
|
|
Example: generateOneTurf(locate(1,1,1))
|
|
Desc: Orders all mapGeneratorModules in the modules list to place(T) on this turf
|
|
|
|
initialiseModules()
|
|
Example: initialiseModules()
|
|
Desc: Replaces all typepaths in the modules list with actual /datum/mapGenerator/Module types
|
|
Existing Calls: mapGenerator/New()
|
|
|
|
syncModules()
|
|
Example: syncModules()
|
|
Desc: Sets the Mother variable on all mapGeneratorModules in the modules list to this mapGenerator
|
|
Existing Calls: initialiseModules(),generate(),generateOneTurf()
|
|
|
|
|
|
mapGeneratorModule
|
|
Desc: a mapGeneratorModule has spawnableAtoms and spawnableTurfs lists
|
|
which it will generate on turfs in it's mother's map based on cluster variables
|
|
|
|
sync(var/datum/mapGenerator/mum)
|
|
Example: sync(a_mapGenerator_as_a_variable)
|
|
Desc: Sets the Mother variable to the mum argument
|
|
Existing Calls: mapGenerator/syncModules()
|
|
|
|
generate()
|
|
Example: generate()
|
|
Desc: Calls place(T) on all turfs in it's mother's map
|
|
Existing Calls: mapGenerator/generate()
|
|
|
|
place(var/turf/T)
|
|
Example: place(locate(1,1,1))
|
|
Desc: Run this mapGeneratorModule's effects on this turf (Spawning atoms, Changing turfs)
|
|
Existing Calls: mapGenerator/generate(), mapGenerator/generateOneTurf()
|
|
|
|
checkPlaceAtom(var/turf/T)
|
|
Example: checkPlace(locate(1,1,1))
|
|
Desc: Checks if the turf is valid for placing atoms
|
|
Existing Calls: place()
|
|
|
|
|
|
|
|
////////////////////////////
|
|
// MAPPER FRIENDLY README //
|
|
////////////////////////////
|
|
|
|
Simple Workflow:
|
|
|
|
1. Define a/some mapGeneratorModule(s) to your liking, choosing atoms and turfs to spawn
|
|
#Note: I chose to split Turfs and Atoms off into seperate modules, but this is NOT required.
|
|
#Note: A mapGeneratorModule may have turfs AND atoms, so long as each is in it's appropriate list
|
|
|
|
2. Define a mapGenerator type who's modules list contains the typepath(s) of all the module(s) you wish to use
|
|
#Note: The order of the typepaths in the modules list is the order they will happen in, this is important for clusterCheckFlags.
|
|
|
|
3. Take notes of the Bottom Left and Top Right turfs of your rectangular "map"'s coordinates
|
|
#Note: X,Y AND Z, Yes you can created 3D "maps" by having differing Z coords
|
|
|
|
4. Create the mapGenerator type you created
|
|
|
|
5. Call yourMapGeneratorType.defineRegion(locate(X,Y,Z), locate(X,Y,Z))
|
|
#Note: The above X/Y/Zs are the coordinates of the start and end turfs, the locate() simply finds the turf for the code
|
|
|
|
6. Call yourMapGeneratorType.generate(), this will cause all the modules in the generator to build within the map bounds
|
|
|
|
Option Suggestions:
|
|
|
|
* Have seperate modules for Turfs and Atoms, this is not enforced, but it is how I have structured my nature example.
|
|
* If your map doesn't look quite to your liking, simply jiggle with the variables on your modules and the type probabilities
|
|
* You can mix and map premade areas with the procedural generation, for example mapping an entire flat land but having code generate just the grass tufts
|
|
|
|
|
|
Using the Modules list
|
|
|
|
Simply think of it like each module is a layer in a graphics editing program!
|
|
To help you do this templates such as /mapGeneratorModule/bottomLayer have been provided with appropriate default settings.
|
|
These are located near the bottom of mapGeneratorModule.dm
|
|
you would order your list left to right, top to bottom, e.g:
|
|
modules = list(bottomLayer,nextLayer,nextNextLayer) etc.
|
|
|
|
|
|
Variable Breakdown (For Mappers):
|
|
|
|
mapGenerator
|
|
map - INTERNAL, do not touch
|
|
bottomLeft - INTERNAL, do not touch
|
|
topRight - INTERNAL, do not touch
|
|
modules - A list of typepaths of mapGeneratorModules
|
|
|
|
mapGeneratorModule
|
|
mother - INTERNAL, do not touch
|
|
spawnableAtoms - A list of typepaths and their probability to spawn, eg: spawnableAtoms = list(/obj/structure/flora/tree/pine = 30)
|
|
spawnableTurfs - A list of typepaths and their probability to spawn, eg: spawnableTurfs = list(/turf/unsimulated/floor/grass = 100)
|
|
clusterMax - The max range to check for something being "too close" for this atom/turf to spawn, the true value is random between clusterMin and clusterMax
|
|
clusterMin - The min range to check for something being "too close" for this atom/turf to spawn, the true value is random between clusterMin and clusterMax
|
|
clusterCheckFlags - A Bitfield that controls how the cluster checks work.
|
|
|
|
clusterCheckFlags flags:
|
|
CLUSTER_CHECK_NONE 0 //No checks are done, cluster as much as possible
|
|
CLUSTER_CHECK_ATOMS 2 //Don't let atoms cluster, based on clusterMin and clusterMax as guides
|
|
CLUSTER_CHECK_TURFS 4 //Don't let turfs cluster, based on clusterMin and clusterMax as guides
|
|
CLUSTER_CHECK_ALL 6 //Don't let anything cluster, based on clusterMind and clusterMax as guides
|
|
|
|
|
|
*/ |