From b4af0397679cea789ef29fa678b33c3351e47ab6 Mon Sep 17 00:00:00 2001
From: jacopograndi <jacopo.grandi@outlook.it>
Date: Tue, 4 Jan 2022 10:49:43 +0100
Subject: init

---
 slay2.py | 1512 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1512 insertions(+)
 create mode 100755 slay2.py

(limited to 'slay2.py')

diff --git a/slay2.py b/slay2.py
new file mode 100755
index 0000000..df2a1ff
--- /dev/null
+++ b/slay2.py
@@ -0,0 +1,1512 @@
+import pygame, traceback, math
+import random, copy, socket
+import pygame.gfxdraw
+
+# Version 1.0 roadmap
+# [x] add tombs (debug)
+# [x] kill units when underpayed
+# [x] add trees (debug)
+# [x] tombs after a turn become trees
+# [x] trees dont make income
+# [x] tree spread
+# [x] lone capital leaves tree
+# [x] add done frame (debug)
+# [x] add drag frame (debug)
+# [x] add castles (debug)
+# [x] ! test everything 1
+# [x] add action queue
+# [x] undo
+# [x] victory condition
+# [x] add lobby
+# [x] add connection socket
+# [x] add packet decode / encode
+# [x] add action actuator
+# [ ] finish art
+# > [x] doode 0 idle
+# > [x] doode 0 drag
+# > [x] doode 0 done
+# > [x] doode 1 idle
+# > [x] doode 1 drag
+# > [x] doode 1 done
+# > [x] doode 2 idle
+# > [x] doode 2 drag
+# > [x] doode 2 done
+# > [ ] doode 3 idle
+# > [ ] doode 3 drag
+# > [ ] doode 3 done
+# > [x] town
+# > [x] castle
+# > [x] trees
+# > [x] tombs
+# [ ] sounds
+# [ ] lobby track
+# [ ] game track 0
+# [ ] game track 1
+# [x] add tile screen and decide name
+# [x] optimization
+# [ ] ! test everything 2s
+# approx: 32 hrs. (spent: 1+3+2+3+3+3)
+# work at least 3 hrs a day!!! -> the 18th finishline
+
+# Test cases 1 (.: not done, -: ok, +: fixed)
+# - money calculation
+# - bankrupcy
+# . tree spreading
+# + strenght function
+# - troubleshoot hover state machine
+# - play a full game, look for bugs
+# - trees stomping not working
+# + banckrupcy was delayed 1 turn
+
+# Optimizations
+# - precalculate zones and neighbours
+# . precalculate perimeter instead of each frame
+# . precalculate order of tiles for unit blitting
+# + render each zoom level separately and not each frame
+
+class Opt:
+    res = [800, 550]
+    gamemode = 0
+    lag = 100
+
+class Loaded:
+    imgs = []
+    imgcolortile = []
+    imgcolorhouse = []
+    font = None
+    fonttitle = None
+    zoomimgs = []
+    zoomcolorimgs = []
+    zoomcolorhouse = []
+
+class Tile:
+    def __init__ (self):
+        self.owner = 0; self.pos = [0, 0]
+        self.grid = [0, 0]
+        self.unit = None
+        self.money = 0
+        self.savings = 0
+        self.income = 0
+        self.upkeep = 0
+        self.strenght = 0
+        self.done = 0
+        self.neighbours = []
+
+class Player:
+    color = [0,0,0]
+    mind = 0
+
+class Gamestate:
+    players = []
+    tiles = []
+    sel = None
+    perimetersel = []
+    zoom = 0
+    rel = [0, 0]
+    turn = 0
+    day = 0
+    moves = []
+    register = []
+    hover = 0
+    peerid = 0
+
+class Commands:
+    def __init__ (self):
+        self.mousepos = [0, 0]
+        self.mouse = [0, 0, 0]
+        self.pressed = [0, 0, 0]
+        self.wheel = 0
+        self.relwheel = 0
+        self.relpos = [0, 0]
+        self.keysdown = []
+        self.res = [0, 0]
+
+    def update (self):
+        self.keysdown = []
+        for i in range(3):
+            if pygame.mouse.get_pressed()[i]: self.mouse[i] += 1
+            elif self.mouse[i] > 0: self.mouse[i] = -1
+            else: self.mouse[i] = 0
+        self.pressed = pygame.mouse.get_pressed()
+
+        mx, my = pygame.mouse.get_pos()
+        self.relpos = [mx-self.mousepos[0], my-self.mousepos[1]]
+        self.mousepos = [mx, my]
+        
+        self.relwheel = 0
+
+        for e in pygame.event.get():
+            if e.type == pygame.QUIT:
+                return False
+            if e.type == pygame.KEYDOWN:
+                self.keysdown += [pygame.key.name(e.key)]
+                if e.key == pygame.K_ESCAPE:
+                    return False
+            if e.type == pygame.MOUSEBUTTONDOWN:
+                if e.button == 4:
+                    self.wheel += 1
+                    self.relwheel = 1
+                elif e.button == 5:
+                    self.wheel -= 1
+                    self.relwheel = -1
+            if e.type == pygame.VIDEORESIZE:
+                self.res = e.size
+        return True
+
+class LocalPeer:
+    def __init__ (self):
+        self.id = 0
+        self.lobbycolorangle = 0
+        self.localplayers = []
+        self.hostplayers = []
+        self.hostSock = None
+        self.clientSock = None
+        self.foundhosts = []
+        self.act = None
+        self.hostAddr = None
+        self.requestqueue = []
+        self.start = 0
+        self.mapseed = 0
+        self.mapsize = 0
+        self.mapindex = 0
+        self.passedturn = False
+        self.packettimer = 0
+        self.turnmoves = []
+
+class Move:
+    def __init__ (self):
+        self.selector = 0
+        self.gridposstart = 0
+        self.gridposend = 0
+        self.player = 0
+        self.day = 0
+        self.snapshot = None
+ 
+class Action:
+    def __init__ (self, protocol):
+        self.protocol = protocol
+        self.playernum = 0
+        self.starting = 0
+        self.color_r = 0
+        self.color_g = 0
+        self.color_b = 0
+        self.playerindex = 0
+        self.mapseed = 0
+        self.mapsize = 0
+        self.mapindex = 0
+        self.registerlenght = 0
+        self.movesstart = 0
+        self.movesend = 0
+        self.moves = []
+    def __repr__ (self):
+        return "[Action: protocol: "+str(self.protocol)+"]"
+        
+def act_encode (act):
+    b = bytes();
+    b += (act.protocol).to_bytes(1, byteorder='big')
+    if act.protocol == 0: # request connection
+        b += (act.color_r).to_bytes(1, byteorder='big')
+        b += (act.color_g).to_bytes(1, byteorder='big')
+        b += (act.color_b).to_bytes(1, byteorder='big')
+        return b
+    if act.protocol == 1: # accept connection
+        b += (act.playerindex).to_bytes(1, byteorder='big')
+        return b
+    if act.protocol == 2: # lobby general request
+        return b
+    if act.protocol == 3: # lobby set
+        b += (act.playernum).to_bytes(1, byteorder='big')
+        b += (act.starting).to_bytes(1, byteorder='big')
+        b += (act.mapseed).to_bytes(4, byteorder='big')
+        b += (act.mapsize).to_bytes(4, byteorder='big')
+        b += (act.mapindex).to_bytes(4, byteorder='big')
+        return b
+    if act.protocol == 4: # lobby playerinfo request
+        b += (act.playerindex).to_bytes(1, byteorder='big')
+        return b
+    if act.protocol == 5: # lobby playerinfo set
+        b += (act.playerindex).to_bytes(1, byteorder='big')
+        b += (act.color_r).to_bytes(1, byteorder='big')
+        b += (act.color_g).to_bytes(1, byteorder='big')
+        b += (act.color_b).to_bytes(1, byteorder='big')
+        return b
+    if act.protocol == 6: # general request
+        return b
+    if act.protocol == 7: # general response
+        b += (act.registerlenght).to_bytes(4, byteorder='big')
+        return b
+    if act.protocol == 8: # request moves
+        b += (act.movesstart).to_bytes(4, byteorder='big')
+        b += (act.movesend).to_bytes(4, byteorder='big')
+        return b
+    if act.protocol == 9: # moves set
+        b += (act.movesstart).to_bytes(4, byteorder='big')
+        b += (act.movesend).to_bytes(4, byteorder='big')
+        for i in range(len(act.moves)): # 11 bytes
+            b += (act.moves[i].selector).to_bytes(1, byteorder='big')
+            b += (act.moves[i].gridposstart).to_bytes(4, byteorder='big')
+            b += (act.moves[i].gridposend).to_bytes(4, byteorder='big')
+            b += (act.moves[i].player).to_bytes(1, byteorder='big')
+            b += (act.moves[i].day).to_bytes(1, byteorder='big')
+        return b
+    if act.protocol == 10: # moves ack
+        return b
+    
+def act_decode (b):
+    act = Action(int.from_bytes(b[0:1], byteorder='big'))
+    if act.protocol == 0:
+        act.color_r = int.from_bytes(b[1:2], byteorder='big')
+        act.color_g = int.from_bytes(b[2:3], byteorder='big')
+        act.color_b = int.from_bytes(b[3:4], byteorder='big')
+    if act.protocol == 1:
+        act.playerindex = int.from_bytes(b[1:2], byteorder='big')
+    if act.protocol == 3:
+        act.playernum = int.from_bytes(b[1:2], byteorder='big')
+        act.starting = int.from_bytes(b[2:3], byteorder='big')
+        act.mapseed = int.from_bytes(b[3:7], byteorder='big')
+        act.mapsize = int.from_bytes(b[7:11], byteorder='big')
+        act.mapindex = int.from_bytes(b[11:15], byteorder='big')
+    if act.protocol == 4:
+        act.playerindex = int.from_bytes(b[1:2], byteorder='big')
+    if act.protocol == 5:
+        act.playerindex = int.from_bytes(b[1:2], byteorder='big')
+        act.color_r = int.from_bytes(b[2:3], byteorder='big')
+        act.color_g = int.from_bytes(b[3:4], byteorder='big')
+        act.color_b = int.from_bytes(b[4:5], byteorder='big')
+    if act.protocol == 7:
+        act.registerlenght = int.from_bytes(b[1:5], byteorder='big')
+    if act.protocol == 8:
+        act.movesstart = int.from_bytes(b[1:5], byteorder='big')
+        act.movesend = int.from_bytes(b[5:9], byteorder='big')
+    if act.protocol == 9:
+        act.movesstart = int.from_bytes(b[1:5], byteorder='big')
+        act.movesend = int.from_bytes(b[5:9], byteorder='big')
+        print(act.movesstart)
+        print(act.movesend)
+        lenght = act.movesend - act.movesstart
+        for i in range(lenght):
+            move = Move()
+            st = 9+11*i
+            move.selector = int.from_bytes(b[st:st+1], byteorder='big')
+            move.gridposstart = int.from_bytes(b[st+1:st+5], byteorder='big')
+            move.gridposend = int.from_bytes(b[st+5:st+9], byteorder='big')
+            move.player = int.from_bytes(b[st+9:st+10], byteorder='big')
+            move.day = int.from_bytes(b[st+10:st+11], byteorder='big')
+            act.moves.append(move)
+            print(move.selector, move.gridposstart, move.gridposend, move.player, move.day)
+        print("end")
+    return act
+
+
+def hsv_to_rgb (h, s=1, v=1):
+    c = v*s
+    x = c*(1-abs((h/60.0)%2-1))
+    m = v - c
+    if 0 <= h < 60: a = (c, x, 0)
+    if 60 <= h < 120: a = (x, c, 0)
+    if 120 <= h < 180: a = (0, c, x)
+    if 180 <= h < 240: a = (0, x, c)
+    if 240 <= h < 300: a = (x, 0, c)
+    if 300 <= h <= 360: a = (c, 0, x)
+    return int((a[0]+m)*255), int((a[1]+m)*255), int((a[2]+m)*255)
+
+def calc_good_mapsize (size):
+    c = 1; i = 0
+    while True:
+        if c == size: return True
+        if c > size: return False
+        c += 6*i; i += 1
+
+def get_next_mapsize (size):
+    c = 1; i = 0
+    while True:
+        if c+6*i > size: return c+6*i
+        c += 6*i; i += 1
+
+def get_prev_mapsize (size):
+    c = 1; i = 0
+    while True:
+        if c+6*i > size: return c-6*(i-1)
+        c += 6*i; i += 1
+
+def abs_to_zoom (pos, rel, zoom, res):
+    z = (zoom*0.1)+1
+    zinverse = 1/z
+
+    rnp = [pos[0]+rel[0], pos[1]+rel[1]]
+    rnp = [rnp[0]*z, rnp[1]*z]
+    rnp = [rnp[0]+(res[0]/2)*(1-z), rnp[1]+(res[1]/2)*(1-z)]
+    return rnp
+
+def zoom_to_abs (pos, rel, zoom, res):
+    z = (zoom*0.1)+1
+    zinverse = 1/z
+
+    rnp = [pos[0]-(res[0]/2)*(1-z), pos[1]-(res[1]/2)*(1-z)]
+    rnp = [rnp[0]*zinverse, rnp[1]*zinverse]
+    rnp = [rnp[0]-rel[0], rnp[1]-rel[1]]
+    return rnp
+
+def get_neighbours (gst, index):
+    if index == None: return []
+    return gst.tiles[index].neighbours
+
+def prec_get_neighbours (gst, index):
+    ret = []
+    neigh = [
+        [1, 0],
+        [0, 1],
+        [-1, 1],
+        [-1, 0],
+        [0, -1],
+        [1, -1],
+    ]
+    for j in range(len(neigh)):
+        nx = gst.tiles[index].grid[0]+neigh[j][0]
+        ny = gst.tiles[index].grid[1]+neigh[j][1]
+        for i in range(len(gst.tiles)):
+            if nx == gst.tiles[i].grid[0] and \
+                    ny == gst.tiles[i].grid[1]:
+                ret.append(i)
+    return ret
+
+def get_zone (gst, index):
+    if index == None: return []
+    grid = gst.tiles[index].grid
+    zone = [index]
+    queue = [index]
+    while True:
+        s = zone[0]
+        zone = zone[1:]
+        friends = get_neighbours(gst, s)
+        for f in friends:
+            if not(f in queue or f in zone) and \
+                   gst.tiles[f].owner == gst.tiles[index].owner:
+                zone.append(f)
+        if len(zone) == 0: return queue
+        queue += [zone[0]]
+
+def get_borders (gst, index):
+    zone = get_zone(gst, index)
+    border = []
+    for z in zone:
+        neigh = get_neighbours(gst, z)
+        for n in neigh:
+            if not(n in border): border += [n]
+    return border
+
+def get_perimeter(gst, zone):
+    neigh = [
+        [1, 0], [0, 1], [-1, 1], [-1, 0], [0, -1], [1, -1],
+    ]
+    perimeter = []
+    for i in zone:
+        for j in range(len(neigh)):
+            nx = gst.tiles[i].grid[0]+neigh[j][0]
+            ny = gst.tiles[i].grid[1]+neigh[j][1]
+            for s in range(len(gst.tiles)):
+                if nx == gst.tiles[s].grid[0] and \
+                        ny == gst.tiles[s].grid[1] and \
+                        gst.tiles[i].owner != gst.tiles[s].owner:
+                    perimeter += [[i, (j+4)%6]]
+    return perimeter
+
+def get_capital (gst, index):
+    zone = get_zone(gst, index)
+    for i in zone:
+        if gst.tiles[i].unit == 1: return i
+    return index
+
+def calculate_income (gst, index):
+    zone = get_zone(gst, index)
+    income = 0
+    for z in zone:
+        if gst.tiles[z].unit != 3: income += 1
+    return income
+
+def calculate_upkeep (gst, index):
+    zone = get_zone(gst, index)
+    upkeep_to_strenght = [0, 2, 6, 18, 52]
+    upkeep = 0
+    for z in zone:
+        if gst.tiles[z].unit == 0:
+            upkeep += upkeep_to_strenght[gst.tiles[z].strenght]
+    return upkeep
+
+def calculate_balance (gst, index):
+    capital = get_capital(gst, index)
+    income = gst.tiles[index].income
+    upkeep = gst.tiles[index].upkeep
+    return gst.tiles[capital].savings + income - upkeep
+
+def calculate_bankrupcy (gst, index):
+    if calculate_balance(gst, index) < 0:
+        capital = get_capital(gst, index)
+        gst.tiles[capital].savings = 0
+        zone = get_zone(gst, index)
+        for z in zone:
+            if gst.tiles[z].unit == 0:
+                gst.tiles[z].unit = 2
+                gst.tiles[z].strenght = 0
+                gst.tiles[z].done = 0
+
+def calculate_victory (gst):
+    count = [0 for i in range(0, len(gst.players))]
+    for i in range(len(gst.tiles)):
+        count[gst.tiles[i].owner] += 1
+    for i in range(len(count)):
+        if count[i] == len(gst.tiles):
+            return i
+    return None
+
+def calculate_ply(gst, player, trees):
+    capitals = []
+    for i in range(len(gst.tiles)):
+        tile = gst.tiles[i]
+        if gst.tiles[i].owner == player:
+            if gst.tiles[i].unit == 2 and trees:
+                # tombs become trees
+                gst.tiles[i].unit = 3
+            gst.tiles[i].done = 0
+            capital = get_capital(gst, i)
+            if not(capital in capitals):
+                capitals += [capital]
+    if gst.day > 0:
+        for c in capitals:
+            gst.tiles[c].savings = gst.tiles[c].money
+            gst.tiles[c].upkeep = calculate_upkeep(gst, c)
+            gst.tiles[c].income = calculate_income(gst, c)
+            gst.tiles[c].money = calculate_balance(gst, c)
+            calculate_bankrupcy(gst, c)
+    calculate_tree_spread(gst)
+
+def calculate_next_ply(gst):
+    gst.turn += 1
+    if gst.turn>=len(gst.players):
+        gst.turn = 0
+        gst.day += 1
+
+    # victory
+    victory = calculate_victory(gst)
+    if victory != None:
+        print(str(victory)+" won!")
+    calculate_ply (gst, gst.turn, True)
+
+def calculate_defence (gst, index):
+    neighs = get_neighbours(gst, index)
+    strenghts = [gst.tiles[index].strenght]
+    for n in neighs:
+        if gst.tiles[n].owner == gst.tiles[index].owner:
+            strenghts += [gst.tiles[n].strenght]
+    return max(strenghts)
+
+def calculate_attack (gst, strenght, defender):
+    if strenght > calculate_defence(gst, defender): return True
+    return False
+
+def calculate_tree_spread (gst):
+    # if an empty tile has 2 tree neighs -> tree
+    new = []
+    for i in range(0, len(gst.tiles)):
+        if gst.tiles[i].unit == None:
+            neighs = get_neighbours(gst, i)
+            count = 0
+            for n in neighs:
+                if gst.tiles[n].unit == 3: count += 1
+            if count >= 2: new += [i]
+    for i in new:
+        gst.tiles[i].unit = 3
+
+def update_capital (gst, index):
+    zone = get_zone(gst, index)
+    capitals = []
+    for i in zone:
+        if gst.tiles[i].unit == 1: capitals += [i]
+    if len(capitals) == 0:
+        available_spots = []
+        for i in zone:
+            if not(gst.tiles[i].unit in [0]): available_spots += [i]
+        if len(available_spots) > 1:
+            capital = random.choice(available_spots)
+            gst.tiles[capital].unit = 1
+            gst.tiles[capital].strenght = 1
+            gst.tiles[capital].savings = 0
+            gst.tiles[capital].money = 0
+            gst.tiles[capital].income = calculate_income(gst, capital)
+            gst.tiles[capital].upkeep = calculate_upkeep(gst, capital)
+    if len(capitals) >= 2:
+        best = max(capitals, key=lambda x: gst.tiles[x].savings)
+        for i in capitals:
+            if i != best:
+                gst.tiles[best].money += gst.tiles[i].money
+                gst.tiles[best].upkeep += gst.tiles[i].upkeep
+                gst.tiles[best].income += gst.tiles[i].income
+                gst.tiles[i].savings = 0
+                gst.tiles[i].money = 0
+                gst.tiles[i].strenght = 0
+                gst.tiles[i].unit = None
+                gst.tiles[i].income = 0
+                gst.tiles[i].upkeep = 0
+    if len(zone) == 1 and len(capitals) == 1:
+        gst.tiles[index].unit = 3
+        gst.tiles[index].savings = 0
+        gst.tiles[index].strenght = 0
+        gst.tiles[index].money = 0
+        gst.tiles[index].done = 0
+        gst.tiles[i].income = 0
+        gst.tiles[i].upkeep = 0
+
+def add_move (gst, sel, a, b, player, day):
+    move = Move()
+    move.selector = sel
+    move.gridposstart = a
+    move.gridposend = b
+    move.player = player
+    move.day = day
+    move.snapshot = copy.deepcopy(gst.tiles)
+    gst.moves.append(move)
+
+def actuate (gst, moves):
+    for move in moves:
+        if move.selector == 0:
+            unit_place(gst, move.gridposstart, move.gridposend)
+        if move.selector == 1:
+            unit_place_castle(gst, move.gridposend)
+        if move.selector == 2:
+            unit_new_upgrade(gst, move.gridposend)
+        if move.selector == 3:
+            unit_new_attack(gst, move.gridposstart, move.gridposend)
+        if move.selector == 4:
+            unit_move(gst, move.gridposstart, move.gridposend)
+        if move.selector == 5:
+            unit_upgrade(gst, move.gridposstart, move.gridposend)
+        if move.selector == 6:
+            unit_attack(gst, move.gridposstart, move.gridposend)
+        if move.selector == 7:
+            calculate_next_ply(gst)
+
+def unit_place (gst, prev, index):
+    # selector = 0
+    gst.tiles[index].unit = 0
+    gst.tiles[index].strenght = 1
+    gst.tiles[get_capital(gst, index)].money -= 10
+    
+def unit_place_castle (gst, index):
+    # selector = 1
+    gst.tiles[index].unit = 4
+    gst.tiles[index].strenght = 2
+    gst.tiles[get_capital(gst, index)].money -= 15
+
+def unit_new_upgrade (gst, index):
+    # selector = 2
+    gst.tiles[index].strenght += 1
+    gst.tiles[get_capital(gst, index)].money -= 10
+
+def unit_new_attack (gst, prev, index):
+    # selector = 3
+    gst.tiles[index].unit = 0
+    gst.tiles[index].strenght = 1
+    gst.tiles[index].done = 1
+    gst.tiles[index].owner = gst.tiles[prev].owner
+    neighs = get_neighbours(gst, index)
+    for n in neighs: update_capital(gst, n)
+    gst.tiles[get_capital(gst, index)].money -= 10
+
+def unit_move (gst, prev, index):
+    # selector = 4
+    gst.tiles[index].unit = gst.tiles[prev].unit
+    gst.tiles[index].strenght = gst.tiles[prev].strenght
+    gst.tiles[prev].unit = None
+    gst.tiles[prev].strenght = 0
+
+def unit_upgrade (gst, prev, index):
+    # selector = 5
+    gst.tiles[index].strenght += gst.tiles[prev].strenght
+    gst.tiles[prev].unit = None
+    gst.tiles[prev].strenght = 0
+    
+def unit_attack (gst, prev, index):
+    # selector = 6
+    gst.tiles[index].savings = 0
+    gst.tiles[index].upkeep = 0
+    gst.tiles[index].income = 0
+    gst.tiles[index].money = 0
+    gst.tiles[index].unit = gst.tiles[prev].unit
+    gst.tiles[index].strenght = gst.tiles[prev].strenght
+    gst.tiles[index].done = 1
+    gst.tiles[index].owner = gst.tiles[prev].owner
+    neighs = get_neighbours(gst, index)
+    for n in neighs: update_capital(gst, n)
+    gst.tiles[prev].unit = None
+    gst.tiles[prev].strenght = 0
+    gst.tiles[prev].done = 0
+
+def reset_sel (gst, prev):
+    gst.sel = prev
+    gst.perimetersel = get_perimeter(gst, get_zone(gst, gst.sel))
+
+def proc_unit_place (gst, prev):
+    prevzone = get_zone(gst, prev)
+    border = get_borders(gst, prev)
+    if gst.sel in border:
+        if gst.sel in prevzone:
+            if gst.tiles[gst.sel].unit in [None, 2, 3]:
+                add_move(gst, 0, prev, gst.sel, gst.turn, gst.day)
+                unit_place(gst, prev, gst.sel)
+            elif gst.tiles[gst.sel].unit == 0:
+                add_move(gst, 2, 0, gst.sel, gst.turn, gst.day)
+                unit_new_upgrade(gst, gst.sel)
+            else: reset_sel(gst, prev)
+        elif gst.sel in border:
+            if calculate_attack(gst, 1, gst.sel):
+                add_move(gst, 3, prev, gst.sel, gst.turn, gst.day)
+                unit_new_attack(gst, prev, gst.sel)
+            else: reset_sel(gst, prev)
+        else: reset_sel(gst, prev)
+    else: reset_sel(gst, prev)
+    gst.hover = 0
+    gst.perimetersel = get_perimeter(gst, get_zone(gst, gst.sel))
+
+def proc_unit_place_castle (gst, prev):
+    prevzone = get_zone(gst, prev)
+    if gst.sel in prevzone:
+        if gst.tiles[gst.sel].unit == None:
+            add_move(gst, 1, 0, gst.sel, gst.turn, gst.day)
+            unit_place_castle(gst, gst.sel)
+        else: reset_sel(gst, prev)
+    else: reset_sel(gst, prev)
+    gst.hover = 0
+    gst.perimetersel = get_perimeter(gst, get_zone(gst, gst.sel))
+
+def proc_unit_move (gst, prev):
+    if gst.sel == prev: gst.sel = None; gst.hover = 0
+    prevzone = get_zone(gst, prev)
+    border = get_borders(gst, prev)
+    if gst.sel in border:
+        if gst.sel in prevzone:
+            if gst.tiles[gst.sel].unit in [None, 2, 3]:
+                add_move(gst, 4, prev, gst.sel, gst.turn, gst.day)
+                unit_move (gst, prev, gst.sel)
+            elif gst.tiles[gst.sel].unit == 0:
+                add_move(gst, 5, prev, gst.sel, gst.turn, gst.day)
+                unit_upgrade (gst, prev, gst.sel)
+            else: reset_sel(gst, prev)
+        elif gst.sel in border:
+            if calculate_attack(gst, gst.tiles[prev].strenght, gst.sel):
+                add_move(gst, 6, prev, gst.sel, gst.turn, gst.day)
+                unit_attack(gst, prev, gst.sel)
+            else: reset_sel(gst, prev)
+        else: reset_sel(gst, prev)
+    else: reset_sel(gst, prev)
+    gst.hover = 0
+    gst.perimetersel = get_perimeter(gst, get_zone(gst, gst.sel))
+        
+def process(scr, com, gst, loaded, opt, acc, peer):
+    if peer.hostSock != None:
+        net_host_process(gst, opt, peer)
+    if peer.clientSock != None:
+        net_client_process(gst, opt, peer, acc)
+        
+    z = (gst.zoom*0.1)+1
+    zinverse = 1/z
+    if com.mouse[2] > 1:
+        gst.rel[0] += com.relpos[0]*zinverse
+        gst.rel[1] += com.relpos[1]*zinverse
+    gst.zoom += com.relwheel
+    if gst.zoom <= -5:
+        gst.zoom = -5
+    if gst.zoom > 0:
+        gst.zoom = 0
+
+    if opt.gamemode == 1 and peer.id != gst.turn: return
+
+    if com.mouse[0] == 1:
+        if com.mousepos[0]<opt.res[0]-200:
+            nearest = -1; dist = 999999
+            prev = gst.sel
+            for i in range(0, len(gst.tiles)):
+                tile = gst.tiles[i]
+                abspos = zoom_to_abs(com.mousepos, gst.rel, gst.zoom, opt.res)
+                xx = tile.pos[0]-abspos[0]
+                yy = tile.pos[1]-abspos[1]
+                candist = math.sqrt(xx*xx+yy*yy)
+                if candist < dist:
+                    nearest = i
+                    dist = candist
+            if nearest != -1:
+                gst.sel = nearest
+                gst.perimetersel = get_perimeter(gst, get_zone(gst, gst.sel))
+            # additional validation
+            if dist > 40: gst.sel = None; gst.perimetersel = []
+            
+            if gst.hover == 1:
+                proc_unit_place(gst, prev)
+            elif gst.hover == 2:
+                proc_unit_move(gst, prev)
+            elif gst.hover == 3:
+                proc_unit_place_castle(gst, prev)
+            else: 
+                zone = get_zone(gst, gst.sel)
+                if len(zone) <= 1 or gst.tiles[gst.sel].owner != gst.turn:
+                    gst.sel = None; gst.perimetersel = []
+                if gst.sel != None:
+                    if gst.tiles[gst.sel].unit == 0 and \
+                            gst.tiles[gst.sel].done == 0 :
+                        gst.hover = 2
+        else:
+            if com.mousepos[1]>170-80 and com.mousepos[1]<170 and \
+               com.mousepos[0]<opt.res[0]-100:
+                capital = get_capital(gst, gst.sel)
+                money = gst.tiles[capital].money
+                if money >= 10:
+                    gst.hover = 1
+            elif com.mousepos[1]>170-80 and com.mousepos[1]<170 and \
+               com.mousepos[0]<opt.res[0]:
+                capital = get_capital(gst, gst.sel)
+                money = gst.tiles[capital].money
+                if money >= 15:
+                    gst.hover = 3
+            if com.mousepos[1]>opt.res[1]-100:
+                calculate_next_ply(gst)
+                
+                newturnmove = Move()
+                newturnmove.selector = 7
+                gst.moves += [newturnmove]
+                gst.register += gst.moves
+                if opt.gamemode == 1:
+                    peer.passedturn = True
+                    peer.turnmoves = copy.deepcopy(gst.moves)
+                del gst.moves[:]
+                
+                gst.hover = 0
+                gst.sel = None; gst.perimetersel = []
+
+    if "z" in com.keysdown:
+        if len(gst.moves) > 0:
+            gst.tiles = copy.deepcopy(gst.moves[-1].snapshot)
+            gst.moves = gst.moves[:-1]
+            gst.sel = None; gst.perimetersel = []
+            gst.hover = 0
+
+
+def render_sidebar (scr, gst, loaded, opt):
+    pygame.draw.rect(scr, (220, 220, 220),
+        (opt.res[0]-200, 0, opt.res[0], opt.res[1]))
+    pygame.draw.rect(scr, (0, 0, 0),
+        (opt.res[0]-200, -1, opt.res[0]+1, opt.res[1]+1), 1)
+
+    # graphs
+    pygame.draw.rect(scr, (240, 240, 240),
+        (opt.res[0]-200, opt.res[1]-300, 200, 200))
+    pygame.draw.rect(scr, (0, 0, 0),
+        (opt.res[0]-200, opt.res[1]-300, opt.res[0]+1, 201), 1)
+    pygame.draw.line(scr, (0, 0, 0),
+        (opt.res[0]-190, opt.res[1]-110),
+        (opt.res[0]-16, opt.res[1]-110))
+    playercounts = [0 for i in range(len(gst.players))]
+    for i in range(0,len(gst.players)):
+        for tile in gst.tiles:
+            if tile.owner == i: playercounts[i] += 1
+    for i in range(0,len(gst.players)):
+        amt = (playercounts[i]/max(playercounts))*180
+        width = 180/len(gst.players)
+        pygame.draw.rect(scr, gst.players[i].color,
+            (opt.res[0]-190+i*width, opt.res[1]-111,
+             width-5, -amt))
+
+    # end turn
+    pygame.draw.rect(scr, (255, 255, 255),
+        (opt.res[0]-200, opt.res[1]-100, 200, 100))
+    pygame.draw.rect(scr, (0, 0, 0),
+        (opt.res[0]-200, opt.res[1]-100, opt.res[0]+1, 101), 1)
+    
+    scr.blit(loaded.font.render("PASS TURN", 4, (0, 0, 0)),
+        (opt.res[0]-190, opt.res[1]-90))
+    
+    scr.blit(loaded.font.render("TURN: "+str(gst.turn), 4, (0, 0, 0)),
+        (opt.res[0]-190, opt.res[1]-70))
+    scr.blit(loaded.font.render("DAY: "+str(gst.day), 4, (0, 0, 0)),
+        (opt.res[0]-190, opt.res[1]-50))
+
+def render_sidebar_town(scr, gst, loaded, opt):
+    if gst.sel == None: return
+    zone = get_zone(gst, gst.sel)
+    capital = get_capital(gst, gst.sel)
+    pygame.draw.rect(scr, (255, 255, 255),
+        (opt.res[0]-200, 0, opt.res[0], 190))
+    pygame.draw.rect(scr, (0, 0, 0),
+        (opt.res[0]-200, -1, opt.res[0]+1, 191), 1)
+    income = gst.tiles[capital].income
+    scr.blit(loaded.font.render("SAVINGS: "+str(gst.tiles[capital].savings), \
+        4, (0, 0, 0)), (opt.res[0]-190, 10))
+    scr.blit(loaded.font.render("INCOME: "+str(income), 4, (0, 0, 0)),
+        (opt.res[0]-190, 28))
+    upkeep = gst.tiles[capital].upkeep
+    scr.blit(loaded.font.render("UPKEEP: "+str(-upkeep), 4, (0, 0, 0)),
+        (opt.res[0]-190, 46))
+    balance = calculate_balance(gst, capital)
+    scr.blit(loaded.font.render("BALANCE: "+str(balance), 4, (0, 0, 0)),
+        (opt.res[0]-190, 64))
+    money = gst.tiles[capital].money
+    scr.blit(loaded.font.render("MONEY: "+str(money), 4, (0, 0, 0)),
+        (opt.res[0]-190, 82))
+
+    for i in range(0, min(7, int(money/10)-int(gst.hover==1))):
+        scr.blit(loaded.imgs[7], (opt.res[0]-170-80+i*7, 170-80))
+        
+    for i in range(0, min(7, int(money/15)-int(gst.hover==3))):
+        scr.blit(loaded.imgs[22], (opt.res[0]-70-80+i*7, 170-80))
+    
+def render_map(scr, gst, loaded, opt):
+    z = (gst.zoom*0.1)+1
+    zinverse = 1/z
+    zindex = gst.zoom+5
+    
+    neighs = get_neighbours(gst, gst.sel)
+    zone = get_zone(gst, gst.sel)
+    per = gst.perimetersel
+    
+    for i in range(len(gst.tiles)):
+        tile = gst.tiles[i]
+        size = int(70*z), int(70*z)
+        
+        pos = tile.pos[0]-size[0]/2*zinverse, tile.pos[1]-size[1]/2*zinverse
+        pos = abs_to_zoom(pos, gst.rel, gst.zoom, opt.res)
+        if i in zone:
+            scr.blit(loaded.zoomcolorimgs[tile.owner+len(gst.players)][zindex], pos)
+        else:
+            scr.blit(loaded.zoomcolorimgs[tile.owner][zindex], pos)
+    for i, j in per:
+        tile = gst.tiles[i]
+        size = int(70*z), int(70*z)
+        
+        pos = tile.pos[0]-size[0]/2*zinverse, tile.pos[1]-size[1]/2*zinverse
+        pos = abs_to_zoom(pos, gst.rel, gst.zoom, opt.res)
+        
+        scr.blit(loaded.zoomimgs[j+1][zindex], pos)
+        
+    ordtiles = sorted(gst.tiles, key=lambda x: x.grid[1], reverse=True)
+    for i in range(len(ordtiles)):
+        tile = ordtiles[i]
+        size = int(160*z), int(160*z)
+        
+        pos = tile.pos[0]-size[0]/2*zinverse, tile.pos[1]-size[1]/2*zinverse
+        pos = abs_to_zoom(pos, gst.rel, gst.zoom, opt.res)
+        if tile.unit == 0:
+            if not(gst.hover == 2 and gst.tiles[gst.sel].grid == tile.grid):
+                img = 7+(tile.strenght-1)*3
+                img += int(tile.done==1)*2
+                scr.blit(loaded.zoomimgs[img][zindex], pos)
+        if tile.unit == 1:
+            scr.blit(loaded.zoomimgs[19][zindex], pos)
+            scr.blit(loaded.zoomcolorhouse[tile.owner][zindex], pos)
+        if tile.unit == 2:
+            scr.blit(loaded.zoomimgs[20][zindex], pos)
+        if tile.unit == 3:
+            scr.blit(loaded.zoomimgs[21][zindex], pos)
+        if tile.unit == 4:
+            scr.blit(loaded.zoomimgs[22][zindex], pos)
+
+def render_hover (scr, gst, loaded, opt, com):
+    z = (gst.zoom*0.1)+1
+    zinverse = 1/z
+    if gst.hover == 1:
+        if com.mousepos[0] > opt.res[0]-200:
+            size = int(160), int(160)
+            pos = com.mousepos[0]-size[0]/2, com.mousepos[1]-size[1]/2
+        else:
+            size = int(160*z), int(160*z)
+            abspos = zoom_to_abs(com.mousepos, gst.rel, gst.zoom, opt.res)
+            pos = abspos[0]-size[0]/2*(zinverse), \
+                  abspos[1]-size[1]/2*(zinverse)
+            pos = abs_to_zoom(pos, gst.rel, gst.zoom, opt.res)
+        new = pygame.transform.smoothscale(loaded.imgs[7+1], size)
+        scr.blit(new, pos)
+        
+    if gst.hover == 2:
+        if com.mousepos[0] > opt.res[0]-200:
+            size = int(160), int(160)
+            pos = com.mousepos[0]-size[0]/2, com.mousepos[1]-size[1]/2
+        else:
+            size = int(160*z), int(160*z)
+            abspos = zoom_to_abs(com.mousepos, gst.rel, gst.zoom, opt.res)
+            pos = abspos[0]-size[0]/2*(zinverse),\
+                  abspos[1]-size[1]/2*(zinverse)
+            pos = abs_to_zoom(pos, gst.rel, gst.zoom, opt.res)
+        new = pygame.transform.smoothscale(
+            loaded.imgs[7+(gst.tiles[gst.sel].strenght-1)*3+1], size)
+        scr.blit(new, pos)
+        
+    if gst.hover == 3:
+        if com.mousepos[0] > opt.res[0]-200:
+            size = int(160), int(160)
+            pos = com.mousepos[0]-size[0]/2, com.mousepos[1]-size[1]/2
+        else:
+            size = int(160*z), int(160*z)
+            abspos = zoom_to_abs(com.mousepos, gst.rel, gst.zoom, opt.res)
+            pos = abspos[0]-size[0]/2*(zinverse),\
+                  abspos[1]-size[1]/2*(zinverse)
+            pos = abs_to_zoom(pos, gst.rel, gst.zoom, opt.res)
+        new = pygame.transform.smoothscale(
+            loaded.imgs[22], size)
+        scr.blit(new, pos)
+
+def render(scr, com, gst, loaded, opt, acc, peer):
+    render_map(scr, gst, loaded, opt)
+    render_sidebar(scr, gst, loaded, opt)
+    render_sidebar_town(scr, gst, loaded, opt)
+    render_hover(scr, gst, loaded, opt, com)
+    pygame.display.flip()
+    scr.fill((30, 30, 30))
+
+def create_map (gst, size, off):
+    norm = lambda g: [g[0], g[1]]
+    
+    gst.tiles = list()
+    sequence = list()
+    ts = 54
+    c, s = [math.cos(math.pi/3)*ts, math.sin(math.pi/3)*ts]
+    direction = [
+        [ts, 0],
+        [c, -s],
+        [-c, -s],
+        [-ts, 0],
+        [-c, s],
+        [c, s],
+    ]
+    # z = x - y
+    griddir = [
+        [1, 0],
+        [0, 1],
+        [-1, 1],
+        [-1, 0],
+        [0, -1],
+        [1, -1],
+    ]
+    
+    t=1; e=0; f=2
+    for i in range(0, size):
+        if e>=t*6: t+=1; e=0; f=1
+        if e==0: sequence += [0]
+        else:
+            sequence += [f%6]
+            if e%t==t-1: f+=1
+        e+=1
+    pos = [off[0], off[1]]
+    grid = [0, 0]
+    for i in range(0, size):
+        tile = Tile()
+        tile.owner = random.randint(0, len(gst.players)-1)
+        tile.pos[0] = pos[0]
+        tile.pos[1] = pos[1]
+        tile.grid = norm(grid)
+        gst.tiles.append(tile)
+        pos[0] += direction[sequence[i]][0]
+        pos[1] += direction[sequence[i]][1]
+        grid[0] += griddir[sequence[i]][0]
+        grid[1] += griddir[sequence[i]][1]
+
+    # precalculate neighbours
+    for i in range(0, size):
+        gst.tiles[i].neighbours = prec_get_neighbours(gst, i)
+
+    # populate map
+    for i in range(0, size):
+        tile = gst.tiles[i]
+        zone = get_zone(gst, i)
+        flag = True
+        for z in zone:
+            if gst.tiles[z].unit == 1: flag = False
+        if flag and len(zone)>1:
+            capital = random.choice(zone)
+            gst.tiles[capital].unit = 1
+            gst.tiles[capital].strenght = 1
+            gst.tiles[capital].savings = 8
+            gst.tiles[capital].upkeep = 0
+            gst.tiles[capital].income = calculate_income(gst, capital)
+            gst.tiles[capital].money = calculate_balance(gst, capital)
+
+def color_img (img, color):
+    new = pygame.Surface(img.get_size()).convert_alpha()  
+    new.fill((color[0], color[1], color[2], 255))
+    new.blit(img, (0,0), None, pygame.BLEND_RGBA_MIN)
+    #new.fill((color[0], color[1], color[2], 0), None, pygame.BLEND_RGBA_ADD)
+    return new
+
+def refresh_zoom (loaded, gst):
+    del loaded.zoomimgs[:]
+    del loaded.zoomcolorimgs[:]
+    del loaded.zoomcolorhouse[:]
+    zooms = []
+    for i in range(-5, 1):
+        z = (i*0.1)+1
+        zinverse = 1/z
+        zooms += [z]
+    # units
+    for i in range(0, len(loaded.imgs)):
+        loaded.zoomimgs += [[]]
+        for zoom in zooms:
+            oldsize = loaded.imgs[i].get_size()
+            size = int(oldsize[0]*zoom), int(oldsize[1]*zoom)
+            new = pygame.transform.smoothscale(loaded.imgs[i], size)
+            loaded.zoomimgs[-1] += [new]
+    # tiles
+    for imgtile in loaded.imgcolortile:
+        loaded.zoomcolorimgs += [[]]
+        for zoom in zooms:
+            oldsize = imgtile.get_size()
+            size = int(oldsize[0]*zoom), int(oldsize[1]*zoom)
+            new = pygame.transform.smoothscale(imgtile, size)
+            loaded.zoomcolorimgs[-1] += [new] 
+    # houses
+    size = int(160*z), int(160*z)
+    for imghouse in loaded.imgcolorhouse:
+        loaded.zoomcolorhouse += [[]]
+        for zoom in zooms:
+            oldsize = imghouse.get_size()
+            size = int(oldsize[0]*zoom), int(oldsize[1]*zoom)
+            new = pygame.transform.smoothscale(imghouse, size)
+            loaded.zoomcolorhouse[-1] += [new]
+
+def refresh_colors (loaded, gst):
+    del loaded.imgcolortile[:]
+    for pl in gst.players:
+        loaded.imgcolortile.append(color_img(loaded.imgs[0], pl.color))
+    for pl in gst.players:
+        col = [(pl.color[i]+256)/2 for i in range(3)]
+        loaded.imgcolortile.append(color_img(loaded.imgs[0], col))
+    for pl in gst.players:
+        col = [(pl.color[i]+128)/2 for i in range(3)]
+        loaded.imgcolorhouse.append(color_img(loaded.imgs[23], col))
+
+def load (loaded):
+    loaded.imgs.append(pygame.image.load("./imgs/hex.png").convert_alpha())
+    for i in range(6):
+        loaded.imgs.append(pygame.image.load(
+            "./imgs/hexframe"+str(i+1).zfill(4)+".png").convert_alpha())
+    for i in range(4):
+        loaded.imgs.append(pygame.image.load(
+            "./imgs/doode"+str(i).zfill(4)+"idle.png").convert_alpha())
+        loaded.imgs.append(pygame.image.load(
+            "./imgs/doode"+str(i).zfill(4)+"drag.png").convert_alpha())
+        loaded.imgs.append(pygame.image.load(
+            "./imgs/doode"+str(i).zfill(4)+"done.png").convert_alpha())
+    loaded.imgs.append(pygame.image.load("./imgs/house.png").convert_alpha())
+    loaded.imgs.append(pygame.image.load("./imgs/tomb.png").convert_alpha())
+    loaded.imgs.append(pygame.image.load("./imgs/tree.png").convert_alpha())
+    loaded.imgs.append(pygame.image.load("./imgs/castle.png").convert_alpha())
+    loaded.imgs.append(pygame.image.load("./imgs/housecolor.png").convert_alpha())
+    loaded.imgs.append(pygame.image.load("./imgs/photo.png").convert_alpha())
+    loaded.font = pygame.font.Font("./cont/OpenSans-Light.ttf", 18)
+    loaded.fonttitle = pygame.font.Font("./cont/OpenSans-Light.ttf", 36)
+
+def generate_request (gst, opt, peer):
+    act = Action(6)
+    if len(peer.requestqueue) > 0:
+        act = peer.requestqueue[0]
+        del peer.requestqueue[0]
+    if peer.passedturn:
+        act = Action(9)
+        act.movesstart = len(gst.register)-len(peer.turnmoves)
+        act.movesend = act.movesstart+len(peer.turnmoves)
+        act.moves = peer.turnmoves
+        peer.requestqueue.append(act)
+    return act
+
+def apply_data (gst, opt, peer, act):
+    if act.protocol == 7:
+        if len(gst.register) < act.registerlenght:
+            newact = Action(8)
+            newact.movesstart = len(gst.register)
+            newact.movesend = newact.movesstart\
+                +min(10, act.registerlenght-len(gst.register))
+            peer.requestqueue += [newact]
+    if act.protocol == 9:
+        if act.movesstart == len(gst.register):
+            # actuator
+            actuate(gst, act.moves)
+            gst.register += act.moves
+    if act.protocol == 10:
+        peer.passedturn = False
+        del gst.moves[:]
+            
+def net_client_process (gst, opt, peer, acc):
+    if peer.packettimer < acc:
+        peer.packettimer = acc+opt.lag
+        act = generate_request(gst, opt, peer)
+        data = act_encode(act)
+        peer.clientSock.sendto(data, peer.hostAddr)
+    try:
+        data, addr = peer.clientSock.recvfrom(256)
+        recvact = act_decode(data)
+        print("recvd: "+str(recvact))
+        peer.hostAddr = addr
+        apply_data(gst, opt, peer, recvact)
+    except BlockingIOError: pass
+    except: traceback.print_exc()
+
+def net_host (gst, opt, peer):
+    peer.hostSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    peer.hostSock.bind(("", 34555))
+    peer.hostSock.setblocking(False)
+    print("opened host")
+    if len(gst.players) == 0:
+        pl = Player()
+        pl.color = hsv_to_rgb(peer.lobbycolorangle/math.pi*180)
+        gst.players.append(pl)
+
+def net_host_process (gst, opt, peer):
+    try:
+        data, addr = peer.hostSock.recvfrom(256)
+        recvact = act_decode(data)
+        print(addr, ("recvdata host: " +str(recvact)))
+        if recvact.protocol == 0:
+            newact = Action(1)
+            newact.playerindex = len(gst.players)
+            newdata = act_encode(newact)
+            peer.hostSock.sendto(newdata, addr)
+            pl = Player()
+            pl.color = recvact.color_r, recvact.color_g, recvact.color_b
+            gst.players.append(pl)
+        if recvact.protocol == 2:
+            newact = Action(3)
+            newact.playernum = len(gst.players)
+            newact.starting = peer.start
+            newact.mapseed = peer.mapseed
+            newact.mapsize = peer.mapsize
+            newact.mapindex = peer.mapindex
+            newdata = act_encode(newact)
+            peer.hostSock.sendto(newdata, addr)
+        if recvact.protocol == 4:
+            newact = Action(5)
+            newact.playerindex = recvact.playerindex
+            newact.color_r = gst.players[recvact.playerindex].color[0]
+            newact.color_g = gst.players[recvact.playerindex].color[1]
+            newact.color_b = gst.players[recvact.playerindex].color[2]
+            newdata = act_encode(newact)
+            peer.hostSock.sendto(newdata, addr)
+        if recvact.protocol == 6:
+            newact = Action(7)
+            newact.registerlenght = len(gst.register)
+            newdata = act_encode(newact)
+            peer.hostSock.sendto(newdata, addr)
+        if recvact.protocol == 8:
+            newact = Action(9)
+            newact.movesstart = recvact.movesstart
+            newact.movesend = recvact.movesend
+            newact.moves += gst.register[newact.movesstart:newact.movesend]
+            newdata = act_encode(newact)
+            peer.hostSock.sendto(newdata, addr)
+        if recvact.protocol == 9:
+            if recvact.movesstart == len(gst.register):
+                actuate(gst, recvact.moves)
+                gst.register += recvact.moves
+            newact = Action(10)
+            newdata = act_encode(newact)
+            peer.hostSock.sendto(newdata, addr)
+    except BlockingIOError: pass
+    except:
+        traceback.print_exc()
+        peer.hostSock.close(); peer.hostSock = None
+
+def net_find (peer):
+    print("opened client")
+    peer.clientSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    peer.clientSock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    peer.clientSock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+    peer.clientSock.setblocking(False)
+    act = Action(0)
+    color = hsv_to_rgb(peer.lobbycolorangle/math.pi*180)
+    act.color_r = color[0]
+    act.color_g = color[1]
+    act.color_b = color[2]
+    data = act_encode(act)
+    peer.clientSock.sendto(data, ('255.255.255.255', 34555))
+    print("sent data "+str(data))
+
+def generate_lobby_request (peer, gst):    
+    act = Action(2)
+    if len(peer.requestqueue) > 0:
+        act = peer.requestqueue[0]
+        del peer.requestqueue[0]
+    return act
+
+def apply_lobby_data (peer, gst, act):
+    if act.protocol == 1:
+        peer.id = act.playerindex
+    if act.protocol == 3:
+        peer.playernum = act.playernum
+        peer.mapseed = act.mapseed
+        peer.mapsize = act.mapsize
+        peer.mapindex = peer.mapindex
+        for i in range(peer.playernum):
+            newact = Action(4)
+            newact.playerindex = i
+            peer.requestqueue += [newact]
+        if act.starting == 1:
+            peer.start = 1
+    if act.protocol == 5:
+        if act.playerindex >= len(gst.players):
+            while act.playerindex > len(gst.players):
+                gst.players.append(Player())
+            pl = Player()
+            pl.color = act.color_r, act.color_g, act.color_b
+            gst.players.append(pl)
+        else:
+            color = act.color_r, act.color_g, act.color_b
+            gst.players[act.playerindex].color = copy.copy(color)
+            
+def net_lobby_process (peer, opt, gst, acc):
+    if peer.hostAddr != None:
+        if peer.packettimer < acc:
+            peer.packettimer = acc+200
+            act = generate_lobby_request(peer, gst)
+            data = act_encode(act)
+            peer.clientSock.sendto(data, peer.hostAddr)
+    try:
+        data, addr = peer.clientSock.recvfrom(256)
+        recvact = act_decode(data)
+        print("recvd: "+str(recvact))
+        peer.hostAddr = addr
+        apply_lobby_data(peer, gst, recvact)
+    except BlockingIOError: pass
+    except:
+        traceback.print_exc()
+        peer.clientSock.close(); peer.clientSock = None
+
+def process_lobby (scr, com, gst, loaded, opt, acc, peer):
+    if peer.hostSock != None:
+        net_host_process(gst, opt, peer)
+    if peer.clientSock != None:
+        net_lobby_process(peer, opt, gst, acc)
+
+    if peer.start == 1:
+        peer.requestqueue = list()
+        refresh_colors(loaded, gst)
+        refresh_zoom(loaded, gst)
+        random.seed(peer.mapseed)
+        create_map(gst, peer.mapsize, [opt.res[0]/2, opt.res[1]/2])
+        return False
+    
+    tx, ty = opt.res[0]/2-300, opt.res[1]/2-225
+    bx, by = opt.res[0]/2+300, opt.res[1]/2+225
+    xm, ym = com.mousepos
+    if com.mouse[0] == 1:
+        if xm>tx+5 and xm<tx+300 and ym>ty+5 and ym<ty+25:
+            if opt.gamemode == 0:
+                peer.localplayers = copy.deepcopy(gst.players)
+                gst.players = copy.deepcopy(peer.hostplayers)
+                opt.gamemode = 1
+            elif opt.gamemode == 1 and False:
+                peer.hostplayers = copy.deepcopy(gst.players)
+                gst.players = copy.deepcopy(peer.localplayers)
+                opt.gamemode = 0
+
+        if opt.gamemode == 0:
+            if xm>tx+100 and xm<tx+130 and ym>ty+75 and ym<ty+95:
+                pl = Player()
+                pl.color = hsv_to_rgb(random.randint(1, 359))
+                gst.players.append(pl)
+            for i in range(len(gst.players)):
+                if xm>tx+12 and ym>ty+106+i*25 \
+                   and xm<tx+12+8 and ym<ty+106+i*25+8:
+                    del gst.players[i]; break
+            if xm>tx+280 and xm<tx+295 and ym>ty+50 and ym<ty+70:
+                if pygame.key.get_mods() & pygame.KMOD_LSHIFT:
+                    peer.mapsize = get_next_mapsize(peer.mapsize)
+                else: peer.mapsize += 1
+            if xm>tx+305 and xm<tx+320 and ym>ty+50 and ym<ty+70:
+                if pygame.key.get_mods() & pygame.KMOD_LSHIFT:
+                    peer.mapsize = get_prev_mapsize(peer.mapsize)
+                else: peer.mapsize -= 1
+            if xm>tx+(bx-tx)/2-50 and xm<tx+(bx-tx)/2+50 \
+               and ym>by-25 and ym<by:
+                # start local game
+                refresh_colors(loaded, gst)
+                refresh_zoom(loaded, gst)
+                create_map(gst, peer.mapsize, [opt.res[0]/2, opt.res[1]/2])
+                return False
+        if opt.gamemode == 1:
+            if peer.hostSock == None and peer.clientSock == None:
+                if xm>tx+10 and xm<tx+100 and ym>ty+30 and ym<ty+50:
+                    # host game
+                    net_host(gst, opt, peer)
+                if xm>tx+10 and xm<tx+100 and ym>ty+50 and ym<ty+70:
+                    # find host
+                    net_find(peer)
+                if xm>tx+280 and xm<tx+295 and ym>ty+50 and ym<ty+70:
+                    if pygame.key.get_mods() & pygame.KMOD_LSHIFT:
+                        peer.mapsize = get_next_mapsize(peer.mapsize)
+                    else: peer.mapsize += 1
+                if xm>tx+305 and xm<tx+320 and ym>ty+50 and ym<ty+70:
+                    if pygame.key.get_mods() & pygame.KMOD_LSHIFT:
+                        peer.mapsize = get_prev_mapsize(peer.mapsize)
+                    else: peer.mapsize -= 1
+            if xm>tx+(bx-tx)/2-50 and xm<tx+(bx-tx)/2+50 \
+               and ym>by-25 and ym<by and peer.hostSock != None:
+                # start multiplayer game
+                peer.start = 1
+                
+    if com.mouse[0] > 1 and opt.gamemode != 1:
+        dx = (bx-30)-xm; dy = (ty+30)-ym
+        if dx*dx+dy*dy < 30*30:
+            peer.lobbycolorangle = math.atan2(dy, dx)+math.pi
+            color = hsv_to_rgb(peer.lobbycolorangle/math.pi*180)
+            peer.lobbycolor = color
+            gst.players[0].color = color
+            
+    return True
+    
+def render_lobby (scr, com, gst, loaded, opt, acc, peer):
+    tx, ty = opt.res[0]/2-300, opt.res[1]/2-225
+    bx, by = opt.res[0]/2+300, opt.res[1]/2+225
+
+    # BACKGROUND
+    if ty > 40:
+        title = loaded.fonttitle.render("SLAY", 4,(255, 255, 255))
+        scr.blit(title, (tx+(bx-tx)/2-title.get_width()/2, ty-50))
+    if tx > 0:
+        color = hsv_to_rgb(peer.lobbycolorangle/math.pi*180)
+        for i in range(0, int(tx/6)):
+            x = tx%6+i*6
+            a = math.sin(acc*0.001+i)*min(i*i*0.2, 150)
+            p = x, a+opt.res[1]/2; q = x, -a+opt.res[1]/2
+            col = [color[c]*(i/int(tx/6)) for c in range(3)]
+            pygame.draw.line(scr, col, p, q)
+        for j in range(0, int(tx/6)):
+            i = int(tx/6)-j
+            x = tx%6-i*6+opt.res[0]
+            a = math.sin(acc*0.001+i)*min(i*i*0.2, 150)
+            p = x, a+opt.res[1]/2; q = x, -a+opt.res[1]/2
+            col = [color[c]*(i/int(tx/6)) for c in range(3)]
+            pygame.draw.line(scr, col, p, q)
+        
+    
+    pygame.draw.rect(scr, (255, 255, 255), (tx, ty, bx-tx, by-ty), 0)
+    pygame.draw.rect(scr, (100, 100, 100), (tx, ty, bx-tx, by-ty), 1)
+
+    scr.blit(loaded.imgs[24], (bx-370, by-400))
+
+    color = hsv_to_rgb(peer.lobbycolorangle/math.pi*180)
+    pygame.gfxdraw.filled_circle(scr, int(bx-30), int(ty+30), 20, color)
+    pygame.gfxdraw.aacircle(scr, int(bx-30), int(ty+30), 20, (0, 0, 0))
+    pos = [bx-30, ty+30]
+    pos[0] += math.cos(peer.lobbycolorangle)*19.5
+    pos[1] += math.sin(peer.lobbycolorangle)*19.5
+    pygame.gfxdraw.line(scr, int(bx-30), int(ty+30),
+        int(pos[0]), int(pos[1]), (0,0,0))
+
+    scr.blit(loaded.font.render("GAMEMODE:", 4,(0,0,0)), (tx+10, ty+5))
+    if opt.gamemode == 0:
+        scr.blit(loaded.font.render(
+            "LOCAL", 4,(0,0,0)), (tx+120, ty+5))
+    if opt.gamemode == 1:
+        scr.blit(loaded.font.render(
+            "ONLINE (multiplayer only)", 4,(0,0,0)), (tx+120, ty+5))
+
+    if opt.gamemode == 1:
+        if peer.hostSock == None and peer.clientSock == None:
+            scr.blit(loaded.font.render(
+                "HOST", 4,(0,0,0)), (tx+10, ty+30))
+            scr.blit(loaded.font.render(
+                "FIND", 4,(0,0,0)), (tx+10, ty+50))
+            scr.blit(loaded.font.render(
+                "[+]", 4,(0,0,0)), (tx+280, ty+50))
+            scr.blit(loaded.font.render(
+                "[-]", 4,(0,0,0)), (tx+305, ty+50))
+        txt = "RANDOM MAP (SEED= "+str(peer.mapseed)+")"
+        scr.blit(loaded.font.render(
+            txt, 4,(0,0,0)), (tx+200, ty+30))
+        scr.blit(loaded.font.render(
+            "MAP SIZE", 4,(0,0,0)), (tx+200, ty+50))
+        col = (30,130,0) if calc_good_mapsize(peer.mapsize) else (0,0,0)
+        scr.blit(loaded.font.render(
+            str(peer.mapsize), 4,col), (tx+330, ty+50))
+
+    if opt.gamemode == 0:
+        scr.blit(loaded.font.render(
+            "PLAYERS", 4,(0,0,0)), (tx+10, ty+75))
+        scr.blit(loaded.font.render(
+            "ADD", 4,(0,0,0)), (tx+100, ty+75))
+        scr.blit(loaded.font.render(
+            "[+]", 4,(0,0,0)), (tx+280, ty+50))
+        scr.blit(loaded.font.render(
+            "[-]", 4,(0,0,0)), (tx+305, ty+50))
+        scr.blit(loaded.font.render(
+            "MAP SIZE", 4,(0,0,0)), (tx+200, ty+50))
+        col = (30,130,0) if calc_good_mapsize(peer.mapsize) else (0,0,0)
+        scr.blit(loaded.font.render(
+            str(peer.mapsize), 4,col), (tx+330, ty+50))
+        
+    for i in range(0, len(gst.players)):
+        if i == peer.id:
+            scr.blit(loaded.font.render(
+                "YOU", 4,(0,0,0)), (tx+52, ty+98+i*25))
+        elif gst.players[i].mind == 0:
+            scr.blit(loaded.font.render(
+                "HUMAN", 4,(0,0,0)), (tx+52, ty+98+i*25))
+            
+        pygame.draw.rect(scr, gst.players[i].color,
+            (tx+25, ty+100+i*25, 20, 20))
+        pygame.draw.rect(scr, (0,0,0),
+            (tx+25, ty+100+i*25, 20, 20), 1)
+
+        pygame.draw.rect(scr, (200,200,200),
+            (tx+12, ty+106+i*25, 8, 8))
+        pygame.draw.line(scr, (40,40,40),
+            (tx+12+2, ty+106+i*25+2), (tx+12+5, ty+106+i*25+5))
+        pygame.draw.line(scr, (40,40,40),
+            (tx+12+5, ty+106+i*25+2), (tx+12+2, ty+106+i*25+5))
+        pygame.draw.rect(scr, (0,0,0),
+            (tx+12, ty+106+i*25, 8, 8), 1)
+    
+    scr.blit(loaded.font.render("START", 4,(0,0,0)), (tx+(bx-tx)/2, by-25))
+    
+    pygame.display.flip()
+    scr.fill((30, 30, 30))
+
+def main():
+    opt = Opt() #
+    
+    pygame.init()
+    displayflags = pygame.HWACCEL|pygame.DOUBLEBUF|pygame.RESIZABLE
+    scr = pygame.display.set_mode(opt.res, displayflags)
+
+    com = Commands() #
+    loaded = Loaded() #
+    gst = Gamestate() #
+    peer = LocalPeer() #
+
+    pl = Player(); pl.color = [255, 0, 0]; gst.players.append(pl)
+    pl = Player(); pl.color = [255, 255, 0]; gst.players.append(pl)
+    pl = Player(); pl.color = [255, 150, 0]; gst.players.append(pl)
+    pl = Player(); pl.color = [0, 255, 0]; gst.players.append(pl)
+    pl = Player(); pl.color = [255, 0, 255]; gst.players.append(pl)
+
+    load(loaded)
+    peer.lobbycolorangle = random.random()*(math.pi*2)
+    peer.mapseed = random.randint(0, 1024*1024*1024)
+    peer.mapsize = 1+6+12+18+24+30+36+42
+
+    clock = pygame.time.Clock()
+    acc = 0; lobby = True
+    run = True
+    while run:
+        tick = clock.tick(60)
+        acc += tick
+
+        run = com.update()
+        if opt.res != com.res:
+            opt.res = com.res
+            scr = pygame.display.set_mode(opt.res, displayflags)
+        if lobby:
+            lobby = process_lobby(scr, com, gst, loaded, opt, acc, peer)
+            render_lobby(scr, com, gst, loaded, opt, acc, peer)
+        else:
+            process(scr, com, gst, loaded, opt, acc, peer)
+            render(scr, com, gst, loaded, opt, acc, peer)
+
+    pygame.quit()
+
+try: main()
+except: pygame.quit(); traceback.print_exc(); input()
-- 
cgit v1.2.3-54-g00ecf