Map generator (python, pygame)

import sys, pygame, math, random

from pygame.locals import *
pygame.init()

random_seed = 238572983412674123
random.seed(random_seed)

#people, houses


hmap = []
for i in range(100):
    hmap.append(0)

br, bcr = [0, 42], [ [0, 0, 100], [0, 0, 255] ] #water colour range for height map
sr, scr = [42, 45], [ [255, 204, 51], [255, 225, 80] ] #sand colour range for height map
gr, gcr = [45, 55], [ [0, 240, 0], [0, 200, 0] ] #grass colour range for height map
tr, tcr = [55, 64], [ [0, 160, 0], [0, 100, 0] ] #tree colour range for height map
rr, rcr = [64, 100], [ [150,150,150], [255, 255, 255] ] #mountain/rock/snow colour range for height map

rs = [ [br, bcr], [sr, scr], [gr, gcr], [tr, tcr], [rr, rcr] ]

for i in range(100):
    for j in range(len(rs)):
        r, c = rs[j][0], rs[j][1]
        if i >= r[0] and i < r[1]:
            c1, c2 = c[0], c[1]
            per = ( (i-r[0])/(r[1]-r[0]) )
            rgb = [ c1[0] + ( (c2[0]-c1[0]) * per),
                    c1[1] + ( (c2[1]-c1[1]) * per),
                    c1[2] + ( (c2[2]-c1[2]) * per) ]
            hmap[i] = rgb

width, height = 300, 300
scale = 3

screen = pygame.display.set_mode((width*scale, height*scale))

mapImg = pygame.Surface((width*scale, height*scale))
overlay = pygame.Surface((width*scale, height*scale)).convert_alpha()
overlay.fill( (0,0,0,0) )

sky = pygame.Surface((width*scale, height*scale)).convert_alpha()
sky.fill( (0,0,0,0) )

def drawScreen():
    screen.blit(mapImg, (0, 0))
    screen.blit(overlay, (0, 0))
    screen.blit(sky, (0, 0))
    pygame.display.flip()

def isValid(x, y):
    if x >= 0 and x < width and y >= 0 and y < height:
        return True
    return False

bordersOn = True
border = [0, 0, 0]
borderDiff = 0
def drawPixel(target, x, y, col, borders, lighting):
    xf, yf = x*scale, y*scale
    xt, yt = (x*scale)+scale, (y*scale)+scale

    for rx in range(xf, xt):
        for ry in range(yf, yt):
            tcol = col

            if bordersOn and (col[0] > 0 or col[1] > 0):
                if (rx == xf and borders[3]): #West (Left)
                    tcol = border
                elif (rx == xt-1 and borders[1]): #East (Right)
                    tcol = border
                elif (ry == yf and borders[0]): #North (Up)
                    tcol = border
                elif (ry == yt-1 and borders[2]): #South (Down)
                    tcol = border

            for i in range(len(tcol)):
                if tcol[i] > 255:
                    tcol[i] = 255
                elif tcol[i] < 0:
                    tcol[i] = 0

            target.set_at((rx, ry), tcol)

def getBorders(x, y, rdiff):
    borders = [False, False, False, False] #North, East, South, West
    if isValid(x, y):
        h = wmap[x][y][0]
        col = hmap[h]

        for o in range(-1, 2, 2):
            ps = [ [x+o, y], [x, y+o] ]
            for i in range(len(ps)):
                p = ps[i]

                if isValid(p[0], p[1]):

                    col2 = hmap[wmap[p[0]][p[1]][0]]
                    diff = math.fabs(col[0]-col2[0]) + math.fabs(col[1]-col2[1]) + math.fabs(col[2]-col2[2])
                    if diff > rdiff and bordersOn:
                        if p[0] < x: #West
                            borders[3] = False
                        elif p[0] > x: #East
                            borders[1] = True
                        elif p[1] < y: #North
                            borders[0] = False
                        elif p[1] > y: #South
                            borders[2] = True
    return borders

wmap = []

for x in range(width):
    tab = []
    for y in range(height):
        h = random.randint(0,99)

        tab.append([h, 0])
    wmap.append(tab)

def getDist(x1, y1, x2, y2):
    return math.sqrt( ((x1-x2)*(x1-x2)) + ((y1-y2)*(y1-y2)) )

smooth = 3
sharp = 1
def smoothmapImg():
    for x in range(width*scale):
        for y in range(height*scale):
            col = mapImg.get_at((x, y))
            col = [col[0]*sharp, col[1]*sharp, col[2]*sharp]
            n = sharp
            for ox in range(-smooth, smooth+1):
                for oy in range(-smooth, smooth+1):
                    if (x+ox) >= 0 and (x+ox) < width*scale and (y+oy) >= 0 and (y+oy) < height*scale:
                        tempc = mapImg.get_at((x+ox, y+oy))
                        col = [col[0] + tempc[0], col[1]+tempc[1], col[2]+tempc[2] ]
                        n = n + 1
            col[0] = math.floor(col[0]/n)
            col[1] = math.floor(col[1]/n)
            col[2] = math.floor(col[2]/n)
            mapImg.set_at((x, y), col)


def drawWorld():
    for x in range(width):
        for y in range(height):
            h = wmap[x][y][0]
            col = hmap[h]

            lighting = wmap[x][y][1]

            drawPixel(mapImg, x, y, col, getBorders(x, y, borderDiff), lighting)
    drawScreen()


def addHotspot(x, y, h, intensity, dist):
    for ox in range(-dist, dist+1):
        for oy in range(-dist, dist+1):
            if (ox*ox)+(oy*oy) <= dist*dist and isValid(x+ox, y+oy):
                per = 100- ((( (ox*ox) + (oy*oy) )/(dist*dist))*100)
                i = math.ceil( (intensity/100)*per )
                wmap[x+ox][y+oy].append([h, i])

drange = [30, 70]
def generateHotspot(x, y):
    pos = [x, y]
    h = random.randint(0, 99)
    intensity = random.randint(6, 13)
    dist = random.randint(drange[0], drange[1])
    addHotspot(pos[0], pos[1], h, intensity, dist)

def genHotspots():
    avgdrange = (drange[0]+drange[1])/2
    hotspot_amt = math.ceil( (width*height)/(math.pi*avgdrange*avgdrange) )
    hotroot = math.ceil(math.sqrt(hotspot_amt))
    wpart, hpart = width/hotroot, height/hotroot
    hotroot = hotroot*2
    for x in range(0, hotroot):

        for y in range(0, hotroot):
            rx = ( (x*wpart) + wpart )/2
            ry = ( (y*hpart) + hpart)/2
            offset = [random.randint(0, math.floor(wpart))-(wpart/2), random.randint(0, math.floor(hpart))-(hpart/2)]
            generateHotspot(math.floor(rx+offset[0]), math.floor(ry+offset[1]))

    print(hotspot_amt, ", ", hotroot)


def getAverageHeight(x, y, sens, hotspots, circular):
    nlist = []
    total = 0
    n = 0
    if isValid(x, y) and hotspots == True:
        if len(wmap[x][y]) > 2:
            for i in range(2, len(wmap[x][y])):
                hotspot = wmap[x][y][i]
                total = total + (hotspot[0]*hotspot[1])
                n = n + hotspot[1]
    for ox in range(-sens, sens+1):
        for oy in range(-sens, sens+1):
            if isValid(x+ox, y+oy):
                if circular:
                    if getDist(x, y, x+ox, y+oy) <= sens:
                        total = total + wmap[x+ox][y+oy][0]
                        n = n + 1
                else:
                    total = total + wmap[x+ox][y+oy][0]
                    n = n + 1
    h = math.floor(total/n)
    if h > 99:
        h = 99
    return h



def smoothWorld(sens, hotspots):
    todo = []
    for x in range(width):
        for y in range(height):
            wmap[x][y][0] = getAverageHeight(x, y, sens, hotspots, False)


def getTotalAverageHeight():
    total = 0
    n = 0
    for x in range(width):
        for y in range(height):
            total = total + wmap[x][y][0]
            n = n + 1

    return math.floor(total/n)

def createWorld():
    genHotspots()
    drawWorld()

    print("Smoothing world, pass 1")
    smoothWorld(2, True)
    drawWorld()

    print("Smoothing world, pass 2")
    smoothWorld(3, False)
    drawWorld()

    print("Smoothing world, pass 3")
    smoothWorld(3, True)
    drawWorld()

    print("Smoothing world, pass 4")
    smoothWorld(3, False)
    drawWorld()

createWorld()

print("Done!")
print("Finding village locations...")

villageHouses = 7
villageSize = 40
houseSize = 2
def findVillageLocations(size):
    locations = []
    for x in range(width):
        for y in range(height):
            h = wmap[x][y][0]
            if h >= gr[0] and h < gr[1]:
                ah = getAverageHeight(x, y, size, False, True)
                if ah >= h-2 and ah <= h+2:
                    canCreate = True
                    for i in range(len(locations)):
                        if getDist(locations[i][0], locations[i][1], x, y) < size*2:
                            canCreate = False
                    if canCreate:
                        locations.append([x, y])
    return locations

class House:
    def __init__(self, village, x, y, size):
        self.village = village
        self.x = x
        self.y = y
        self.size = size

    def draw(self):
        for ox in range(-self.size, self.size+1):
            for oy in range(-self.size, self.size+1):
                if getDist(self.x, self.y, self.x+ox, self.y+oy) <= self.size:
                    drawPixel(overlay, self.x+ox, self.y+oy, [140, 123, 55, 255], [True, True, False, False], 0)

class Village:
    def __init__(self, loc, size, hamt, hsize):
        houses = []
        n = 0
        while len(houses) < hamt and n < 50:
            pos = [random.randint(loc[0]-size, loc[0]+size), random.randint(loc[1]-size, loc[1]+size)]
            dist = getDist(loc[0], loc[1], pos[0], pos[1])
            if dist <= size and isValid(pos[0], pos[1]):
                canCreate = True
                for i in range(len(houses)):
                    house = houses[i]
                    if getDist(pos[0], pos[1], house.x, house.y) < hsize*2:
                        canCreate = False
                ph = wmap[pos[0]][pos[1]][0]
                if canCreate and ph >= gr[0] and ph < gr[1]:
                    houses.append(House(self, pos[0], pos[1], hsize))
            n = n + 1
        self.houses = houses
        self.x = loc[0]
        self.y = loc[1]
        self.size = size

    def draw(self):
        for i in range(len(self.houses)):
            self.houses[i].draw()



#locs = findVillageLocations(villageSize)

#print("Creating villages... (",len(locs),")")
#villages = []
#for i in range(len(locs)):
#    v = Village(locs[i], villageSize, villageHouses, houseSize)
#    v.draw()
#    villages.append(v)

print("Done!")
drawScreen()

while 1:
    for event in pygame.event.get():
        if event.type == QUIT:
            sys.exit()