Just here for the code? Check out https://github.com/abrightmoore/ProceduralSettlementsInMinecraft

Framework

The approach I have taken to settlement generation involved identifying plots of existing landscape that can accept a building and then placing clusters of rooms on them. I populate the buildings with contents and then connect the buildings together with paths. The areas between the building plots are strung with low wall sections, and some farm land with various crop types are placed where possible. Building types include houses, towers, and a village square with a fountain.

Placement of generated schematics on the landscape requires some minor adjustments to parts of the landscape. Sometimes it is necessary to create sections of building foundations to prevent parts of the flooring floating over air.

Buildings

Buildings are a collection of rooms packed close to each other using a simple packing algorithm. The contents of the rooms are determined from a simple blueprint that associates the room type with a generation procedure. Orientation of blocks to line up with walls and avoid windows is done through the generator inspecting the area and making appropriate layout decisions.

Windows, lighting, and doors are punched through the assembly at intervals to provide passage for the inhabitants.

Room Contents

Carpet, crafting tables, furnaces, chests, beds and chairs are placed according to the room type to provide simple functional capabilities that an inhabitant might require.

Building placement

The algorithm profiles the landscape using a heightmapping approach. It then attempts to isolate areas of severe terrain height change, and then searches the remaining gently sloping areas for square sections that can be used to place buildings.

Each settlement is defined by a blueprint which is a collection of feature generator names. The generators are delegated the responsibility to populate the region of the landscape with features. This framework is extended by adding a generator to the blueprint for a village.

Towers

The tower variant of building has been introduced to provide a watchtower to the settlement. It was primarily created to show how generators can be created using python and the features of the pymclevel library. A worked example is in this thread: https://twitter.com/TheWorldFoundry/status/1087616035992170496

The structure of a tower shows some of the procedural methods used to create it:

Paths between plots

Each building plot centre is an anchor point that can be used to mark paths between the plots. By adjusting the number and weights of path plotting the settlement can get a ‘lived in’ feel.

Walls

Establishing a voronoi graph for the plots in the settlement creates sections of landscape where walls can be placed.

Farmland

Adding a farmland generator was then as simple as creating a blueprint entry and writing the corresponding generator to create farmland, water source, fences and crops.

The structure of a Minecraft world, adapted from the Minecon Earth 2018 MCEdit Community Panel

Machine learning with Minecraft skins

Traditional approaches to design problems in computing involve evaluating criteria and then responding with a procedure that takes input to create a result. Some systems are iterative and involve repeated application of 'rules' to generate an outcome. My work on this challenge was 'procedural' and not-iterative in nature, and not statistical/learning based. My approach was to evaluate the landscape and then build something in response to what was found.

def getMyHeightMap(level, box, options):

'''

Iterate through space and explore it

'''

print "INFO: Starting to getMyHeightMap()"

HM = [] # A set of rows

for z in xrange(box.minz,box.maxz):

COL = []

for x in xrange(box.minx,box.maxx):

(theBlock,theBlockData) = (-1,-1)

heightHere = -1 # default to 'invalid'/void

y = box.maxy

while y >= box.miny: # Examine each 1x1 line, top down

y -= 1

theBlock = level.blockAt(x,y,z)

if theBlock not in NONSURFACE:

theBlockData = level.blockDataAt(x,y,z)

heightHere = y

y = box.miny-1 # or... break

COL.append((heightHere,(theBlock,theBlockData)))

HM.append(COL) # Adding the current column of values to the set

if DEBUG: print "Height Map:\n",HM

print "INFO: Completed getMyHeightMap()"

return HM

def generateAggregateHeightMaps(HM):

'''

Gathers a set of info about regions together

'''

print "INFO: Starting to generateAggregateHeightMaps()"

DEPTH = len(HM)

# print HM

WIDTH = len(HM[0])

AHM = []

DIM = 4

keepGoing = True

while keepGoing:

if DIM > DEPTH or DIM > WIDTH:

keepGoing = False

else:

CZ = 0

ROWS = []

while (CZ+DIM) <= DEPTH:

COL = []

CX = 0

while (CX+DIM) <= WIDTH:

heightSum = 0

heightMin = 999999  # Invalid

heightMax = -999999 # Invalid

analyseBlocks = {} # Analyse Block types

for dz in xrange(0,DIM):

for dx in xrange(0,DIM):

HMRow = HM[CZ+dz]

(heightHere,(bID,bData)) = HMRow[CX+dx]

if (bID,bData) in analyseBlocks: # Analyse Block types

analyseBlocks[(bID,bData)] = analyseBlocks[(bID,bData)]+1 # Analyse Block types

else: # Analyse Block types

analyseBlocks[(bID,bData)] = 1 # Analyse Block types

heightSum += heightHere

if heightHere < heightMin: heightMin = heightHere

if heightHere > heightMax: heightMax = heightHere

heightAvg = heightSum/(DIM**2)

COL.append(((CX,CZ),(heightAvg,heightSum,heightMin,heightMax,heightMax-heightMin),analyseBlocks)) # Sample tuple - including variance

#print COL

CX += DIM

ROWS.append(COL)

CZ += DIM

AHM.append((DIM,ROWS))

DIM += 1 # DIM*2 # Or otherwise double it

if DEBUG: print "Aggregate Height Maps:\n",AHM

print "INFO: Completed generateAggregateHeightMaps()"

return AHM

Terrain profiles as cells at different scales

Height map (left) and derived edge map (right) showing connected areas of gentle sloped terrain

Edge detection was done simply by calculating whether the difference between two heights was excessive, which for a Minecraft player is the unjumpable height difference of 2 blocks, and also by projecting this difference out far enough that there is sufficient area marked as 'near the edges' that would allow a building to be safely placed anywhere there was a 'flat' pixel in the edge map:

def findEdges(img):

width = img.get_width()

height = img.get_height()

delta = 2 # This is the number to change to adjust the sensitivity of edge detection. Decrease to increase the possible plot locations to flatter zones.

deltaHalf = delta >> 1

imgB = pygame.Surface((width-delta, height-delta),0,8)

pix = pygame.PixelArray(img)

pixB = pygame.PixelArray(imgB)

for x in xrange(deltaHalf,width-deltaHalf):

for y in xrange(deltaHalf,height-deltaHalf):

avgDelta = 0

vr = pix[x,y]

count = 0

for dx in xrange(-deltaHalf,deltaHalf+1):

for dy in xrange(-deltaHalf,deltaHalf+1):

count += 1

if not (dx == 0 and dy == 0):

nr = pix[x+dx,y+dy]

# print vr,nr

avgDelta = avgDelta + int(abs(vr-nr))

avgDelta = avgDelta / count

# pixB[x-1,y-1] = avgDelta

if avgDelta != 0:

pixB[x-delta,y-delta] = 255

img.unlock()

imgB.unlock()

return imgB

To simplify selection of building sites (black, right), the edge detection (white, right) is expanded to prevent the building dimensions falling close to an edge

Houses are randomly generated

Modular procedurally generated houses

Modern city hierarchical procedural generation by the author in Minecraft (Building and project by @NitricConcepts)

Hierarchical procedural generation framework adapted for space diorama

Hierarchical procedural generation framework adapted for clouds