def __init__(self):
self._pygame_init()
self.input_handler = InputHandler()
self.drawer = Drawer(self.screen)
self.camera = Camera(self.drawer, self.screen_width,
self.screen_height)
self.input_handler.add_subscriber(EventName.QUIT, self)
self.input_handler.add_subscriber(EventName.ESCAPE, self)
self.input_handler.add_subscriber(EventName.SPACE, self)
self.input_handler.add_subscriber(EventName.RETURN, self)
self.input_handler.add_subscriber(EventName.UP, self)
self.input_handler.add_subscriber(EventName.DOWN, self)
self.input_handler.add_subscriber(EventName.LEFT, self)
self.input_handler.add_subscriber(EventName.RIGHT, self)
self.input_handler.add_subscriber(EventName.MOUSEMOTION, self)
self.input_handler.add_subscriber(EventName.MOUSEMOTIONUP, self)
self.input_handler.add_subscriber(EventName.MOUSEBUTTONUP, self)
self.input_handler.add_subscriber(EventName.MOUSEBUTTONDOWN, self)
self.running = True
self.rickmorty = pygame.image.load("assets/images/rickmorty3.jpeg")
# .convert_alpha()
self.transformrick = 0
self.startx = 0
self.starty = 0
self.screen.fill(0xeeeeee)
self.game_surface.fill(0xaaaaaa)
pygame.draw.rect(self.game_surface, 0xffffff, (10, 50, 100, 200))
pygame.draw.rect(self.game_surface, 0xff0000, (50, 60, 10, 20))
self.game_surface.blit(self.rickmorty, (0, 0))
def __init__(self):
pg.init()
pg.mouse.set_cursor(*CURSOR)
self._camera = Camera()
self._hotbar = Hotbar()
self._world = World()
self._main_player = Player("main_player",
spawn_pos=PLAYER_DEFAULT_SPAWN_POS)
self._action = GameAction.play
def __init__(self, window, input_handler):
super(GameScreen, self).__init__()
self.window = window
self.input_handler = input_handler
self.camera = Camera(window)
self.render = Render(self.camera, self.window)
sc_batch = self.render.scene_batch
st_batch = self.render.static_batch
self.player = player.Player(renderhook=self.render.playerhook)
self.proj_viewer = ProjectileViewer(
self.send_center, batch=sc_batch, scale=self.render.scale,
rndhook=self.render.attack)
self.controls = {}
self.controls_old = {}
self.map = Map('blank')
#self.player.spawn(100, 100)
self.time = 0
self.moves = moves(1024)
self.index = [0]
self.head = [0]
#other players
self.players = {}
self.specs = {}
#crosshair
self.cross = CrossHair(batch=st_batch)
self.isSpec = 0.5
self.hud = Hud(batch=st_batch, window=self.window)
self.gs_view = GameStateViewer(self.players, self.hud.update_prop,
self.hud.set_score)
self.frozen = False
self.rest_time = 0
def execute(self, game_data, gfx_data):
all_keys = game_data.map.num_keys_found == game_data.map.num_keys_total
if not all_keys:
num_remaining = game_data.map.num_keys_total - game_data.map.num_keys_found
text = "You haven't found all the keys on this level yet, {} keys left".format(
num_remaining)
game_data.map.stairs_found = True
result = [{"message": Message(text)}]
return self.package(result=result)
results = []
if game_data.run_planner.has_next:
if game_data.map.tutorial:
# re-set formulas after tutorial
game_data.formula_builder.run_tutorial = False
game_data.formula_builder.set_initial_slots()
game_data.player.caster.clear_cooldowns()
# reset shield
if game_data.player.fighter.shield:
game_data.player.fighter.shield = None
elif config.conf.keys:
results.append({"xp": game_data.player.level.xp_to_next_level})
game_data.prev_state.append(game_data.state)
game_data.prev_state.append(GameStates.FORMULA_SCREEN)
game_data.state = GameStates.STORY_SCREEN
game_data.map = game_data.run_planner.activate_next_level()
game_data.map.entities = game_data.map.entities
game_data.fov_map = initialize_fov(game_data.map)
game_data.fov_recompute = True
cam_width = min(game_data.map.width, gfx_data.camera.orig_width)
cam_height = min(game_data.map.height, gfx_data.camera.orig_height)
gfx_data.camera = Camera(cam_width, cam_height, game_data)
gfx_data.windows.activate_wnd_for_state(game_data.state, game_data,
gfx_data)
gfx_data.camera.initialize_map()
gfx_data.camera.center_on(game_data.player.pos.x,
game_data.player.pos.y)
game_data.stats.next_level()
results.append({"descended": True})
else:
game_data.prev_state.append(game_data.state)
game_data.state = GameStates.VICTORY
game_data.story.next_story()
gfx_data.windows.activate_wnd_for_state(game_data.state, game_data,
gfx_data)
game_data.stats.end_time = datetime.datetime.now()
results.append({"victory": True})
return self.package(results)
def game(self):
"""Creates a Game based on the state of the `self`"""
level_config = self._level_config_selector.get_selected()
game_input = GameInput(self._event_handler,
self._config.game_input_config)
game_notifications = []
plane_factories = []
start_positions = level_config.starting_locations()
for i in range(self._n_players):
game_notifications.append(
GameNotification(self._config.press_key_to_start_message,
self._config.until_spawn_message))
plane_factories.append(PlaneFactory(self._config.plane_config))
plane_factories[i].start_position = start_positions[i]
players = []
game_views = []
for i in range(self._n_players):
player_input_config = self._config.player_input_configs[i]
player_input = PlayerInput(game_input, player_input_config)
user = self.user_selectors[i].get_current()
spawn_timer = Timer(self._config.player_spawn_time)
players.append(
Player(plane_factories[i], player_input, game_notifications[i],
PlayerRecorder(user, Timer()), user, spawn_timer))
camera = Camera(self._config.game_camera_height)
font_color = self._config.game_view_font_color
game_views.append(GameView(players[-1], camera, font_color))
game_length = self._config.game_length
game_state = GameState(level_config.game_objects(), players,
level_config.name(), Timer(game_length))
background = GameBackground.from_config(self._config.background_config)
pause_overlay = PauseOverlay(self._config.pause_message,
self._config.pause_font_color,
self._config.pause_blur_radius)
info_bar = InfoBar(self._config.info_bar_level_message,
self._config.info_bar_time_left_message,
self._config.info_bar_font_color,
self._config.info_bar_background_color)
renderer = GameRenderer(self._screen, game_views, background,
pause_overlay, info_bar)
game_clock = Clock(self._config.game_fps, busy_wait, True)
game = Game(game_input, game_state, renderer, game_clock)
return game
def __init__(self, window):
super(GameScreen, self).__init__()
self.window = window
self.camera = Camera(window)
self.player = player.Player()
self.proj_viewer = ProjectileViewer(self.send_center)
self.controls = {}
self.controls_old = {}
self.map = Map('blank')
#self.player.spawn(100, 100)
self.time = 0
self.moves = moves(1024)
self.index = [0]
self.head = [0]
#other players
self.players = {}
self.specs = {}
#crosshair
self.cross = CrossHair()
self.isSpec = True
self.hud = Hud()
self.gs_view = GameStateViewer(self.players, self.hud.update_prop,
self.hud.set_score)
class GameScreen(Events):
"""docstring for GameScreen"""
def __init__(self, window):
super(GameScreen, self).__init__()
self.window = window
self.camera = Camera(window)
self.player = player.Player()
self.proj_viewer = ProjectileViewer(self.send_center)
self.controls = {}
self.controls_old = {}
self.map = Map('blank')
#self.player.spawn(100, 100)
self.time = 0
self.moves = moves(1024)
self.index = [0]
self.head = [0]
#other players
self.players = {}
self.specs = {}
#crosshair
self.cross = CrossHair()
self.isSpec = True
self.hud = Hud()
self.gs_view = GameStateViewer(self.players, self.hud.update_prop,
self.hud.set_score)
def update(self, dt):
dt = int(dt * 1000000) / 1000000.
if self.controls['esc'] and not self.controls_old['esc']:
self.send_message('menu_transition_+', (GameMenu, self.isSpec))
if self.controls['rdy'] and not self.controls_old['rdy']:
if not self.isSpec:
self.ready_up()
if self.controls['chat'] and not self.controls_old['chat']:
self.send_message('menu_transition_+',
(ChatScreen, self.window))
self.update_keys()
self.on_update(dt)
def update_physics(self, dt, state=False, input=False):
playergen = (player.rect for player in self.players.itervalues())
mapgen = (rect for rect in self.map.quad_tree.retrieve([],
self.player.rect))
rectgen = chain(playergen, mapgen)
self.player.update(dt, rectgen, state, input)
return self.player.state
def update_state_only(self, state):
self.player.state.update(0, state)
def update_keys(self):
for key_, value in self.controls.items():
self.controls_old[key_] = value
def from_server(self, data):
typ, data = data
if typ == proto.playerUpdate:
ind, time, s_state, inpt, weaponinfo = data
smove = move(time, inpt, s_state)
if ind == self.player.id:
correct_client(self.update_physics, smove, self.moves,
self.head, self.index[0],
self.update_state_only)
self.player.weapons.from_server(weaponinfo)
else:
#try:
self.players[ind].client_update(s_state)
self.players[ind].input = inpt
#except KeyError:
# pass
elif typ == proto.projectile:
self.proj_viewer.process_proj(data)
elif typ == proto.newPlayer:
gs, data = data
if gs == proto.goesSpec:
ind, name, colstring = data
new = player.Player()
new.name = name
new.id = ind
new.set_color(colstring)
self.specs[ind] = new
#if there are existing players on the server
elif gs == proto.wantsJoin:
ind, name, state, time, colstring = data
new = player.Player()
new.name = name
new.state = state
new.time = time
new.id = ind
new.set_color(colstring)
new.rect.update_color(new.color)
self.players[ind] = new
print 'new player: %s' % name
self.gs_view.to_team(ind)
elif typ == proto.disconnect:
ind = data
if ind in self.players:
self.gs_view.leave(ind)
del self.players[ind]
elif ind in self.specs:
del self.specs[ind]
elif typ == proto.stateUpdate:
gametime, data = data
gs, ind = data
self.gs_view.set_time(gametime)
if gs == proto.wantsJoin:
if ind == self.player.id:
self.send_message('menu_transition_-')
self.player.state.isDead = False
self.trans_to_game()
else:
self.players[ind] = self.specs[ind]
del self.specs[ind]
self.gs_view.to_team(ind)
elif gs == proto.goesSpec:
if ind == self.player.id and self.isSpec:
pass
elif ind == self.player.id and not self.isSpec:
self.send_message('menu_transition_-')
self.trans_to_spec()
else:
self.specs[ind] = self.players[ind]
self.gs_view.leave(ind)
del self.players[ind]
elif gs == proto.isDead:
ind, killer, weapon = ind
if ind == self.player.id:
self.player.die()
else:
self.players[ind].die()
self.gs_view.score(ind, killer, weapon)
elif gs == proto.spawns:
ind, pos = ind
if ind == self.player.id:
self.player.spawn(*pos)
else:
self.players[ind].spawn(*pos, other=True)
elif gs == proto.isReady:
ind, name = ind
self.gs_view.is_ready(ind, name)
elif gs == proto.countDown:
self.player.freeze()
elif gs == proto.inProgress:
self.gs_view.start_game()
elif gs == proto.warmUp:
self.gs_view.to_warmup()
elif typ == proto.mapUpdate:
ind, itemid, gt, spawn = data
self.gs_view.set_time(gt)
if ind == self.player.id:
if isinstance(self.map.items[itemid], Triangle):
st = self.map.items[itemid].keystr
if not st in self.player.weapons.weapons:
self.player.weapons.pickup(st)
else:
self.player.weapons.apply(st, self.player)
self.map.serverupdate(itemid, spawn)
elif typ == proto.chat:
ind, msg = data
if ind == self.player.id:
name = self.player.name
color = self.player.color
elif ind in self.players:
name = self.players[ind].name
color = self.players[ind].color
else:
name = self.specs[ind].name
color = self.specs[ind].color
#chatdata = ' '.join((name + ':', '\t', msg))
chatdata = (name, color, msg)
self.hud.update_prop(chat=chatdata)
def send_to_client(self, dt):
temp_input = proto.Input()
self.time += int(dt * 1000000)
temp_input.CopyFrom(self.player.input)
c_move = move(self.time, temp_input, self.player.state.copy())
try:
self.moves[self.index[0]] = c_move
except IndexError:
self.moves.append(c_move)
self.moves.advance(self.index)
self.send_message('input', (self.player.input, self.time))
def spec_send(self, dt):
self.send_message('input', (proto.Input(), self.time))
def draw(self):
self.on_draw()
def on_connect(self, msg):
ind, mapname, name = msg
self.player.get_id(ind, name)
self.map = Map(mapname)
print 'connected with id: ' + str(self.player.id)
#self.send_message('input', (self.player.input, 1337))
self.gs_view.init_self(ind)
self.trans_to_spec()
def try_join(self):
msg = proto.Message()
msg.type = proto.stateUpdate
plr = proto.Player()
plr.id = self.player.id
msg.player.CopyFrom(plr)
if self.isSpec:
msg.gameState = proto.wantsJoin
else:
msg.gameState = proto.goesSpec
self.send_message('other', msg)
def ready_up(self):
msg = proto.Message()
msg.type = proto.stateUpdate
plr = proto.Player()
plr.id = self.player.id
msg.player.CopyFrom(plr)
msg.gameState = proto.isReady
self.send_message('other', msg)
def send_chat(self, chatmsg):
msg = proto.Message()
msg.type = proto.chat
plr = proto.Player()
plr.id = self.player.id
plr.chat = chatmsg
msg.player.CopyFrom(plr)
self.send_message('other', msg)
def on_update(self, dt):
pass
def on_draw(self):
pass
def idle_update(self, dt):
self.send_to_client(dt)
self.gs_view.update(dt)
self.hud.update(dt)
def trans_to_spec(self):
self.on_update = self.spec_update
self.on_draw = self.spec_draw
self.isSpec = True
self.player.state.hook_hud(self.hud.update_prop)
self.hud.init_spec()
def trans_to_game(self):
self.on_update = self.game_update
self.on_draw = self.game_draw
self.isSpec = False
self.player.weapons.hook_hud(self.hud.update_prop)
self.player.state.hook_hud(self.hud.update_prop)
self.gs_view.add_self(self.player)
self.hud.init_player(self.players)
def game_update(self, dt):
self.update_physics(dt)
self.camera.update(dt, self.player.state)
self.send_to_client(dt)
self.proj_viewer.update(dt)
self.gs_view.update(dt)
self.hud.update(dt)
def game_draw(self):
self.camera.set_camera()
for plr in self.players.itervalues():
plr.draw()
self.player.draw()
self.proj_viewer.draw()
self.map.draw()
self.camera.set_static()
self.hud.draw()
self.cross.draw(*self.camera.mpos)
def spec_update(self, dt):
self.player.specupdate(dt)
self.camera.update(dt, self.player.state)
#self.send_to_client(dt)
self.spec_send(dt)
self.proj_viewer.update(dt)
self.gs_view.update(dt)
self.hud.update(dt)
def spec_draw(self):
self.camera.set_camera()
for plr in self.players.itervalues():
plr.draw()
self.proj_viewer.draw()
self.map.draw()
self.camera.set_static()
self.hud.draw()
def send_center(self, ind):
if ind == self.player.id:
pl = self.player
return pl.rect.center, (pl.input.mx, pl.input.my)
else:
pl = self.players[ind]
return pl.rect.center, (pl.input.mx, pl.input.my)
def test_draw_line_does_nothing_if_no_drawing_surface(self):
camera = Camera(2)
camera.draw_line(Vector2(0), Vector2(1), (1, 2, 3), 4)
def setUp(self):
self.drawing_surface = create_autospec(DrawingSurface)
self.drawing_surface.get_size.return_value = Vector2(2, 1)
self.camera = Camera(2)
self.camera.set_drawing_surface(self.drawing_surface)
class TestCamera(unittest.TestCase):
def setUp(self):
self.drawing_surface = create_autospec(DrawingSurface)
self.drawing_surface.get_size.return_value = Vector2(2, 1)
self.camera = Camera(2)
self.camera.set_drawing_surface(self.drawing_surface)
def test_draw_line_does_nothing_if_no_drawing_surface(self):
camera = Camera(2)
camera.draw_line(Vector2(0), Vector2(1), (1, 2, 3), 4)
def test_draw_line_draws_scaled_lines(self):
self.camera.draw_line(Vector2(0), Vector2(1), (1, 2, 3), 4)
self.drawing_surface.draw_line.assert_called_with(ANY,
ANY,
ANY,
ANY,
scaled=True)
def test_draw_line_scales_width_correctly(self):
self.camera.set_drawing_surface(self.drawing_surface)
self.camera.draw_line(Vector2(0), Vector2(1), (1, 2, 3), 4)
self.drawing_surface.draw_line.assert_called_with(
ANY, ANY, ANY, 2, ANY)
def test_draw_line_on_y_axis_when_camera_at_origo(self):
self.camera.draw_line(Vector2(0, 1), Vector2(0, -1), (1, 2, 3), 4)
self.drawing_surface.draw_line.assert_called_with(
Vector2(1, 1), Vector2(1, 0), ANY, ANY, ANY)
def test_draw_line_on_x_axis_when_camera_at_origo(self):
self.camera.draw_line(Vector2(-2, 0), Vector2(2, 0), (1, 2, 3), 4)
self.drawing_surface.draw_line.assert_called_with(
Vector2(0, 0.5), Vector2(2, 0.5), ANY, ANY, ANY)
def test_draw_line_general_when_camera_at_origo(self):
self.camera.draw_line(Vector2(0), Vector2(1, 0.5), (1, 2, 3), 4)
self.drawing_surface.draw_line.assert_called_with(
Vector2(1, 0.5), Vector2(1.5, 0.75), ANY, ANY, ANY)
def test_draw_line_general_when_camera_not_at_origo(self):
self.camera.location = Vector2(1, 2)
self.camera.draw_line(Vector2(0), Vector2(1, 0.5), (1, 2, 3), 4)
self.drawing_surface.draw_line.assert_called_with(
Vector2(1 - 0.5, 0.5 - 1), Vector2(1.5 - 0.5, 0.75 - 1), ANY, ANY,
ANY)
def test_draw_image_scales_height_correctly(self):
image_mock = Mock()
self.camera.draw_image(image_mock, Vector2(3, 4), 0.4, 10)
self.drawing_surface.draw_image.assert_called_with(ANY, ANY, ANY, 5)
def test_draw_image_draws_at_correct_location(self):
image_mock = Mock()
self.camera.location = Vector2(1, 2)
self.camera.draw_image(image_mock, Vector2(1, 0.5), 0.4, 10)
self.drawing_surface.draw_image.assert_called_with(
ANY, Vector2(1.5 - 0.5, 0.75 - 1), ANY, ANY)
class Game:
def _pygame_init(self, sound=False):
pygame.init()
pygame.display.set_caption("Energy Matters")
self.screen = pygame.display.set_mode(
(0, 0), pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
# self.screen = pygame.display.set_mode(
# (640, 480), pygame.HWSURFACE | pygame.DOUBLEBUF)
log.info(f"Screen size: {self.screen.get_size()}")
self.screen_width, self.screen_height = self.screen.get_size()
self.game_surface = pygame.Surface(
[self.screen.get_size()[0],
self.screen.get_size()[0]])
self.clock = pygame.time.Clock()
def __init__(self):
self._pygame_init()
self.input_handler = InputHandler()
self.drawer = Drawer(self.screen)
self.camera = Camera(self.drawer, self.screen_width,
self.screen_height)
self.input_handler.add_subscriber(EventName.QUIT, self)
self.input_handler.add_subscriber(EventName.ESCAPE, self)
self.input_handler.add_subscriber(EventName.SPACE, self)
self.input_handler.add_subscriber(EventName.RETURN, self)
self.input_handler.add_subscriber(EventName.UP, self)
self.input_handler.add_subscriber(EventName.DOWN, self)
self.input_handler.add_subscriber(EventName.LEFT, self)
self.input_handler.add_subscriber(EventName.RIGHT, self)
self.input_handler.add_subscriber(EventName.MOUSEMOTION, self)
self.input_handler.add_subscriber(EventName.MOUSEMOTIONUP, self)
self.input_handler.add_subscriber(EventName.MOUSEBUTTONUP, self)
self.input_handler.add_subscriber(EventName.MOUSEBUTTONDOWN, self)
self.running = True
self.rickmorty = pygame.image.load("assets/images/rickmorty3.jpeg")
# .convert_alpha()
self.transformrick = 0
self.startx = 0
self.starty = 0
self.screen.fill(0xeeeeee)
self.game_surface.fill(0xaaaaaa)
pygame.draw.rect(self.game_surface, 0xffffff, (10, 50, 100, 200))
pygame.draw.rect(self.game_surface, 0xff0000, (50, 60, 10, 20))
self.game_surface.blit(self.rickmorty, (0, 0))
def update(self):
self.drawer.update_sprites()
pass
def draw(self):
self.drawer.draw()
# self.screen.fill(0xeeeeee)
# self.game_surface.fill(0xaaaaaa)
# pygame.draw.rect(self.game_surface, 0xffffff, (10, 50, 100, 200))
# pygame.draw.rect(self.game_surface, 0xff0000, (50, 60, 10, 20))
# self.game_surface.blit(self.rickmorty, (0, 0))
# self.screen.blit(self.game_surface, (self.startx, self.starty))
# pygame.display.flip()
pass
def run(self):
while self.running:
self.clock.tick(30)
# for event in pygame.event.get():
# if event.type == pygame.QUIT:
# self.running=False
self.input_handler.process_events()
self.update()
self.draw()
log.info("Exiting the Game.run() loop")
pygame.quit()
def input_update(self, event_type, event_attributes):
if event_type == EventName.QUIT:
self.running = False
elif event_type == EventName.ESCAPE:
self.running = False
elif event_type == EventName.MOUSEBUTTONDOWN:
message = repr(event_attributes) \
+ " | grid_offset_x: " + str(self.drawer.grid_offset_x) \
+ " | grid_offset_y: " + str(self.drawer.grid_offset_y)
self.drawer.create_float_text(message, event_attributes['pos'][0],
event_attributes['pos'][1])
message = repr(self.camera) + \
str(self.camera.get_tile_coords_from_click(*event_attributes['pos']))
self.drawer.create_float_text(message, event_attributes['pos'][0],
event_attributes['pos'][1] - 40)
# pass
log.info(event_attributes)
if event_attributes[
'button'] == MouseButton.LEFT.value: # Left click
log.info("transofrm")
self.transformrick = 1
pass
elif event_attributes[
'button'] == MouseButton.RIGHT.value: # Right click
pass
elif event_attributes[
'button'] == MouseButton.SCROLLUP.value: # Scroll up
self.camera.zoomIn()
#Test without camera
# new_rect = [self.game_surface.get_rect(
# )[0] * 2, self.game_surface.get_rect()[1] * 2]
# self.game_surface = pygame.transform.smoothscale(
# self.game_surface, [200, 200])
elif event_attributes[
'button'] == MouseButton.SCROLLDOWN.value: # Scroll down
self.camera.zoomOut()
#Test without camera
# new_rect = [self.game_surface.get_rect(
# )[0] * 2, self.game_surface.get_rect()[1] * 2]
# self.game_surface = pygame.transform.smoothscale(
# self.game_surface, [400, 400])
elif event_type == EventName.MOUSEMOTION:
log.info(event_attributes['buttons'])
log.info(MouseButton.LEFT.value)
log.info(event_attributes['buttons'][MouseButton.LEFT.value])
if event_attributes['buttons'][MouseButton.LEFT_MOTION.value]:
self.camera.translate(
*event_attributes['rel']) # Unpacking the coords tuple
class GameScreen(Events):
"""docstring for GameScreen"""
def __init__(self, window, input_handler):
super(GameScreen, self).__init__()
self.window = window
self.input_handler = input_handler
self.camera = Camera(window)
self.render = Render(self.camera, self.window)
sc_batch = self.render.scene_batch
st_batch = self.render.static_batch
self.player = player.Player(renderhook=self.render.playerhook)
self.proj_viewer = ProjectileViewer(
self.send_center, batch=sc_batch, scale=self.render.scale,
rndhook=self.render.attack)
self.controls = {}
self.controls_old = {}
self.map = Map('blank')
#self.player.spawn(100, 100)
self.time = 0
self.moves = moves(1024)
self.index = [0]
self.head = [0]
#other players
self.players = {}
self.specs = {}
#crosshair
self.cross = CrossHair(batch=st_batch)
self.isSpec = 0.5
self.hud = Hud(batch=st_batch, window=self.window)
self.gs_view = GameStateViewer(self.players, self.hud.update_prop,
self.hud.set_score)
self.frozen = False
self.rest_time = 0
def update(self, dt):
dt = int(dt * 1000000.) / 1000000.
if self.controls['esc'] and not self.controls_old['esc']:
self.send_message('menu_transition_+', (GameMenu, self.isSpec))
if self.controls['rdy'] and not self.controls_old['rdy']:
if not self.isSpec:
self.ready_up()
self.render.move_ahead()
if self.controls['chat'] and not self.controls_old['chat']:
self.send_message('menu_transition_+',
(ChatScreen, None))
self.update_keys()
for plr in self.players.itervalues():
mapgen = [rect for rect in self.map.quad_tree.retrieve([],
plr.rect)]
plr.predict(dt, mapgen)
self.on_update(dt)
def update_physics(self, dt, state=False, input=False):
self.player.update(dt, self.get_rect(), state, input)
return self.player.state.copy()
def update_state_only(self, state):
self.player.state.update_hp(state)
def update_keys(self):
for key_, value in self.controls.items():
self.controls_old[key_] = value
def from_server(self, data):
typ, data = data
if typ == proto.playerUpdate:
ind, time, s_state, inpt, weaponinfo = data
smove = move(time, inpt, s_state)
if ind == self.player.id:
correct_client(self.update_physics, smove, self.moves,
self.head, self.index[0],
self.update_state_only)
self.player.weapons.from_server(weaponinfo)
else:
self.players[ind].client_update(s_state)
self.players[ind].input = inpt
if ind == self.isSpec:
self.camera.mpos_from_aim(vec2(inpt.mx, inpt.my))
self.players[ind].weapons.from_server(weaponinfo)
self.render.weapon_check(ind, weaponinfo)
elif typ == proto.projectile:
self.proj_viewer.process_proj(data)
elif typ == proto.newPlayer:
gs, data = data
if gs == proto.goesSpec:
ind, name, colstring = data
new = player.Player(renderhook=self.render.playerhook, id=ind)
new.name = name
new.id = ind
new.set_color(colstring)
new.rect.update_color(new.color)
self.specs[ind] = new
#if there are existing players on the server
elif gs == proto.wantsJoin:
ind, name, state, time, colstring = data
new = player.Player(renderhook=self.render.playerhook, id=ind)
new.name = name
new.state = state
new.time = time
new.id = ind
new.set_color(colstring)
new.rect.update_color(new.color)
self.players[ind] = new
new.add_to_view()
print 'new player: %s' % name
self.gs_view.to_team(ind)
elif typ == proto.disconnect:
ind = data
if ind in self.players:
if ind == self.isSpec:
self.cancel_follow()
self.gs_view.leave(ind)
self.players[ind].remove_from_view()
del self.players[ind]
self.set_playergen()
elif ind in self.specs:
del self.specs[ind]
elif typ == proto.stateUpdate:
gametime, data = data
gs, ind = data
self.gs_view.set_time(gametime)
if gs == proto.wantsJoin:
if ind == self.player.id:
self.send_message('menu_transition_-')
self.player.state.isDead = False
if self.isSpec > 0.5:
self.players[self.isSpec].state.unhook()
self.players[self.isSpec].weapons.unhook()
self.trans_to_game()
else:
self.players[ind] = self.specs[ind]
del self.specs[ind]
self.gs_view.to_team(ind)
self.players[ind].add_to_view()
elif gs == proto.goesSpec:
if ind == self.player.id and self.isSpec:
pass
elif ind == self.player.id and not self.isSpec:
self.send_message('menu_transition_-')
self.gs_view.leave(self.player.id)
self.trans_to_spec()
else:
self.specs[ind] = self.players[ind]
self.gs_view.leave(ind)
if ind == self.isSpec:
self.cancel_follow()
del self.players[ind]
self.specs[ind].remove_from_view()
self.set_playergen()
elif gs == proto.isDead:
ind, killer, weapon = ind
if ind == self.player.id:
self.player.die()
else:
self.players[ind].die()
self.gs_view.score(ind, killer, weapon)
elif gs == proto.spawns:
ind, pos = ind
if ind == self.player.id:
self.player.spawn(*pos)
else:
self.players[ind].spawn(*pos, other=True)
elif gs == proto.isReady:
ind, name = ind
self.gs_view.is_ready(ind, name)
elif gs == proto.countDown:
self.player.freeze()
self.gs_view.count_down()
elif gs == proto.inProgress:
self.gs_view.start_game()
elif gs == proto.warmUp:
self.frozen = False
self.gs_view.to_warmup()
elif gs == proto.gameOver:
self.frozen = True
self.gs_view.show_score()
elif gs == proto.overTime:
self.hud.update_prop(text='Overtime!')
elif typ == proto.mapUpdate:
ind, itemid, gt, spawn = data
self.gs_view.set_time(gt)
if ind == self.player.id:
if isinstance(self.map.items[itemid], Triangle):
st = self.map.items[itemid].keystr
if not st in self.player.weapons.weapons:
self.player.weapons.pickup(st)
else:
if not isinstance(self.map.items[itemid], Ammo):
self.player.weapons.apply(st, self.player)
else:
self.player.weapons.predict_ammo(st)
elif ind in self.players:
if isinstance(self.map.items[itemid], Triangle):
st = self.map.items[itemid].keystr
if not st in self.players[ind].weapons.weapons:
self.players[ind].weapons.pickup(st)
else:
if not isinstance(self.map.items[itemid], Ammo):
try:
pl = self.players[ind]
pl.weapons.apply(st, pl)
except TypeError:
pass
else:
self.players[ind].weapons.predict_ammo(st)
self.map.serverupdate(itemid, spawn)
elif typ == proto.chat:
ind, msg = data
if ind == self.player.id:
name = self.player.name
color = self.player.color
elif ind in self.players:
name = self.players[ind].name
color = self.players[ind].color
else:
name = self.specs[ind].name
color = self.specs[ind].color
#chatdata = ' '.join((name + ':', '\t', msg))
chatdata = (name, color, msg)
self.hud.update_prop(chat=chatdata)
def send_to_client(self, dt):
temp_input = proto.Input()
self.time += int(dt * 1000000.)
temp_input.CopyFrom(self.player.input)
c_move = move(self.time, temp_input, self.player.state.copy())
try:
self.moves[self.index[0]] = c_move
except IndexError:
self.moves.append(c_move)
self.moves.advance(self.index)
self.send_message('input', (self.player.input, self.time))
def spec_send(self, dt):
self.rest_time += dt
if self.rest_time >= timestep * 6:
self.time += int(timestep * 1000000.)
self.rest_time = 0
self.send_message('input', (proto.Input(), self.time))
def draw(self):
self.render.draw()
def on_connect(self, msg):
ind, mapname, name, gs = msg
self.player.get_id(ind, name)
batch = pyglet.graphics.Batch()
self.map = Map(mapname, batch=batch, renderhook=self.render.maphook)
self.render.maphook(self.map, add=True)
print 'connected with id: ' + str(self.player.id)
#self.send_message('input', (self.player.input, 1337))
self.gs_view.init_self(ind, gs)
self.trans_to_spec()
def try_join(self):
msg = proto.Message()
msg.type = proto.stateUpdate
plr = proto.Player()
plr.id = self.player.id
msg.player.CopyFrom(plr)
if self.isSpec:
msg.gameState = proto.wantsJoin
else:
msg.gameState = proto.goesSpec
self.send_message('other', msg)
def ready_up(self):
msg = proto.Message()
msg.type = proto.stateUpdate
plr = proto.Player()
plr.id = self.player.id
msg.player.CopyFrom(plr)
msg.gameState = proto.isReady
self.send_message('other', msg)
def send_chat(self, chatmsg):
msg = proto.Message()
msg.type = proto.chat
plr = proto.Player()
plr.id = self.player.id
plr.chat = chatmsg
msg.player.CopyFrom(plr)
self.send_message('other', msg)
def on_update(self, dt):
pass
def on_draw(self):
pass
def idle_update(self, dt):
self.rest_time += dt
if not self.isSpec:
while self.rest_time >= timestep:
if not self.frozen:
self.update_physics(timestep)
self.send_to_client(timestep)
self.rest_time -= timestep
#interpolate missing time
state = self.player.state.copy()
self.player.predict_step(self.rest_time, self.get_rect(),
state, self.player.input)
else:
self.spec_send(dt)
self.render.update(dt)
self.gs_view.update(dt)
self.proj_viewer.update(dt)
self.hud.update(dt)
def trans_to_spec(self):
self.on_update = self.spec_update
self.isSpec = 0.5
self.player.state.hook_hud(self.hud.update_prop)
self.hud.init_spec()
self.gs_view.scorehook(self.gs_view.a.score, self.gs_view.b.score)
self.player.remove_from_view()
self.cross.remove()
self.ready_cycle = False
self.set_playergen()
self.window.set_mouse_visible(True)
self.window.set_exclusive_mouse(False)
def trans_to_game(self):
self.player.add_to_view()
self.isSpec = False
self.player.weapons.hook_hud(self.hud.update_prop)
#self.player.state.hook_hud(self.hud.update_prop)
self.hud.init_player(self.players)
self.gs_view.add_self(self.player)
self.cross.add(self.render.static_batch)
self.on_update = self.game_update
self.register_mouse()
self.window.set_mouse_visible(False)
self.window.set_exclusive_mouse(True)
self.cancel_drag()
self.rest_time = 0
def game_update(self, dt):
self.rest_time += dt
while self.rest_time >= timestep:
if not self.frozen:
self.update_physics(timestep)
self.send_to_client(timestep)
self.rest_time -= timestep
#interpolate missing time
state = self.player.state.copy()
self.player.predict_step(self.rest_time, self.get_rect(),
state, self.player.input)
#state.id = self.player.id
#state.mpos = vec2(self.player.input.mx, self.player.input.my)
#state.color = self.player.color
#self.render.playerhook(state, update=True)
self.render.update(dt)
self.camera.update(dt, self.player.state)
self.proj_viewer.update(dt)
self.gs_view.update(dt)
self.hud.update(dt)
self.cross.update(*self.camera.mpos)
def spec_update(self, dt):
if self.player.input.att and self.ready_cycle:
try:
self.ready_cycle = False
if self.isSpec > 0.5:
self.players[self.isSpec].state.unhook()
self.players[self.isSpec].weapons.unhook()
self.isSpec = self.playergen.next()
id = self.isSpec
self.players[id].state.hook_hud(self.hud.update_prop)
self.players[id].weapons.hook_hud(self.hud.update_prop)
self.unregister_mouse()
self.cross.add(self.render.static_batch)
self.hud.init_pers_hud()
self.cancel_drag()
except StopIteration:
self.cancel_follow()
if not self.player.input.att:
self.ready_cycle = True
if self.isSpec > 0.5:
self.camera.update(dt, self.players[self.isSpec].state)
self.cross.update(*self.camera.interpolate_mpos())
else:
self.player.specupdate(dt)
self.camera.update(dt, self.player.state)
self.render.update(dt)
self.spec_send(dt)
self.proj_viewer.update(dt)
self.gs_view.update(dt)
self.hud.update(dt)
def send_center(self, ind):
if ind == self.player.id:
pl = self.player
return pl.rect.center, (pl.input.mx, pl.input.my)
else:
pl = self.players[ind]
return pl.rect.center, (pl.input.mx, pl.input.my)
def register_mouse(self):
self.input_handler.register(self.camera.receive_m_pos, 'mouse_cam')
self.window.set_mouse_visible(True)
self.window.set_exclusive_mouse(False)
def unregister_mouse(self):
try:
self.input_handler.unregister(self.camera.receive_m_pos)
self.window.set_mouse_visible(False)
self.window.set_exclusive_mouse(True)
except KeyError:
pass
def set_playergen(self):
self.playergen = iter(self.players.keys())
def cancel_follow(self):
ind = self.isSpec
if ind > 0.5:
self.player.state.pos = vec2(*self.players[ind].state.pos)
self.isSpec = 0.5
self.set_playergen()
self.register_mouse()
self.cross.remove()
self.hud.init_spec()
@self.window.event
def on_mouse_drag(x, y, dx, dy, buttons, mods):
if buttons == 4:
self.player.state.pos -= vec2(dx, dy) * 2
self.dragevent = on_mouse_drag
def cancel_drag(self):
try:
self.window.remove_handler('on_mouse_drag', self.dragevent)
except AttributeError:
pass
def get_rect(self):
playerlist = [player.rect for player in self.players.itervalues()
if not player.state.isDead]
maplist = [rect for rect in self.map.quad_tree.retrieve([],
self.player.rect)]
return playerlist + maplist
def setup_data_state(constants, run_tutorial=True, previous_data=None):
pygame.init()
pygame.display.set_caption("Formula")
pygame.mixer.quit()
pygame.key.set_repeat(100)
main = pygame.display.set_mode(
(constants.window_size.width, constants.window_size.height))
assets = Assets.setup()
godmode = False
fps_per_second = 30
story_loader = StoryLoader()
story_data = StoryData(story_loader)
timesystem = TimeSystem()
visuals = VisualEffectSystem.setup(fps_per_second)
clock = pygame.time.Clock()
windows = WindowManager()
rpw = RightPanelWindow(constants)
windows.push(rpw)
windows.push(GameWindow(constants, parent=rpw))
windows.push(MessageLogWindow(constants, parent=rpw))
windows.push(StoryWindow(constants, story_data, visible=True))
windows.push(StoryHelpWindow(constants))
windows.push(FormulaWindow(constants))
windows.push(FormulaHelpWindow(constants))
windows.push(GeneralHelpWindow(constants))
windows.push(LevelUpWindow(constants))
windows.push(AskQuitWindow(constants))
windows.push(DeadWindow(constants))
windows.push(VictoryWindow(constants))
windows.push(ConsoleWindow(constants))
windows.push(CraftingWindow(constants))
windows.push(CraftingHelpWindow(constants))
windows.push(InventoryWindow(constants))
windows.push(InventoryHelpWindow(constants))
text_width = constants.message_log_text_size.width / get_width(
Assets.get().font_message)
log = MessageLog(text_width) # for some margin on the sides
player = Player(godmode)
formula_builder = FormulaBuilder(player.caster.num_slots,
player.caster.num_formulas, run_tutorial)
levels = 9
planner = RunPlanner(levels, player, constants, timesystem, run_tutorial)
fov_map = None
ingredient_storage = IngredientStorage()
if config.conf.pickupstartcount == "base":
ingredient_storage.add_multiple({
Ingredient.FIRE: 2,
Ingredient.WATER: 2,
Ingredient.EARTH: 2,
Ingredient.RANGE: 1,
Ingredient.AREA: 1,
})
if config.conf.trap:
ingredient_storage.add_multiple({
Ingredient.TRAP: 2,
})
else:
for ing in Ingredient.all():
ingredient_storage.add_multiple(
{ing: config.conf.pickupstartcount})
menu_data = AttrDict({"currchoice": 0})
inventory = Inventory(max_count=constants.num_consumables,
num_quickslots=constants.num_quickslots)
from components.consumable import Firebomb, Freezebomb, Teleporter, CooldownClear
# for t in [Firebomb, Freezebomb, Teleporter, CooldownClear, Thingy, Thingmajig]:
# inventory.add(t())
#inventory.add(Firebomb())
#inventory.add(Teleporter())
initial_state = GameStates.STORY_SCREEN
logger = previous_data.logger if previous_data else BlobLogger()
game_data = StateData(
player=player,
log=log,
constants=constants,
timesystem=timesystem,
fov_map=fov_map,
fov_recompute=True,
story_data=story_data,
run_planner=planner,
formula_builder=formula_builder,
menu_data=menu_data,
ingredient_storage=ingredient_storage,
inventory=inventory,
logger=logger,
initial_state=initial_state,
initial_state_history=[GameStates.PLAY],
)
camera = Camera(constants.camera_size.width, constants.camera_size.height,
game_data)
gfx_data = GfxState(
main=main,
assets=assets,
camera=camera,
fullscreen=False,
visuals=visuals,
fps_per_second=fps_per_second,
clock=clock,
windows=windows,
)
if not run_tutorial:
game_data.prev_state = [GameStates.FORMULA_SCREEN, GameStates.PLAY]
windows.activate_wnd_for_state(game_data.state, game_data, gfx_data)
story_data.next_story()
# create default formulas
Formula.EMPTY, _ = formula_builder.get_empty_formula(caster=player)
initial_formulas = formula_builder.evaluate_entity(caster=player)
player.caster.set_formulas(initial_formulas)
return game_data, gfx_data, initial_state
class Game:
_control_to_selected_index = {
Controls.select_item_0: 0,
Controls.select_item_1: 1,
Controls.select_item_2: 2,
Controls.select_item_3: 3,
Controls.select_item_4: 4,
Controls.select_item_5: 5,
Controls.select_item_6: 6,
Controls.select_item_7: 7,
Controls.select_item_8: 8,
}
def __init__(self):
pg.init()
pg.mouse.set_cursor(*CURSOR)
self._camera = Camera()
self._hotbar = Hotbar()
self._world = World()
self._main_player = Player("main_player",
spawn_pos=PLAYER_DEFAULT_SPAWN_POS)
self._action = GameAction.play
def main_loop(self):
while True:
# Keyboard inputs
keys_pressed = pg.key.get_pressed()
mods_pressed = pg.key.get_mods()
if (keys_pressed[Controls.quit] or pg.event.peek(pg.QUIT)
or self._action == GameAction.quit
or self._action == GameAction.quit_without_saving):
return
# Requesting horizontal movements
does_horiz_movement = False
if keys_pressed[Controls.move_left]:
if mods_pressed == pg.KMOD_NONE:
self._main_player.req_move_left()
else:
if mods_pressed & Mods.sprinting:
self._main_player.req_sprint_left()
does_horiz_movement ^= True
if keys_pressed[Controls.move_right]:
if mods_pressed == pg.KMOD_NONE:
self._main_player.req_move_right()
else:
if mods_pressed & Mods.sprinting:
self._main_player.req_sprint_right()
does_horiz_movement ^= True
if not does_horiz_movement:
self._main_player.req_h_move_stop()
# Requesting jumps
if keys_pressed[Controls.jump]:
self._main_player.req_jump()
else:
self._main_player.req_jump_stop()
# Requesting camera zooms
is_zooming = False
if keys_pressed[Controls.zoom_in]:
self._camera.req_zoom_in()
is_zooming ^= True
if keys_pressed[Controls.zoom_out]:
self._camera.req_zoom_out()
is_zooming ^= True
if not is_zooming:
self._camera.req_zoom_stop()
# Mouse inputs
mb_pressed = pg.mouse.get_pressed()
# Select item in hotbar
for control in self._control_to_selected_index:
if keys_pressed[control]:
self._hotbar.req_select_index(
self._control_to_selected_index[control])
# Breaking blocks
if mb_pressed[Controls.break_block]:
self._world.req_break_block(self._camera.selected_block_w_pos)
# Placing blocks
if mb_pressed[Controls.place_block]:
block = self._hotbar.selected_item
self._world.req_place_block(self._camera.selected_space_w_pos,
block,
self._main_player.get_bounds())
# Applying movements
self._main_player.move(self._world)
self._camera.req_move(self._main_player.pos)
self._camera.move()
# Graphics
self._world.draw_and_tick(self._camera)
self._main_player.draw(self._camera, self._world)
self.draw_gui()
if DEBUG:
self._camera.draw_debug_info()
self._camera.display_flip_and_clock_tick()
# Death
if self._main_player.is_dead:
self.death_loop()
def death_loop(self):
self._main_player.spawn()
self._action = GameAction.quit
def __enter__(self):
if LOAD:
# Create SAVES_CURRENT_DIR if it doesn't already exist.
try:
os.makedirs(CURRENT_SAVE_PATH)
except FileExistsError:
pass
world_load_result = self._world.load_from_disk(CURRENT_SAVE_PATH)
player_load_result = self._main_player.load_from_disk(
CURRENT_SAVE_PATH)
if world_load_result == LoadResult.incompatible or player_load_result == LoadResult.incompatible:
self._action = GameAction.quit_without_saving
print("Error: incompatible save file.")
self._camera.set_transforms(self._main_player.pos)
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if SAVE and not self._action == GameAction.quit_without_saving:
self._world.save_to_disk(CURRENT_SAVE_PATH)
self._main_player.save_to_disk(CURRENT_SAVE_PATH)
pg.quit()
def draw_gui(self):
self._camera.draw_block_selector(self._main_player.action_w_pos,
self._world)
self._hotbar.draw(self._camera)