# Random terrain

Procedurally generated terrain, often refered to as randomly generated terrain, is a terrain that is created via script rather than by hand. This gives the ability to have a game that is a completely different experience every time while using a lot less work.

## The basic algorithm

The most basic algorithm is to place bricks of random size in random positions across your baseplate. To do this we will set up a simple for loop that instances a new, anchored part every time.

```
for i = 1, 200 do
local part = Instance.new("Part", workspace) -- Creates a Part and makes it a descendant of Workspace
part.Anchored = true -- Prevents the part from moving.
```

Next we will set the size to a random amount. For this we will use the function *math.random()*

```
part.Size = Vector3.new(math.random(1, 20), math.random(1, 20), math.random(1, 20))
```

This will set the Size to a random amount between 1 and 20 for the X,Y and Z size. Now for the last step of our algorithm, use CFrame to place the brick in a random spot. We will easily just place the X and Z axis using *math.random()* yet for the Y axis, we'll have to do something special. Being that we want all the bricks to stay on the ground, we want their base to be at 0. Now since the Position of a brick in roblox uses the center of the brick, we'll have to divide the Y size in half, so that it sits just perfectly on 0. So it would be :

```
part.CFrame = CFrame.new(math.random(-100, 100), part.Size.Y/2, math.random(-100, 100))
end -- for the for loop
```

## Heightmap

A heightmap shows different elevations across the whole map. For making a basic one, we will just have a script in the base of our map. This way we can specify the size of the map we want and where it will be positioned, easily. To start, we will define three variables.

```
local size = Vector3.new(10, -- Number of tiles along the width
10, -- Number of steps of heightmap
10) -- Number of tiles along the length
local base = script.Parent -- The part to replace with terrain
local tilePart = Instance.new("Part")
tilePart.Anchored = true
tilePart.formFactor = "Custom"
tilePart.Size = base.Size / size --The size of one unit or cuboid of the map
```

Now, how we will create all the bricks is similar to how we did it last time, only now it will use two "for" loops.

```
for x = 1, size.x do
for z = 1, size.z do
local y = math.random(size.y)
local tile = tilePart:clone()
local position = Vector3.new(x-1, 0, z-1) * tile.Size
tile.Size = tile.Size * Vector3.new(1, y, 1)
tile.CFrame = CFrame.new(tile.Size/2) --Shift the part by half it's size, so we can position the corner
tile.CFrame = tile.CFrame - base.Size / 2 --Shift it into one corner of the base
tile.CFrame = tile.CFrame + position --Put it in the right place
tile.CFrame = base.CFrame * tile.CFrame --Move it so that it is level with the surface of the base
tile.Parent = workspace
end
end -- an end for each for loop
```

## Coloring the bricks

Sadly, in case you haven't noticed, the bricks are all completely dull and grey. So to change this we will make a simple function named "color".

### Randomly Picked

For this method, we'll use a table full of colors. Then the function will pick a random color out of the table and use it. Here is the function

```
local colors = {BrickColor.Red(), BrickColor.Black(), BrickColor.White()}
function color(part)
part.BrickColor = colors[math.random(#colors)]
end
```

Now all you have to do to use this function is somewhere in the script put *color(a)*
and it will run.

### Based on height

Now we will base are function off of the height of the brick. It will be basically the same thing, with one real difference. Now we will have a couple of conditionals and the "color(a)" will have to go after the brick is sized.

```
local colors = {BrickColor.Red(), BrickColor.Black(), BrickColor.White()}
function color(part)
if part.Size.Y > 7 then
part.BrickColor = colors[3]
elseif part.Size.Y > 3 then
part.BrickColor = colors[2]
else
part.BrickColor = colors[1]
end
end
```

## Using weighted values

In scripting terminology, weighted means numbers adjusted to seem more proportional towards what you want.

### Mountains

In case we wanted to make sure a mountain came out of our script, we can easily just use a variable ( rand ) to hold the highest point we reach and add that to every number. Now to maintain it being random, we will also add a random number between -2 and 2. Then after we have that number, we'll check if the random number between -2 and 2 is greater than 0 and add it to our variable "rand".

```
rand=0
for x=1,Xlength do
for z=1,Zlength do
local a=part:clone()
local random_factor=math.random(-2,2)
tilePart.Size=Vector3.new(part.Size.X/Xlength,rand+random_factor,par.Size.Z/Zlength)
if random_factor>0 then
rand=rand+random_factor
end
```

### Lake

Now to make a lake, we won't need random_factor or rand. All that will be needed is a little bit of math to add in the weighted factors. Just try

```
tilePart.Size=Vector3.new(par.Size.X/Xlength,math.random(-2,2)+math.abs(x-Xlength/2)+math.abs(z-Zlength),par.Size.Z/Zlength)
```

Now this works because it will subtract half of the number of bricks from x, putting x in the middle, then taking the absolute value of that and adding it with the same thing for z.