def draw(self, canvas: draw.Canvas):
"""
Draws every tile (and its contents) in correct order.
"""
scr_w, scr_h = canvas.get_size()
for y in range(self.h):
for x in range(self.w):
tile = self.data[x][y]
draw_x, draw_y = Tile.to_screen_coords(x, y, tile.z)
real_x, real_y = canvas.transform[-1].position(draw_x, draw_y)
if real_x < -Tile.tile_w or real_x > scr_w + Tile.tile_w \
or real_y < -Tile.tile_h or real_y > scr_h + Tile.tile_h:
continue
frame = Tile.image.get_frame(tile.type)
canvas.paint(frame, draw_x, draw_y)
if tile.object is not None:
canvas.save()
canvas.translate(draw_x + Tile.tile_w / 2,
draw_y + Tile.tile_h / 2)
canvas.paint(tile.object)
canvas.restore()
canvas.set_color_rgb(255, 0, 255)
class Main(State):
def __init__(self, engine: Engine):
self.engine = engine
self.canvas = Canvas(engine.get_renderer())
shared.world.Tile.init_graphics(self.canvas)
shared.world.Object.init_graphics(self.canvas)
self.connection = None
self.thread = None
self.network = ServerNetwork(CaveWorldProtocol())
self.network.bind({
ClientConnected: self.on_client_connected,
ClientDisconnected: self.on_client_disconnected,
client.Introduction: self.on_client_introduction,
actor.ActorRequest: self.on_actor_request,
world.DataRequest: self.on_world_request
})
self.turn_manager = TurnManager(self)
self.world = World(self.canvas, 32, 32)
self.world.generate()
def on_client_introduction(self, message, client):
print("Client introduction!")
print("message: ", message)
def on_client_connected(self, message, client):
print("Client connected!", client)
def on_client_disconnected(self, message, client):
print("Client disconnected!", client)
if "actor" in client:
self.turn_manager.unregister_client(client)
if not client["actor"].detach():
print("Error detaching actor!")
self.network.broadcast(self.world.construct_world_data_response())
def on_world_request(self, message, client):
print('Client', client, 'requests world data!')
self.network.send_to(client,
self.world.construct_world_data_response())
def on_actor_request(self, message, client):
from random import randint
while True:
x, y = randint(0, self.world.w - 1), randint(0, self.world.h - 1)
if self.world.data[int(x)][int(y)].object is None:
break
from server.actor import CaveMan
actor = CaveMan(client, self.world)
actor.x = x
actor.y = y
client["actor"] = actor
print("Created actor at", x, y)
actor.attach()
self.turn_manager.register_actor(actor)
self.network.broadcast(self.world.construct_world_data_response())
def host(self, address, port):
self.network.host(address, port)
def update(self, dt):
self.network.process()
def draw(self):
self.canvas.set_color_rgb(0, 0, 0)
self.canvas.clear()
self.canvas.save()
self.canvas.set_scale(3, 3)
self.canvas.translate(512, 512)
x, y = self.engine.mouse_position()
self.canvas.translate(-x * 2, -y * 2)
self.world.draw(self.canvas)
self.canvas.restore()
def key_pressed(self, key):
pass
def key_released(self, key):
pass
def mouse_pressed(self, x, y, button):
pass
def mouse_released(self, x, y, button):
pass
class Main(State):
def __init__(self, engine: Engine):
self.engine = engine
self.canvas = Canvas(engine.get_renderer())
shared.world.Tile.init_graphics(self.canvas)
shared.world.Object.init_graphics(self.canvas)
self.network = ClientNetwork(CaveWorldProtocol())
self.network.bind({
Connected: self.on_connected,
Disconnected: self.on_disconnected,
actor.ActorResponse: self.on_actor_response,
actor.PrepareTurnRequest: self.on_prepare_turn_request,
world.DataResponse: self.on_world_data_response,
})
self.world = World(self.canvas, 0, 0)
self.actor = None
def connect(self, address, port):
self.network.connect(address, port)
def on_connected(self, message):
print("Successfully connected!!!")
self.network.send(client.Introduction(name="foo"))
self.network.send(world.DataRequest())
self.network.send(actor.ActorRequest(type="caveman"))
def on_disconnected(self, message):
print("Disconnected from the server...")
def on_world_data_response(self, message):
print("World data from server")
self.world.new(message.width, message.height)
for x, row in enumerate(message.tiles):
for y, tile in enumerate(row):
self.world.data[x][y] = Tile(tile.type, tile.z)
if tile.object:
self.world.data[x][y].object = Object(
representation=tile.object.repr)
def on_actor_response(self, message):
print("Actor response!")
pass
def on_prepare_turn_request(self, message):
print("Prepare turn request!", message.as_dict())
pass
def update(self, dt):
self.network.process()
def draw(self):
self.canvas.set_color_rgb(32, 32, 32)
self.canvas.clear()
self.canvas.save()
self.canvas.set_scale(3, 3)
self.canvas.translate(512, 512)
x, y = self.engine.mouse_position()
self.canvas.translate(-x * 2, -y * 2)
self.world.draw(self.canvas)
self.canvas.restore()
def key_pressed(self, key):
pass
def key_released(self, key):
pass
def mouse_pressed(self, x, y, button):
pass
def mouse_released(self, x, y, button):
pass