From 7521d7b4abce6cac30ac37cc030669f49c291ba0 Mon Sep 17 00:00:00 2001 From: Joscha Date: Wed, 5 Apr 2017 19:44:21 +0000 Subject: [PATCH] Make map display empty squares --- chunks.py | 18 +++++++++- client.py | 28 ++++++++++----- maps.py | 100 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- utils.py | 18 ++++++++++ 4 files changed, 153 insertions(+), 11 deletions(-) create mode 100644 utils.py diff --git a/chunks.py b/chunks.py index 5a4ec2d..80bf976 100644 --- a/chunks.py +++ b/chunks.py @@ -1,3 +1,5 @@ +import threading + class ChunkDiff(): """ Represents differences between two chunks (changes to be made to a chunk). @@ -24,4 +26,18 @@ class ChunkPool(): Load chunks it doesn't know. """ - pass + def __init__(self): + self._lock = threading.RLock() + + def __enter__(self): + self._lock.acquire() + return self + + def __exit__(self, type, value, tb): + self._lock.release() + + def load_list(self, coords): + pass + + def get(self, x, y): + pass diff --git a/client.py b/client.py index d049d9f..b710fa8 100644 --- a/client.py +++ b/client.py @@ -1,23 +1,35 @@ +import curses import sys import threading +from maps import Map +from chunks import ChunkPool # import fron chunks, maps, clientchunkpool class Client(): def __init__(self, address): self.address = address - self.clock = threading.RLock() - #self.pool = Chunkpool() + self.pool = ChunkPool() #self.map_ = Map(sizex, sizey, self.pool) #self.chunkmap = Chunkmap(sizex, sizey, self.pool) # size changeable by +/-? #self.sock = socket.Socket(...) - def launch(self): - # try to connect - # launch socket thread - # update display - # -> launch input thread + def launch(self, stdscr): + sizey, sizex = stdscr.getmaxyx() + self.map_ = Map(sizex, sizey, self.pool) + + stdscr.noutrefresh() + self.map_.draw() + curses.doupdate() + stdscr.getkey() + self.map_.worldx += 1 + self.map_.cursorx += 2 + self.map_.cursory += 1 + stdscr.noutrefresh() + self.map_.draw() + curses.doupdate() + stdscr.getkey() def get_input(self, scr): pass @@ -32,7 +44,7 @@ def main(argv): return client = Client(argv[1]) - client.launch() + curses.wrapper(client.launch) if __name__ == "__main__": main(sys.argv) diff --git a/maps.py b/maps.py index 8bd833a..a0b6896 100644 --- a/maps.py +++ b/maps.py @@ -1,10 +1,93 @@ +import curses +import math +from utils import CHUNK_HEIGHT, CHUNK_WIDTH, chunkx, chunky, inchunkx, inchunky, Position + +import sys + class Map(): """ A map which displays chunks and a cursor on the screen. Allows for user to modify chunks in an intuitive way. """ - pass + def __init__(self, width, height, chunkpool): + self.worldx = 0 + self.worldy = 0 + self.cursorx = 0 + self.cursory = 0 + self.chunkpreload = 0 + + self.chunkpool = chunkpool + + self._pad = curses.newpad(5, 5) + self.resize(width, height) + + def draw(self): + with self.chunkpool as pool: + for x in range(chunkx(self.width) + 1): + for y in range(chunky(self.height) + 1): + chunk = pool.get(x+chunkx(self.worldx), y+chunky(self.worldy)) + if chunk: + chunk.draw_to(x*CHUNK_WIDTH, y*CHUNK_HEIGHT, self._pad) + else: + self.draw_empty_to(x*CHUNK_WIDTH, y*CHUNK_HEIGHT) + + # set cursor position in world + self._pad.move( + self.cursory - chunky(self.worldy)*CHUNK_HEIGHT, + self.cursorx - chunkx(self.worldx)*CHUNK_WIDTH + ) + + #sys.stderr.write("{} {} 0 0 {} {} | {} {}\n".format(inchunky(self.worldy), inchunkx(self.worldx), self.height, self.width, self.py, self.px)) + self._pad.noutrefresh(inchunky(self.worldy), inchunkx(self.worldx), 0, 0, self.height-1, self.width-1) + #self._pad.noutrefresh(0, 0, 0, 0, 10, 10) + + def draw_empty_to(self, x, y): + if False and curses.has_colors(): + curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE) + for dy in range(CHUNK_HEIGHT): + self._pad.addstr(y+dy, x, " "*CHUNK_WIDTH, curses.color_pair(1)) + else: + for dy in range(CHUNK_HEIGHT): + s = "."*(CHUNK_WIDTH) + #sys.stderr.write("Writing {!r} at {} {} ownsize {} {}\n".format(s, x, y+dy, self.px, self.py)) + self._pad.addstr(y+dy, x, s) + + def resize(self, width, height): + self.width = width + self.height = height + + self._pad.resize( + (chunky(height) + 1)*CHUNK_HEIGHT, + (chunkx(width) + 1)*CHUNK_WIDTH + 1 # workaround for addwstr issue when drawing + ) + + with self.chunkpool as pool: + pool.load_list(self.visible_chunk_coords()) + + def visible_chunk_coords(self): + coords = [] + + xstart = chunkx(self.worldx) - self.chunkpreload + ystart = chunky(self.worldy) - self.chunkpreload + xend = xstart + chunkx(self.width) + 1 + 2*self.chunkpreload + yend = ystart + chunky(self.height) + 1 + 2*self.chunkpreload + + for x in range(xstart, xend): + for y in range(ystart, yend): + coords.append(Position(x, y)) + + return coords + + def write(self, char): + pass + + def move_cursor(self, dx, dy): + pass + + def scroll(self, dx, dy): + pass + class ChunkMap(): """ @@ -12,4 +95,17 @@ class ChunkMap(): Might show additional details too (i.e. if a chunk has been modified). """ - pass + def __init__(self, chunkpool): + self.cpool = chunkpool +# +# def draw(self): +# pass +# +# def resize(self, size): +# pass +# + def move(self, x, y, corner): + pass + + def toggle(self): + pass diff --git a/utils.py b/utils.py new file mode 100644 index 0000000..8e754f8 --- /dev/null +++ b/utils.py @@ -0,0 +1,18 @@ +from collections import namedtuple + +Position = namedtuple("Position", "x y") + +CHUNK_WIDTH = 16 +CHUNK_HEIGHT = 8 + +def chunkx(value): + return value//CHUNK_WIDTH + +def chunky(value): + return value//CHUNK_HEIGHT + +def inchunkx(value): + return value%CHUNK_HEIGHT + +def inchunky(value): + return value%CHUNK_WIDTH