import math
import random
import gzip

random.seed()
X,Y,Z = 256,256,128

def main():
    #loadColors()
    print("loading...")
    input = gzip.open("input.dat", "rb")
    header = input.read(485)
    global bytes
    bytes = bytearray(input.read(X*Y*Z))
    footer = input.read()
    input.close()

    generateMap()

    print("writing...")
    input = gzip.open("server_level.dat", "wb")
    input.write(header + bytes + footer)
    input.close()
    print("finished!")

def generateMap():
    oceanServ();

def oceanServ():
    plasmaFractal(128, 4, 2, 10, 1)
    undergroundDebris(92, 128)
    fillWater(256)
    cylinder(10,128,128,255,1,0,2)
    for x in range(X):
        for y in range(Y):
            bytes[p(x, y, 32)] = 7

def undergroundDebris(height, amount):
    print("spreading debris...")
    for i in range(amount):
        sphere(random.randint(1,4), random.randint(0,X), random.randint(0,Y), random.randint(0,height), 0, random.randint(14,16))

def count(t):
    number = 0
    print("counting blocks...")
    for x in range(X):
        for y in range(Y):
            for z in range(Z):
                if bytes[Y*(X*z+x)+y] == t:
                    number += 1
    print(number)

def replace(f, t):
    number = 0
    print("counting blocks...")
    for x in range(X):
        for y in range(Y):
            for z in range(Z):
                if bytes[Y*(X*z+x)+y] == f:
                    bytes[Y*(X*z+x)+y] = t

def p(x, y, z):
    return Y*(X*z+x)+y

def plasmaFractal(h, roughness, seed, scale, t):
    print("building plasma fractal:")
    print("   calculating...")
    grid = []
    for i in range(X+1):
        temp = []
        for j in range(Y+1):
            temp.append(0)
        grid.append(temp)
    grid[0][Y] += (random.random()-0.5)*seed
    grid[X][0] += (random.random()-0.5)*seed
    grid[0][0] += (random.random()-0.5)*seed
    grid[X][Y] += (random.random()-0.5)*seed

    for i in range(7, -1, -1):
        step = int(math.pow(2,i))
        for x1 in range(step, X, step*2):
            for y1 in range(step, Y, step*2):
                grid[x1][y1] = (grid[x1-step][y1-step] + grid[x1+step][y1+step] + grid[x1+step][y1-step] + grid[x1-step][y1+step])/4 + variance(math.pow(1.6,7-i), roughness)
        for x1 in range(step, X, step*2):
            for y1 in range(0, Y+step, step*2):
                grid[x1][y1] = (grid[x1+step][y1] + grid[x1-step][y1])*0.5
        for x1 in range(0, X+step, step*2):
            for y1 in range(step, Y, step*2):
                grid[x1][y1] = (grid[x1][y1+step] + grid[x1][y1-step])*0.5
    print("   constructing...")
    for x1 in range(X):
        for y1 in range(Y):
            f = (grid[x1][y1] + grid[x1+1][y1+1] + grid[x1+1][y1] + grid[x1][y1+1])/4 + variance(256, roughness)
            f = round(f*scale + h)
            if f < 0:
                f = 0
            elif f > Z:
                f = Z
            if f:
                column(f,x1,y1,t, 12)

def variance(step, roughness):
    return roughness/(step)*(random.random()-0.5)

def sphere(r, x1, y1, z1, inner, t):
    print("building sphere...")
    for x in range(x1-r, x1+r):
        for y in range(y1-r, y1+r):
            for z in range(z1-r, z1+r):
                radius = (x-x1)*(x-x1) + (y-y1)*(y-y1) + (z-z1)*(z-z1)
                if radius < r*r and (radius >= inner*inner or not inner):
                    if t:
                        bytes[Y*(X*z+x)+y] = t
                    else:
                        bytes[Y*(X*z+x)+y] = colorPat(x,y,z)

def cylinder(r, x1, y1, z1, h, inner, t):
    print("building cylinder...")
    for z in range(h):
        for x in range(x1-r,x1+r):
            for y in range(y1-r,y1+r):
                radius = (x-x1)*(x-x1) + (y-y1)*(y-y1)
                if radius < r*r and (radius >= inner*inner or not inner):
                    bytes[X*Y*(z+z1)+Y*x+y] = t

def rect(x1,y1,z1, x2,y2,z2, t):
    for x in range(int(x1), int(x2)):
        for y in range(int(y1), int(y2)):
            for z in range(int(z1), int(z2)):
                bytes[Y*(X*z+x)+y] = t

def blockWater():
    print("blocking water...")
    for z in range(int(Z/2-2),int(Z/2)):
        for x in range(X):
            bytes[X*Y*z+Y*x] = 7
            bytes[X*Y*z+Y*x+(X-1)] = 7
        for y in range(Y):
            bytes[X*Y*z+y] = 7
            bytes[X*Y*z+Y*(Y-1)+y] = 7

def fillMap(height, t):
    print("filling with water...")
    for x in range(X):
        for y in range(Y):
            for z in range(int(height)):
                bytes[Y*(X*z+x)+y] = t

def column(h, x, y, t, c):
    for z in range(h):
        if z > h-32:
            g = 3
        else:
            g = t
        bytes[Y*(X*z+x)+y] = g
    if c:
        bytes[X*Y*(h-1)+Y*x+y] = c
        bytes[X*Y*(h-2)+Y*x+y] = c
        bytes[X*Y*(h-3)+Y*x+y] = c

main()