The Detroit Post
Friday, 15 October, 2021

Is Rust Procedurally Generated

author
Daniel Brown
• Monday, 26 October, 2020
• 11 min read

An example of a Procedural Map, randomly generated. The server owners can also select specific options that alter the world generation such as the size of the world.

rust launch site map wiki monument wikia rockets settings graphic loot play community island
(Source: rust.wikia.com)

Contents

Everything is randomized in the initial world generation, including rad town placement, roads, rivers, monuments, and biome placement. I'm wondering if this game has a procedural engine, like Minecraft for the terrain.

This is the first in a series of tutorials on procedural generation with Rust. Procedural generation is a technique which allows content to be created programmatically, rather than everything in a game being specifically placed by a designer.

This tutorial will show how to create a tilemap-based level with rooms connected by straight corridors, using Rust. We'll also cover how to use seeds to reproduce specific layouts and serialize the output into JSON.

Once created, change into the new folder and run the project to check everything's ok: The first step is to create the tile map which will keep track of empty space and rooms in our level.

This sets the width and height properties of the struct, and creates a vector for each row: Each row is set to contain width number of elements, all set to 0 ; all these rows are then added to the board vector and added to the Level struct.

generated ark seeds map procedural procedurally maps arks playark
(Source: mapingonlinesource.blogspot.com)

In Rust, vectors are growable arrays which adds a bit of overhead since they need to be able to resize. Since we're dynamically creating the board size from the width and height, we'll need to use a vector instead.

The # lets us print out the contents of our level, but this is a bit of a mess at the moment with a single line of zeroes. To allow custom formatting, we need to derive the Display trait on Level, so we can print out a nice map.

In the FMT function, we're looping through each entry in the board and printing out the {:?} Debug string, since each entry is an integer, along with a space, and for each row array we add a line break.

When using procedural generation, it's nice to have reproducible output so you can re-use levels you like. The rand crate provides this functionality, so we all we need to do is change where the type of random number generator, and make sure we use the same one throughout the code.

I've found the SeedableRng provided by the rand crate to be a bit picky in what it accepts as a seed, so we'll add a couple of crates to help create a seed in the correct format. SeedableRng requires an array of 32 u8 items, so these crates will help us turn a string of text into the appropriate format.

rust plant power wiki wikia powered play overview
(Source: rust.wikia.com)

We can convert the level into JSON so it can be exported and used in a game using serve. Serde is a serialization and serialization crate which contains the core functions, while serde_json is specifically for converting JSON data.

Serde_derive is an incredibly useful crate which allows most Rust data structures to be automatically converted by deriving the Serialize or Deserialize traits. Then we need to derive Serialize on our structs, so we can convert the level into JSON.

If you leave one of those out, you'll see an error message complaining that the Serialize trait is not satisfied, so you should be able to track down everything you need to mark as serializable. Primitive types, like i32, are already implemented in serve, so we don't need to do anything extra with the level's width or height properties.

In level.rs, remove the Serialize derive tag from Tile, then add a new implementation block: The code in the function is very similar to Tile's Display implementation: we check the type of the Tile ENIM, then return a serialized i32, either zero or one, depending on the ENIM value.

Run the project again, and this time the serialized output should look much nicer! Instead, let's allow a string to be passed to the program at runtime, so we can create new levels without having to re-compile the project every time.

seeds map flat ark procedurally land generated rock maps shining software forums many
(Source: mapscatalogonline.blogspot.com)

Hash is now replaced with a match : std::env::arms::nth(1) tries to read the second argument to the program and if it exists, passes it to the create_hash function. Clap is a handy crate which handles reading and parsing arguments to your program.

If you want to pass text as before, then use the -t flag: cargo run -- -t manuelneuersweeperkeeper. With Clap, you could also set up other parameters to be read in, such as the board size or number of rooms.

There are a few things you could play around with, such as the size or number of rooms in a level, or whether to use certain types of corridors, or even unit tests since Rust makes that really easy!. In the next part, we'll cover using the JSON output to draw the maps, and also look at different algorithms to place and join rooms.

The theme of Procedural Generation is extensive, so we’ll only touch the tip of the iceberg. We’ll focus only on terrain generation for 2D and 3D games.

Procedural generation (or PG) is the ability to create “partially” random content by the computer. This means that with little to no input, you can program infinite content for your players.

rust tank sphere monuments oil wikia wiki
(Source: rust.wikia.com)

And if well done, your players are able to enjoy your game for years to come, while experiencing endless challenges and experiences. I know your mind must be exploding with ideas and exciting new games you want to make.

PG is not for you, for example, when your focus is the narrative, or when you want your player to follow a certain story path. Even though games like Minecraft have thousands of hours of replayability, truth is, you will at some point download mods.

Or maybe even grab some special requirement to unlock a hidden quest? Just because it’s PG, doesn’t mean you don’t need to design it.

As mentioned before, this text will only cover terrain generation. To add PG to your game, there are several things you should consider, because you can’t just generate meadows and hills.

You need biomes, rivers, forests, deserts, stuff like that. And that is achieved with multiple PG layers (or passes, we’ll get there).

rust road wikia
(Source: rust.wikia.com)

The first thing you have to understand is: there is no true randomness for computers. Since computers only work with certainties, randomness is not an ability they have.

The final result would be 10 and that will be the input to the noise generation. Depending on the noise generator, the algorithm varies, but in this case, we’ll talk about Berlin.

For the next step, we grab 1 row of the 2d noise from earlier. Make sure you understand that it is only 1 row, expanded vertically so you can see it better.

These rules were used to create this measly 2d map, and it’s very ugly, but you get the point. The next step could be to generate, for example, trees and grass.

For 2d top-down games, all we need is to simply generate noise, build the map based on altitude, apply different tiles to different values and voilà, it’s done. As for the features of the over world, we need as many passes you can give it.

astra terra game simulation rust yet opengl
(Source: arewegameyet.com)

Now you only need your imagination and implement deserts, swamps and what not :). You don’t need to do it this way, but I believe this is the easiest way to introduce people to PG.

The only difference is that Minecraft is “infinite”, and so, instead of generating the whole world as we did just now, they split it in chunks of 16×16x256 tiles. Split A in chunks of 16×16, select the values for your current chunk Split B in chunks of 16×16, select the values for your current chunk For each of the values in A (horizontal and vertical, or X and Y) : Find the altitude, using the previous formula (maximum x value + baseline), or your own Determine the tile type based on the current biome of B, (if you are generating the tile x = 10, y = 15 of the noise A, you will read the type of biome from B from the tile x = 10, y = 15) After the tile is filled with either grass, sand or whatever, we need to fill all the way down to Y = 0, using the following rules: If Y = 0, we create bedrock If Y < 6, there is a 70% chance of putting bedrock, and 30% of stone If the distance to top tile is > 10, put stone, otherwise, put dirt.

After the chunk is generated, we can apply some cave systems. Now that we have a chunk with the over world and a small cave system, it’s up to the features' generation, such as trees, cacti and so on… Personally I used Berlin noise to create clusters of features, such as bushes and trees, which give a nice smooth transition from smaller trees on the outskirts to bigger trees deep in the forest.

For terr aria and other finite games, it’s a single map with proper borders, so we just generate the world and store it in our disk. Ah yes, No Man’s Sky… Their take on this is a little more ingenious, but not new to the programming world.

Do you remember how we generated the world based on the different kinds of noise? Which means that the world is generated, but never stored in any disk.

rust shotgun
(Source: mmos.com)

And when it’s no longer needed, the world is unloaded from memory. So for example, if player A enters a new world, mines some rocks and builds a base, then logs out, the server stores the broken rocks, the base and the spaceship in the server disk, but not the entire world (as we do in finite world games).

But then, it has changes that player A did to it, which in turn, get applied to the world, the broken rocks, the base and the spaceship. Then, when player B is within reach, he visually sees these changes in his computer.

And even though it can give you endless hours of fun, it requires a lot of polish to keep the players engaged with new random stuff, and not just different flavors of the same things. And remember: The longer you tune your system, the more unique it will be.

In case you just want to see something cool regarding terrain: Your support will help me cover site expenses and pay writers to create new blog content.

Other Articles You Might Be Interested In

01: Unc Charlotte Center For Real Estate
02: Unc Charlotte Real Estate
03: Unc Charlotte Real Estate Program
04: Unemployment For Real Estate Agents Washington State
05: Unemployment Insurance
06: Unemployment Insurance When Self Employed
07: Ung Real Estate Long Beach
08: Unico Real Estate Seattle
09: Union City Oklahoma Real Estate
10: Union Hill Real Estate Kansas City
Sources
1 www.realtor.com - https://www.realtor.com/realestateandhomes-search/Union-Hill_Kansas-City_MO
2 www.redfin.com - https://www.redfin.com/neighborhood/92559/MO/Kansas-City/Union-Hill
3 www.century21.com - https://www.century21.com/real-estate/union-hill-kansas-city-mo/LR64108UNIONHILL/
4 www.zillow.com - https://www.zillow.com/union-hill-kansas-city-mo/rentals/
5 www.point2homes.com - https://www.point2homes.com/US/Real-Estate-Listings/MO/Kansas-City/Crown-Center-Union-Hill.html
6 www.zillow.com - https://www.zillow.com/kansas-city-mo/union-hill_att/
7 unionhill.com - https://unionhill.com/
8 lorettoproperties.com - http://lorettoproperties.com/
9 www.judyq.com - http://www.judyq.com/
10 unitedagencyks.com - https://unitedagencyks.com/real-estate/listings/
11 www.tonyskansascity.com - https://www.tonyskansascity.com/