def start_loop(self): """Loop for start screen""" selected = False background = Background(START_BG, [0, 0]) top_score = Hud(10, 350, 200, 40, "TOP SCORE") def launch_game(): nonlocal selected selected = True self.game_loop() while not selected: for event in pygame.event.get(): if event.type == pygame.QUIT: selected = True top_score.prop = self.scores.top_score self.clock.tick(20) pygame.mouse.set_visible(True) self.screen.blit(background.image, background.rect) large_text = pygame.font.Font('freesansbold.ttf', 80) text_surf, text_rect = text_objects("OMEGA!", large_text, (210, 208, 224)) text_rect.center = ((self.screen_width / 2), (self.screen_height / 2.75)) self.screen.blit(text_surf, text_rect) top_score.update(dest=self.screen) button('PLAY', ((self.screen_width / 2) - 50), 240, 100, 40, ((37, 31, 71), (108, 100, 153), (210, 208, 224)), self.screen, launch_game)
def main(): hud = Hud() # ser = serial.Serial(port = '/dev/ttyUSB0', # baudrate = 9600, # parity = serial.PARITY_NONE, # stopbits = serial.STOPBITS_ONE, # bytesize = serial.EIGHTBITS, # timeout = 1) logger = 0 kv = {} stringKV = {} firstPass = True while True: # wrapping this all in a try-catch should handle file-opening/-closing timeline nicely # i.e. catch TclError(possibly tclError): close file # # var parsing and file writing will need to be wrapped in classes sleep(0.5) #kv = RT.randomKV() #print kv try: #inLine = ser.readline() inLine = RT.randomKVLine() if inLine[0] == '@': newKV = parseLineToKV(inLine) newStringKV = parseLineToStringKV(inLine) if firstPass: keys = sorted(newStringKV.keys()) logger = Logger(keys) firstPass = False if newKV != kv: kv = newKV stringKV = newStringKV hud.updateHud(kv) hud.update_idletasks() hud.update() logger.logKV(stringKV) print strfkv(stringKV) except TclError: #possibly tclError print "HUD was closed" logger.close() break except err: print err break
class Game(): def __init__(self, _parent=None): self.parent = _parent # Containers self.game_objects = {} self.game_doors = {} self.game_objects_np = render.attachNewNode("Game_Objects") self.game_doors_np = render.attachNewNode("Player_Doors") self.game_doors_np.setPos(0, 0, 0) self.game_counter_node = None self.game_collector_nodes = [] self.redDudesCount = 0 self.blueDudesCount = 0 # Physics world self.physics_world = None self.builder = Builder(self) # level lights self.directLight = None # Dude class self.dude = None self.spawnPoints = self.builder.spawnPoints # HUD self.hud = Hud() # Lightshow self.elapsed = 0.0 def start(self, levelID, winCondition=25): self.winCondition = winCondition self.loadLevel("assets/level{}".format(levelID)) self.loadLights() # player self.loadPlayer("default") self.loadDude() # Timer taskMgr.add(self.update, "Game_Update_Task", 0) self.hud.show() # start the Lightshow taskMgr.add(self.discoLightTask, "the lightshow") def stop(self): self.player.stop() self.dude.stop() self.builder.cleanup() self.physics_world = None render.clearLight() self.directLight = None self.hud.hide() taskMgr.remove("the lightshow") def update(self, task): if self.game_counter_node is None: return ghost = self.game_counter_node.node() for node in ghost.getOverlappingNodes(): if "red" in node.name: self.redDudesCount += 1 self.physics_world.removeRigidBody(self.dude.dudes[node.name].node()) self.dude.dudes[node.name].removeNode() self.hud.update(self.redDudesCount, self.blueDudesCount) del self.dude.dudes[node.name] break elif "blue" in node.name: self.blueDudesCount += 1 self.physics_world.removeRigidBody(self.dude.dudes[node.name].node()) self.dude.dudes[node.name].removeNode() self.hud.update(self.redDudesCount, self.blueDudesCount) del self.dude.dudes[node.name] break if self.redDudesCount > self.blueDudesCount: base.messenger.send("lostGame") return Task.done elif self.blueDudesCount >= self.winCondition: base.messenger.send("wonGame") return Task.done for collectorGhostNP in self.game_collector_nodes: collectorGhost = collectorGhostNP.node() for node in collectorGhost.getOverlappingNodes(): if "red" in node.name: self.physics_world.removeRigidBody(self.dude.dudes[node.name].node()) self.dude.dudes[node.name].removeNode() self.hud.update(self.redDudesCount, self.blueDudesCount) del self.dude.dudes[node.name] return Task.cont def setPhysicsWorld(self, _physicsworld): self.physics_world = _physicsworld #### LOADERS #### def loadLevel(self, _filename): self.builder.parseEggFile(_filename) def loadLights(self): # Set a simple light dlight = DirectionalLight('DirectLight') dlnp = render.attachNewNode(dlight) dlnp.setHpr(-30, 0, 0) render.setLight(dlnp) self.directLight = dlnp self.discoLights = [] p1 = PointLight("PointLight1") p1.setColor(VBase4(1, 0, 0, 1)) p1.setAttenuation((0.08, 0, 0.05)) p1np = render.attachNewNode(p1) p1np.setPos(0, -5, 0) render.setLight(p1np) self.discoLights.append(p1) p2 = PointLight("PointLight2") p2.setColor(VBase4(0, 1, 0, 1)) p2.setAttenuation((0.08, 0, 0.05)) p2np = render.attachNewNode(p2) p2np.setPos(5, -5, 0) render.setLight(p2np) self.discoLights.append(p2) p3 = PointLight("PointLight3") p3.setColor(VBase4(0, 0, 1, 1)) p3.setAttenuation((0.08, 0, 0.05)) p3np = render.attachNewNode(p3) p3np.setPos(-5, -5, 0) render.setLight(p3np) self.discoLights.append(p3) p4 = PointLight("PointLight4") p4.setColor(VBase4(0, 0, 1, 1)) p4.setAttenuation((0.08, 0, 0.05)) p4np = render.attachNewNode(p4) p4np.setPos(-5, -5, 5) render.setLight(p4np) self.discoLights.append(p4) p5 = PointLight("PointLight1") p5.setColor(VBase4(0, 0, 1, 1)) p5.setAttenuation((0.08, 0, 0.05)) p5np = render.attachNewNode(p5) p5np.setPos(0, -5, 5) render.setLight(p5np) self.discoLights.append(p5) p6 = PointLight("PointLight1") p6.setColor(VBase4(0, 0, 1, 1)) p6.setAttenuation((0.08, 0, 0.05)) p6np = render.attachNewNode(p6) p6np.setPos(5, -5, 5) render.setLight(p6np) self.discoLights.append(p6) def discoLightTask(self, task): self.elapsed += globalClock.getDt() if self.elapsed > 0.75: for light in self.discoLights: newcolor = choice( [VBase4(0, 0, 1, 1), VBase4(0, 1, 0, 1), VBase4(1, 0, 0, 1), VBase4(0, 1, 1, 1), VBase4(1, 0, 1, 1), VBase4(1, 1, 0, 1),] ) light.setColor(newcolor) self.elapsed = 0.0 return task.cont def loadPlayer(self, _name): self.player = Player(self) self.player.start() def loadDude(self): self.dude = Dude(self) self.dude.start()
def run(): pygame.init() random.seed() display_size = 800, 600 viewport_size = display_size[0], 600 black = 0, 0, 0 red = 255, 70, 70 green = 70, 255, 70 blue = 70, 70, 255 white = 255, 255, 255 l_green = 50, 255, 0 screen = pygame.display.set_mode(display_size) screen.fill(black) clock = Clock(readonly=False) dbman = DBManager() dbman.import_db("./db") gfxman = GfxManager() gfxman.import_gfx(dbman.get(), "./gfx") stagemanager = StageManager() stagemanager.import_stages("./stages") stages = stagemanager.get() groupmanager = GroupManager() g_draw = groupmanager.add("draw", "OrderedUpdates") g_ship = groupmanager.add("ship") g_enemies = groupmanager.add("enemies") g_enemy_projectiles = groupmanager.add("enemy_projectiles") g_player_projectiles = groupmanager.add("player_projectiles") g_beams = groupmanager.add("beams") g_explosions = groupmanager.add("explosions") g_shields = groupmanager.add("shields") g_bonuses = groupmanager.add("bonuses") hud = Hud(viewport_size) g_enemies.add(Obstacle((60, 30))) g_enemies.add(MovingObstacle((160, 80))) g_bonuses.add(RechargeBonus((300, 200))) g_bonuses.add(SuperShieldBonus((500, 300))) g_bonuses.add(ShieldUpgradeBonus((500, 500))) g_bonuses.add(ShieldUpgradeBonus((300, 500))) ship = ref(PlayerShip((175, viewport_size[1] - 60), g_ship)) hud.setup_connections(ship()) back = SpaceBackground(viewport_size) for stage_name in sorted(stages.keys()): stage_clock = 0 while True: for spawn_time in stages[stage_name]["spawn"]: if spawn_time <= stage_clock: while stages[stage_name]["spawn"][spawn_time]: spawn = stages[stage_name]["spawn"][spawn_time].pop() pos = spawn["x"], spawn["y"] object_cls = eval(spawn["object_cls_name"]) if spawn["object_base_cls_name"]: if spawn["object_base_cls_name"] == "Projectile": if not spawn.has_key("object_params"): raise ValueError, "Params for projectile '%s' in stage %s \ not set" % ( spawn["object_cls_name"], stage_name, ) if not spawn["object_params"].has_key("dir"): raise ValueError, "Invalid 'dir' for projectile '%s' in \ stage %s" % ( spawn["object_cls_name"], stage_name, ) if not spawn["object_params"].has_key("collision_group"): raise ValueError, "Invalid 'collision_group' for projectile \ '%s' in stage %s" % ( spawn["object_cls_name"], stage_name, ) params = spawn["object_params"] dir = params["dir"] g_coll = groupmanager.get(params["collision_group"]) object = object_cls(pos, dir, g_coll) elif spawn["object_base_cls_name"] == "Bonus": pass else: raise ValueError, "Invalid value '%s' for attrubite \ 'object_base_cls_name' in stage %s" % ( spawn["object_base_cls_name"], stage_name, ) else: object = object_cls(pos) if spawn["bonus_cls_name"]: if isinstance(object, BonusHolder): object.set_bonus(spawn["bonus_cls_name"], spawn["bonus_params"]) else: raise ValueError, "Instances of %s can not hold bonuses." % object.__class__.__name__ if spawn["mover_cls_name"]: mover_cls = eval("mover.%s" % spawn["mover_cls_name"]) m = mover_cls(pos, object.max_speed, spawn["mover_params"]) object.set_mover(m) for g in spawn["groups"]: if g == "enemies": g_enemies.add(object) elif g == "explosions": g_explosions.add(object) elif g == "enemy_projectiles": g_enemy_projectiles.add(object) elif g == "player_projectiles": g_player_projectiles.add(object) # time management clock.tick(40) # clock.tick( float(sys.argv[1]) ) stage_clock += clock.get_time() for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_q: sys.exit() elif event.key == pygame.K_s: if ship(): ship().next_weapon() elif event.key == pygame.K_a: if ship(): ship().previous_weapon() elif event.key == pygame.K_x: if ship(): ship().activate_shield(True) elif event.type == pygame.KEYUP: if event.key == pygame.K_UP: if ship(): ship().fly_up(False) elif event.key == pygame.K_x: if ship(): ship().activate_shield(False) pressed_keys = pygame.key.get_pressed() if pressed_keys[pygame.K_UP]: if ship(): ship().fly_up(True) if pressed_keys[pygame.K_DOWN]: if ship(): ship().fly_down(viewport_size[1]) if pressed_keys[pygame.K_LEFT]: if ship(): ship().fly_left() if pressed_keys[pygame.K_RIGHT]: if ship(): ship().fly_right(viewport_size[0]) if pressed_keys[pygame.K_z]: if ship(): ship().shoot() back.clear(screen, clear_bg) back.update() back.draw(screen) # temp # if ship(): # ship().damage(1) # g_draw.clear(screen, clear_bg) hud.clear(screen, clear_bg) g_draw.update() hud.update() g_draw.draw(screen) hud.draw(screen) pygame.display.flip()
class World: # This is the __init__ # its important. def __init__(self, app, screen): # tock started out random, but now is an important variable. # It is a frames count, used for periodic updates on certain # frames. self.p_max_health = 5 self.won = False self.won_msg = "WINNER!" self.particle_ban = False self.wait_stop_count = -1 # -1 means do not count self.wait_stop_max = 120 # wait this many frames after decay # before showing menu self.tock = 0 self.stage_e_bullet_odds = 15 self.mouse_rect = None self.temp_rect = None self.app = app self.screen = screen self.app.music_name = "intro.ogg" # self.app.continue_music() if self.app.settings['music']: # self.app.music_loaded = self.app.music_name # pygame.mixer.music.load(self.app.resource_find( # self.music_name)) # pygame.mixer.music.play() # plays once PLUS repeats param pass left_border = 50 right_border = 50 w, h = screen.get_size() self.world_rect = pygame.Rect(left_border, 0, w-right_border-left_border, h) self.bg = BackgroundManager(self.world_rect) # Yay spritegroups! They make the world go round, and iterate. # Basically each visible game object resides in its own special # spritegroup & then all one needs to do is go through these & # call functions & stuff. # It makes sense in here *points to brain* self.p_swarm = Swarm(self.world_rect) self.particles = Swarm(self.world_rect) self.explosion_images = self.app.load_seq('ex-medium') self.shield_hit_images = self.app.load_seq('shield_hit-tiny') self.damage_images = self.app.load_seq('ex-tiny') # Load player sprite as image list. self.p_unit_images = self.app.load_seq('pship') # self.p_unit_images = [] # self.p_unit_images.append(self.load_file('pship.png')) # self.p_unit_images.append(self.load_file('pship1.png')) # self.p_unit_images.append(self.load_file('pship2.png')) # self.p_unit_images.append(self.load_file('pship3.png')) # Load enemy ship image. self.e_ship_image = self.load_file('eship.png') if self.app.settings['sounds']: self.p_shoot_sound = self.app.load_file('p-weapon0.wav', file_type='sound') self.p_shoot_sound.set_volume(.3) self.e_ex_sound = self.app.load_file('e-ex.wav', file_type='sound') self.p_ex_sound = self.app.load_file('p-ex.wav', file_type='sound') self.e_damage_sound = self.app.load_file('e-damage.wav', file_type='sound') self.e_shield_sound = self.app.load_file('e-shield.wav', file_type='sound') self.p_shield_sound = self.app.load_file('p-shield.wav', file_type='sound') self.p_damage_sound = self.app.load_file('p-damage.wav', file_type='sound') print("loaded sounds...") self.menus = None self.tock = 0 self.lagcount = 0 self.leftkeydown = 0 self.rightkeydown = 0 # self.enemylist = [] # list of dirty rects self.swarm = Swarm(self.world_rect, shoot_odds=self.stage_e_bullet_odds) self.stage = Stage(self.swarm, self.p_swarm) self.p_shot_image = self.load_file('p-laser.png') self.e_shot_image = self.load_file('e-laser.png') self.p_bullet_swarm = Swarm(self.world_rect) self.e_bullet_swarm = Swarm(self.world_rect) # self.bullet_width = 10 self.hud_rect = pygame.Rect(0, 0, 5, 150) self.hud = Hud() self.hud.generate_blip('player.score', 100, fg_color=(255,243,207), text_color=(192,180,180), caption="SCORE") self.hud.generate_blip('player.health', self.p_max_health, fg_color=(0,255,42), text_color=(192,180,180), caption="SHIELD") self.statcounter = self.hud.get_blip('player.score') def load_file(self, name): return self.app.load_file(name) def on_exit(self): print("on_exit...") # Clears all the variables def clear_vars(self): # print("clear_vars: world_rect: " + str(self.world_rect)) self.p_start_x = self.world_rect.width / 2 self.p_start_y = self.world_rect.height - 60 self.bend_y = float(self.p_start_y) # print("clear_vars: p_start_y: " + str(self.p_start_y)) self.bend_rate = 0.02 self.leftkeydown = 0 self.rightkeydown = 0 if self.p_unit is not None: self.hud.set_blip_value('player.health', self.p_unit.health) else: print("WARNING: clear_vars failed to set bar since no" + " player unit exists") self.statcounter.set_val(0) self.stage.set_stage_number(-1) # hax self.stage_e_bullet_odds = 100 self.swarm.empty() self.p_bullet_swarm.empty() self.p_swarm.empty() self.particles.empty() self.e_bullet_swarm.empty() # Define function to draw player ship on X, Y plane def draw_player_units(self): self.p_swarm.draw(self.screen) # Define function to move the enemy ship def emove(self): self.swarm.draw(self.screen) # use spritegroup draw method # Draws all the enemys you ask it def generate_enemies(self): print("generating enemies...") # Some recursive loops: xmin = self.world_rect.left xmax = self.world_rect.right ymin = self.world_rect.top stage_data = self.stage.get_data() self.e_ship_image = self.app.load_file(stage_data['e']+".png") enemy_width, enemy_height = self.e_ship_image.get_size() enemy_spacing_x = 15 enemy_spacing_y = 10 init_enemy_speed = 3 angle = -90 # cartesian self.app.music_name = stage_data['music'] # if self.app.music_name == 'intro.ogg': # self.app.continue_music() # force song change e_max_health = stage_data['e_h'] for enemycol in range(stage_data['x_e_count']): # Now for the rows for enemyrow in range(stage_data['y_e_count']): # Make a new enemy object: new_enemy = Entity(self.app, 'eship', [self.e_ship_image], init_enemy_speed, angle, self.swarm, e_max_health, self.explosion_images, self.particles, ai_enable=True, value=stage_data['e_h'], ex_sound=self.e_ex_sound) new_enemy.set_xy( xmin + enemycol * (enemy_width + enemy_spacing_x), ymin + enemyrow * (enemy_height + enemy_spacing_y) - 150 ) new_enemy.set_range( xmin + enemycol * (enemy_width + enemy_spacing_x), xmax - (stage_data['x_e_count'] - enemycol) * (enemy_height + enemy_spacing_x) ) # Now add the temp enemy to the array and we're good to # go self.swarm.add(new_enemy) # So I'm trying out having the program check for collisions, instead # of the enemy objects i think i might switch to the objects, but # still keep this function just hand the computing to the object def test_collision(self): part_speed = 1 part_angle = -90 part_health = 1 e_hit = pygame.sprite.groupcollide(self.swarm, self.p_bullet_swarm, 0, 0) for sprite, bullets in e_hit.items(): # print("removed " + str(bullet) for bullet in bullets: was_alive = sprite.get_is_alive() prev_health = sprite.health if sprite.get_is_alive(): sprite.set_hit(1) damage = prev_health - sprite.health poof = self.shield_hit_images temper_sound = self.e_shield_sound if damage > 0: poof = self.damage_images temper_sound = self.e_damage_sound if not was_alive: break point = pygame.sprite.collide_mask(sprite, bullet) if ((point is not None) and (not self.particle_ban)): particle = Entity(self.app, 'particle', poof, part_speed, part_angle, self.particles, part_health, None, None, anim_done_remove=True, temper_sound=temper_sound) particle.temper = 1 # start particle death x1, y1 = sprite.get_pos() # top left x = x1 + point[0] - particle.rect.width / 2 y = y1 + point[1] - particle.rect.height / 2 particle.set_xy(x, y) self.particles.add(particle) if not sprite.get_is_alive(): points = sprite.take_value() # only once & if health 0 if points > 0: self.statcounter.add_value(points) self.p_bullet_swarm.remove(bullets) p_hit = pygame.sprite.groupcollide(self.p_swarm, self.e_bullet_swarm, 0, 0) for sprite, bullets in p_hit.items(): for bullet in bullets: was_alive = sprite.get_is_alive() prev_health = sprite.health if sprite.get_is_alive(): sprite.set_hit(1) damage = prev_health - sprite.health poof = self.shield_hit_images temper_sound = self.p_shield_sound if damage > 0: poof = self.damage_images temper_sound = self.p_damage_sound self.hud.set_blip_value('player.health', self.p_unit.health) # New in pygame 1.8.0: point = pygame.sprite.collide_mask(sprite, bullet) if not was_alive: break if (point is not None) and (not self.particle_ban): particle = Entity(self.app, 'particle', poof, part_speed, part_angle, self.particles, part_health, None, None, anim_done_remove=True, temper_sound=temper_sound) particle.temper = 1 # start particle death x1, y1 = sprite.get_pos() # top left x = x1 + point[0] - particle.rect.width / 2 y = y1 + point[1] - particle.rect.height / 2 particle.set_xy(x, y) self.particles.add(particle) # if pygame.sprite.spritecollideany(self.p_unit, # self.e_bullet_swarm): # self.p_unit.set_hit(1) # self.hud.set_blip_value('player.health', # self.p_unit.health) # if there are no enemys left, go to the next stage def check_done(self): if not self.swarm: if self.stage.is_last_stage(): if not self.won: self.won = True # TODO: make ending screen # self.app.music_name = 'victory.ogg' # if self.app.music_name == 'intro.ogg': # self.app.continue_music() # force song change self.app.music_name = None # stop repeating self.app.check_music() # apply None to loop self.app.queue_music('victory.ogg', 1) if not self.won: self.stage.next_stage() if self.stage_e_bullet_odds > 15: self.stage_e_bullet_odds -= 15 self.generate_enemies() # checks to see if we can expand the ranges of the bots so its nice # and.... umm... nice. def check_rows(self): if self.tock % 20 == 0: # simple sorting algorithm to find the highest values xmin = self.world_rect.left xmax = self.world_rect.right highest = xmin lowest = xmax for enemy in self.swarm: if enemy.get_range()[1] > highest: highest = enemy.get_range()[1] if enemy.get_range()[0] < lowest: lowest = enemy.get_range()[0] highest = xmax - highest lowest = lowest - xmin if highest != 0 or lowest != 0: # makes things |--| this much more efficient for enemy in self.swarm: erange = enemy.get_range() enemy.set_range(erange[0]-lowest, erange[1]+highest) # major hack just to get this thing playable..... sorry def again(self): if self.hud.get_blip_value('player.health') <= 0: self.particle_ban = True if self.p_unit.get_is_decayed(): self.particle_ban = True # also wait for particles to finish for prettier ending if len(self.particles) < 1: if self.wait_stop_count < 0: print("player unit decayed, counting down to menu") self.wait_stop_count = 0 # return False if self.wait_stop_count >= 0: self.wait_stop_count += 1 if self.wait_stop_count > self.wait_stop_max: return False if self.won: if self.wait_stop_count < 0: print("won game, counting down to menu") self.wait_stop_count = 0 return True # this is called if the player initiates shooting def pshoot(self): # sx = self.p_unit.rect.centerx - # self.p_shot_image.rect.width / 2 # sy = self.p_unit.rect.top + # self.p_shot_image.rect.height * .75 if self.p_unit.get_is_alive(): self.p_unit.shoot(self.p_shot_image, self.p_bullet_swarm) # self.p_unit.shoot_from(self.p_shot_image, # self.p_bullet_swarm, # sx, sy, self.p_unit.angle) def draw_bullets(self): self.p_bullet_swarm.draw(self.screen) self.e_bullet_swarm.draw(self.screen) def draw_hud(self): if self.tock % 5 == 0: self.hud.update() self.hud.draw(self.screen) # Goes through all the objects and makes each of them move as # necessary def tick(self): self.bend_y += self.bend_rate bend_max = 5.0 if self.bend_rate < 0.0: self.bend_rate -= .02 else: self.bend_rate += .02 if ((self.bend_y > self.p_start_y + bend_max) or (self.bend_y < self.p_start_y)): if self.bend_rate < 0.0: self.bend_rate = .02 self.bend_y = float(self.p_start_y) else: self.bend_rate = -.02 self.bend_y = float(self.p_start_y) + bend_max self.p_unit.set_xy(self.p_unit.get_pos()[0], int(self.bend_y+.5)) self.p_bullet_swarm.update() self.swarm.update() self.e_bullet_swarm.update() ###################### # Here are a bunch of metafunctions. # I break it up so its really easy to add new features, # like if we ant a counter? add something to check() and draw(). # All of these are called once per frame. def check(self): self.check_done() self.test_collision() self.check_rows() self.bg.update() if self.p_unit.get_is_alive(): self.swarm.shoot(self.e_shot_image, self.e_bullet_swarm) self.p_unit.update() for particle in self.particles: particle.update() def draw(self): self.screen.fill(self.bg.bg_color) # if self.world_rect is not None: # self.screen.fill((64, 64, 64), self.world_rect) self.bg.draw(self.screen) self.draw_bullets() self.draw_player_units() self.emove() self.particles.draw(self.screen) self.draw_hud() # if self.p_unit is not None: # if self.p_unit.rect is not None: # self.screen.fill((128, 128, 128), self.p_unit.rect) # if self.mouse_rect is not None: # self.screen.fill((255, 255, 255), self.mouse_rect) # if self.temp_rect is not None: # self.screen.fill((128, 0, 0), self.temp_rect) # does just what it sounds like..... def clear_screen(self): self.screen.fill(self.bg.bg_color) # pygame.display.flip() # for debugging info mostly def dispvars(self): print("The Enemy SpriteGroup size is:" + str(len(self.swarm.sprites()))) print("The Player Bullet Array size is:" + str(len(self.p_bullet_swarm.sprites()))) print("The Enemy Bullet Array size is:" + str(len(self.e_bullet_swarm.sprites()))) # does lots and lots of stuff, it really needs to be cleaned up def process_events(self, events): # print("input: self.p_unit.rect: " + str(self.p_unit.rect)) xmin = self.world_rect.left xmax = self.world_rect.right smooth_scroll_var1 = 10 smooth_scroll_var2 = 2 pygame.event.pump() # redraw Window so OS knows not frozen self.app.check_music() pause_menu_strings = ["RESUME", "ABOUT", "HELP", "EXIT"] if self.won: pause_menu_strings.insert(0, self.won_msg) for event in events: if event.type == QUIT: self.on_exit() sys.exit(0) if event.type == pygame.MOUSEMOTION: pygame.event.get() prev_pos = self.p_unit.get_pos() tempx = (pygame.mouse.get_pos()[0] - self.p_unit.rect.width / 2) # *Just to make sure we don't get the ship way out: if tempx + self.p_unit.rect.width > xmax: # if its outside the world, # just stick it as far as possible self.p_unit.set_xy(xmax - self.p_unit.rect.width, prev_pos[1]) elif tempx < xmin: self.p_unit.set_xy(xmin, prev_pos[1]) elif abs(tempx-self.p_start_x) > \ smooth_scroll_var1: # smooth scrolling if the mouse gets far # from the ship self.p_unit.set_xy( prev_pos[0] + (tempx-prev_pos[0]) / smooth_scroll_var2, prev_pos[1]) else: # if it gets down to this point, # we've passed all sanity checks so just move it self.p_unit.set_xy(tempx, prev_pos[1]) elif event.type == pygame.MOUSEBUTTONDOWN: self.pshoot() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_q: self.menus.show_dialog(pause_menu_strings) if event.key == pygame.K_p: self.menus.show_dialog(pause_menu_strings) if event.key == pygame.K_ESCAPE: self.menus.show_dialog(pause_menu_strings) # keyboard controls if event.key == pygame.K_LEFT: self.leftkeydown = 1 if event.key == pygame.K_RIGHT: self.rightkeydown = 1 if event.key == pygame.K_SPACE: self.pshoot() elif event.type == pygame.KEYUP: if event.key == pygame.K_LEFT: self.leftkeydown = 0 if event.key == pygame.K_RIGHT: self.rightkeydown = 0 elif event.type == pygame.USEREVENT: if event.code == pygame.USEREVENT_DROPFILE: print("Tried to open file on MacOS (this should" + " never happen:") print(" " + str(event)) else: # should be event.code 0 self.app.continue_music() print("music queue ended in game:") if event.code != 0: print("unknown USEREVENT event.code: " + str(event.code)) if self.leftkeydown: self.p_unit.move_one(-1, self.world_rect) if self.rightkeydown: self.p_unit.move_one(1, self.world_rect) pygame.event.clear() #################################################################### def start(self, menus): self.won = False self.particle_ban = False self.wait_stop_count = -1 # -1 means do not count down to menu self.menus = menus p_speed = 10 self.p_unit = Entity(self.app, 'pship', self.p_unit_images, p_speed, 90.0, self.p_swarm, self.p_max_health, self.explosion_images, self.particles, ex_sound = self.p_ex_sound) self.p_unit.shoot_sound = self.p_shoot_sound print("Clearing vars...") self.clear_vars() # does reset player unit (p_unit) position self.p_swarm.add(self.p_unit) self.p_unit.set_xy(self.p_start_x, self.p_start_y) print("Starting main event loop...") self.loop() # Yeah see this one does all of the work def loop(self): # Start loop REFRESH_TIME = self.app.get_fps() * 3 while (not self.menus.get_bool('exit')) and (self.again()): # Refresh screen periodically if self.tock >= REFRESH_TIME: # self.clear_screen() self.tock = 0 self.tock += 1 # Check everythign and see if changes need to be made self.check() # Draw bullets self.draw() # Move everything self.tick() # Initiate input function self.process_events(pygame.event.get()) # applies the smart screen updating pygame.display.update() # TODO: ? pygame.display.update(self.enemylist) # self.enemylist = [] # Pauses and waits timeittook = self.app.clock.tick(self.app.get_fps())
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 playGame(character1, character2): pygame.init() pygame.mixer.init() pygame.mixer.music.load("Sound/07 - The Raising Fighting Spirit.ogg") #Background music "The Rising Fighting Spirit":http://downloads.khinsider.com/game-soundtracks/album/naruto-original-soundtrack-1 pygame.mixer.music.play(-1) displaysurf = pygame.display.set_mode((WIDTH, HEIGHT)) clock = pygame.time.Clock() player1=Character(PLAYER1_CONTROLS, IMAGES[character1], SOUNDS[character1], PLAYER1_POSITION) player2=Character(PLAYER2_CONTROLS, IMAGES[character2], SOUNDS[character2], PLAYER2_POSITION) HUD1_IMAGES=HUD_IMAGES.copy() HUD1_IMAGES["icon"]=IMAGES[character1]["icon"] HUD2_IMAGES=HUD_IMAGES.copy() HUD2_IMAGES["icon"]=IMAGES[character2]["icon"] player1_hud=Hud(HUD1_IMAGES, LEFT_HUD_POSITION) player2_hud=Hud(HUD2_IMAGES, RIGHT_HUD_POSITION) player2_hud.flip() background=load_image("Background/training_background.png") #http://spritedatabase.net/game/1889 background=pygame.transform.scale(background, (WIDTH, HEIGHT)) player1_wins=load_image("Background/player1wins.png") #Used the folowing website to generate the win signs: http://www.dafont.com/ninja-naruto.font player2_wins=load_image("Background/player2wins.png") pygame.display.set_caption('Pybrawl') game_over=False while True: # main game loop displaysurf.blit(background, (0,0)) clock.tick(FPS) for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() elif event.type == KEYDOWN and event.key == K_RETURN and game_over: return if player1.health==0: game_over=True pygame.mixer.music.stop() displaysurf.blit(player2_wins, (172, 200)) if player2.health==0: game_over=True pygame.mixer.music.stop() displaysurf.blit(player1_wins, (172, 200)) keys_status=pygame.key.get_pressed() if game_over: keys_status=[False for i in keys_status] player1.update(keys_status) player2.update(keys_status) collide(player1, player2) keep_inside(player1) keep_inside(player2) if player1.rect.centerx < player2.rect.centerx: player1.direction="right" player2.direction="left" else: player1.direction="left" player2.direction="right" player1_hud.update(player1.health/player1.max_health, player1.mana/player1.max_mana) player2_hud.update(player2.health/player2.max_health, player2.mana/player2.max_mana) player1.draw(displaysurf) player2.draw(displaysurf) player1_hud.draw(displaysurf) player2_hud.draw(displaysurf) pygame.display.update()
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
class World (object): def __init__(self): super(World, self).__init__() self.frames = 1 # this is normal difficulty by default # easy would prolly be .7ish and hard.. 1.3 or so? self.difficulty = 0.7 self.spawnFreq = 10 self.scrollPosition = 0 self.scrollSpeed = 3 self.endPosition = FRAMES_UNTIL_BOSS * self.scrollSpeed self.startScreen = True self.helpScreen = False self.difficultyScreen = False self.bossMode = False self.gameOver = False self.winScreen = False self.score = 0 self.call_popcorn = 0 self.boss_music=False self.holdingLeftMouseButton = False #for keeping track of for the win screen! self.numEnemiesAppeared = 0 self.numEnemiesDestroyed = 0 self.numViruses = 0 self.numWorms = 0 self.numPopUps = 0 self.playerGroup = pygame.sprite.GroupSingle() self.enemies = pygame.sprite.Group() self.pickups = pygame.sprite.Group() self.bullets = pygame.sprite.Group() self.mines = pygame.sprite.Group() self.backgrounds = pygame.sprite.Group() self.spawnBkg() # sprite groups listed in draw order (lowest sprite get drawn first) self.spriteGroups = [self.backgrounds, self.mines, self.pickups, self.bullets, self.enemies, self.playerGroup] self.hud = Hud() def spawnWorld(self): self.StartScreen = False playerPos = (PLAY_WIDTH / 2, SCREEN_HEIGHT - 50) pygame.mouse.set_pos(playerPos) self.player = Player(self, playerPos) self.playerGroup.add(self.player) pygame.mixer.music.load("data/music/Main.mp3") pygame.mixer.music.play() self.hud.createHudElements() self.frames = 1 self.scrollPosition = 0 self.scrollSpeed = 3 def spawnBkg(self): bkg = Bkg() self.backgrounds.add(bkg) def spawnCtrl(self): ctrl = Ctrl() self.pickups.add(ctrl) def spawnAlt(self): alt = Alt() self.pickups.add(alt) def spawnDel(self): d = Del() self.pickups.add(d) def spawnVirus(self, position): self.numEnemiesAppeared += 1 enemy = Virus(position) self.enemies.add(enemy) def spawnDoubleVirus(self, position): self.numEnemiesAppeared += 1 enemy = DoubleVirus(self, position) self.enemies.add(enemy) def spawnTripleVirus(self): self.numEnemiesAppeared += 1 enemy = TripleVirus(self) self.enemies.add(enemy) def spawnWorm(self): self.numEnemiesAppeared += 1 position1 = random.randint(195,PLAY_WIDTH-50) position2 = 10 position = position1, position2 enemy = Worm(position,'head') self.enemies.add(enemy) for i in range(random.randint(1,5)): position1 -= 32 position = position1, position2 enemy = Worm(position,'body') self.enemies.add(enemy) position1 -= 32 position = position1, position2 enemy = Worm(position,'tail') self.enemies.add(enemy) def spawnPopup(self): self.numEnemiesAppeared += 1 enemy = Popup() while len(pygame.sprite.spritecollide(enemy, self.playerGroup, False)) > 0: enemy = Popup() self.enemies.add(enemy) def spawnBoss(self): self.boss_music=True self.numEnemiesAppeared += 1 pygame.mixer.music.load("data/music/Boss.mp3") pygame.mixer.music.play(-1) self.boss = Boss((PLAY_WIDTH / 2, -200)) self.enemies.add(self.boss) for tentacle in self.boss.tentacles: for link in tentacle.links: self.enemies.add(link) def spawnSafe(self): safe = SafeMode() self.pickups.add(safe) def leftMouseButtonDown(self): self.holdingLeftMouseButton = True self.player.shoot(self.bullets) def leftMouseButtonUp(self): self.holdingLeftMouseButton = False def rightMouseButtonDown(self): self.player.quarantine(self.mines) sound = pygame.mixer.Sound("data/sounds/minedeploy.wav") sound.set_volume(.25) sound.play() def enemy_popcorn(self): if len(self.enemy_list)==1: self.call_popcorn=0 else: self.enemy_list[1].takeHit(self.enemy_list[1].health) self.enemy_list.remove(self.enemy_list[1]) def destroy_all_enemies(self): self.enemy_list=[0] if self.player.destroyAllEnemies: self.player.after_destroy_all() sound = pygame.mixer.Sound("data/sounds/destroyall.wav") sound.play() for enemy in self.enemies: if enemy.typeofenemy == 'boss' or enemy.typeofenemy == 'link': enemy.takeHit(1) else: if enemy.typeofenemy is 'virus': self.numViruses += 1 if enemy.typeofenemy is 'worm': self.numWorms += 1 if enemy.typeofenemy is 'pop up window': self.numPopUps += 1 self.numEnemiesDestroyed += 1 self.enemy_list.insert(1,enemy) #enemy.takeHit(enemy.health) self.call_popcorn=self.frames def update(self): if self.holdingLeftMouseButton: if self.frames % 5 == 0: self.player.shoot(self.bullets) for group in self.spriteGroups: group.update() self.hud.update(self) # Test player-enemy collisions for enemy in pygame.sprite.spritecollide(self.player, self.enemies, False): if not enemy.dead and not enemy.animName == 'spawn': if not enemy.typeofenemy == 'boss': enemy.takeHit(enemy.health) if not self.player.invincible: self.player.decrease_life() self.score -= 100 if enemy.dead: if enemy.typeofenemy is 'virus': self.numViruses += 1 self.numEnemiesDestroyed += 1 if enemy.typeofenemy is 'worm': self.numWorms += 1 self.numEnemiesDestroyed += 1 if enemy.typeofenemy is 'pop up window': self.numPopUps += 1 self.numEnemiesDestroyed += 1 # Test player-pickup collisions for pickup in pygame.sprite.spritecollide(self.player, self.pickups, False): pickup.on_collision(self.player) sound = pygame.mixer.Sound("data/sounds/keypickup.wav") sound.play() # Test enemy-playerBullet collisions for enemy, bullets in pygame.sprite.groupcollide(self.enemies, self.bullets, False, False).items(): for bullet in bullets: enemy.collideWithBullet(bullet) if enemy.dead: self.player.increase_powerup(5) if enemy.typeofenemy == "worm": self.numWorms += 1 self.numEnemiesDestroyed += 1 self.score += 25 elif enemy.typeofenemy == "virus": self.numViruses += 1 self.numEnemiesDestroyed += 1 self.score += 10 elif enemy.typeofenemy == "popup": self.numEnemiesDestroyed += 1 self.numPopUps += 1 self.score += 15 # Test enemy-mine collisions for mine in self.mines: if mine.exploding: for enemy in pygame.sprite.spritecollide(mine, self.enemies, False): enemy.takeHit(1) if enemy.dead: if enemy.typeofenemy is 'virus': self.numViruses += 1 self.numEnemiesDestroyed += 1 if enemy.typeofenemy is 'worm': self.numWorms += 1 self.numEnemiesDestroyed += 1 if enemy.typeofenemy is 'pop up window': self.numPopUps += 1 self.numEnemiesDestroyed += 1 # Check enemies offscreen, popups doing damage for enemy in self.enemies: if enemy.rect.top > SCREEN_HEIGHT and not enemy.typeofenemy == 'link': enemy.kill() self.score -= 10 self.player.decrease_health(1) sound = pygame.mixer.Sound("data/sounds/CPUload.wav") sound.play() if enemy.typeofenemy == "popup": if enemy.frame % 20 == 0: self.score -= 1 # Check bullets offscreen for bullet in self.bullets: if bullet.rect.bottom < 0: bullet.kill() # Check backgrounds offscreen for bkg in self.backgrounds: if bkg.rect.top > SCREEN_HEIGHT: bkg.kill() if self.frames % 360 == 0: self.spawnBkg() if self.spawnFreq is not 1: if self.frames % (500) == 0: if self.spawnFreq <= 1: self.spawnFreq = 1 elif self.spawnFreq > 1: self.spawnFreq -= self.difficulty # Spawn more enemies baseSpawnRate = (self.spawnFreq * 5 + random.randint(1, 5)) #print self.difficulty, baseSpawnRate, self.spawnFreq if not self.bossMode: if self.frames % baseSpawnRate < 1: seed = random.randint(1, 10) if(seed < 7): self.spawnVirus(0) elif(seed < 10): self.spawnDoubleVirus(0) else: self.spawnTripleVirus() if self.frames % (baseSpawnRate * random.randint(3, 6)) < 1: self.spawnWorm() if self.frames % (baseSpawnRate * random.randint(2, 5)) < 1: self.spawnPopup() if self.frames % (baseSpawnRate * random.randint(18, 21)) < 1: self.player.destroyAllEnemies = True if self.frames % (baseSpawnRate * random.randint(1, 4)) < 1: self.spawnCtrl() if self.frames % (baseSpawnRate * random.randint(5, 8)) < 1: self.spawnAlt() if self.frames % (baseSpawnRate * random.randint(9, 12)) < 1: self.spawnDel() if self.frames % (baseSpawnRate * random.randint(4, 7)) < 1: self.spawnSafe() # Check if main music has ended, and loop music should start if not pygame.mixer.music.get_busy(): if not self.boss_music: pygame.mixer.music.load("data/music/Mainloop.mp3") pygame.mixer.music.play(-1) elif self.frames == FRAMES_UNTIL_BOSS + MUSIC_LENGTH_BOSS: pygame.mixer.music.load("data/music/Bossloop.mp3") pygame.mixer.music.play(-1) #Check for calling enemy_popcorn if self.call_popcorn != 0 and self.call_popcorn<self.frames-10: self.enemy_popcorn() # Check gameover if self.player.lives == 0: self.gameOver = True pygame.mixer.music.stop() # Check win screen! if self.bossMode and self.boss.dead and self.boss.anim.done: if not self.winScreen: self.numEnemiesDestroyed += 1 self.winScreen = True # Scroll level self.scrollPosition += self.scrollSpeed self.scrollPosition = min(self.scrollPosition, self.endPosition) if self.scrollPosition == self.endPosition and not self.bossMode: self.bossMode = True self.spawnBoss() self.frames += 1 def draw(self, screen): for group in self.spriteGroups: for sprite in group: sprite.draw(screen) self.hud.draw(screen, PLAY_WIDTH)
class Game_Client2: def __init__(self, width, height, gui, stack): self.logger = logging.getLogger('Client') hdlr = logging.FileHandler('tankwarz_client.log') formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s') hdlr.setFormatter(formatter) self.logger.addHandler(hdlr) self.logger.setLevel(logging.INFO) self.running = False self.started = False self.connected = False self.alive = True self.tank = None self.switch_sound = pyglet.media.load("res/sounds/switch28.wav", streaming=False) self.bg_sound = pyglet.media.load("res/music/bgmusic2.wav", streaming=True) self.bg_loop = pyglet.media.SourceGroup(self.bg_sound.audio_format, None) self.bg_loop.loop = True self.bg_loop.queue(self.bg_sound) self.bg_player = pyglet.media.Player() self.bg_player.volume = 0.05 self.bg_player.queue(self.bg_loop) self.game_map = None self.minimap = None self.hud = None self.camera = None self.cl_id = int(time.time()) self.CLIENT_ID = int(time.time()) self.gui = gui self.stack = stack self._client = legume.Client() self._client.OnMessage += self.message_handler self._client.OnConnectRequestAccepted += self.on_connect_accepted self._client.OnConnectRequestRejected += self.on_connect_rejected self._client.OnError += self.on_connection_error self._client.OnDisconnect += self.on_disconnect self.update_timer = time.time() self.time_label = pyglet.text.HTMLLabel( '<font face="Arial" size="50" color="white"><b>00:00</b></font>', x=Game.WIDTH // 2, y=Game.HEIGHT - 12, anchor_x='center', anchor_y='center', batch=hud_batch) self.score = 0 create_walls() pyglet.clock.schedule_interval(self.update, 1.0 / 60) def on_connect_accepted(self, sender, args): self.connected = True self.logger.info("Connection Accepted") if not self.started: self.logger.info("Creating New Tank") cl = ClientStart() cl.client_id.value = self.CLIENT_ID self._client.send_reliable_message(cl) message = TankCreate() message.id.value = self.cl_id x = random.randint(660, 2230) y = random.randint(350, 2500) message.pos_x.value = x message.pos_y.value = y message.rot.value = 0 message.l_vel_x.value = 0 message.l_vel_y.value = 0 message.a_vel.value = 0 color_value = random.randint(1, 5) message.color.value = color_value message.client_id.value = self.CLIENT_ID self._client.send_reliable_message(message) self.started = True def on_connect_rejected(self, args): self.logger.info("Connection Rejected") def on_disconnect(self, sender, args): self.logger.info("You have been disconnected") def on_connection_error(self, sender, error_message): self.logger.error(error_message) self.logger.info("Attempting to reconnect") self.connect(host) def start_game(self): self.logger.info("STARTGAME") self.tank = tanks[self.cl_id] self.hud = Hud() self.camera = Camera() self.camera.init_gl(Game.WIDTH, Game.HEIGHT) self.on_resize = self.camera.on_resize self.bg_player.play() self.running = True self.gui.remove(self.stack) def update_camera_player(self): self.camera.left = self.tank.sprite.position[0] - 640 self.camera.right = self.camera.left + self.camera.width self.camera.bottom = self.tank.sprite.position[1] - 350 self.camera.top = self.camera.bottom + self.camera.height if self.camera.left < 0: self.camera.left = 0 self.camera.right = self.camera.left + Game.WIDTH elif self.camera.right > global_vars.full_width: self.camera.right = global_vars.full_width self.camera.left = self.camera.right - Game.WIDTH if self.camera.bottom < 0: self.camera.bottom = 0 self.camera.top = Game.HEIGHT elif self.camera.top > global_vars.full_height: self.camera.top = global_vars.full_height self.camera.bottom = self.camera.top - Game.HEIGHT def switch1(self): if self.tank.ammo_type == Projectile.Ammo_Type.AP: self.switch_sound.play() self.tank.ammo_type = Projectile.Ammo_Type.REGULAR self.hud.bullet1_overlay.color = (40, 40, 40, 200) self.hud.bullet1_sprite.opacity = 255 self.hud.bullet1_text.color = (255, 255, 255, 255) self.hud.bullet1_ammo.color = (255, 255, 255, 255) self.hud.bullet2_overlay.color = (40, 40, 40, 100) self.hud.bullet2_sprite.opacity = 100 self.hud.bullet2_text.color = (255, 255, 255, 100) self.hud.bullet2_ammo.color = (255, 255, 255, 100) msg = TankSwitchAmmo() msg.id.value = self.tank.idn msg.ammo_type.value = self.tank.ammo_type self.send_reliable_message_safely(msg) def switch2(self): if self.tank.ammo_type == Projectile.Ammo_Type.REGULAR: self.switch_sound.play() self.tank.ammo_type = Projectile.Ammo_Type.AP self.hud.bullet1_overlay.color = (40, 40, 40, 100) self.hud.bullet1_sprite.opacity = 100 self.hud.bullet1_text.color = (255, 255, 255, 100) self.hud.bullet1_ammo.color = (255, 255, 255, 100) self.hud.bullet2_overlay.color = (40, 40, 40, 200) self.hud.bullet2_sprite.opacity = 255 self.hud.bullet2_text.color = (255, 255, 255, 255) self.hud.bullet2_ammo.color = (255, 255, 255, 255) msg = TankSwitchAmmo() msg.id.value = self.tank.idn msg.ammo_type.value = self.tank.ammo_type self.send_reliable_message_safely(msg) def rotate_left_turret(self): self.tank.rotateTurret(Direction.LEFT) msg = TankCommand() msg.id.value = self.cl_id msg.command.value = Tank.Command.TURRET_ROTATE_LEFT self.send_message_safely(msg) def rotate_right_turret(self): self.tank.rotateTurret(Direction.RIGHT) msg = TankCommand() msg.id.value = self.cl_id msg.command.value = Tank.Command.TURRET_ROTATE_RIGHT self.send_message_safely(msg) def stop_rotate_turret(self): self.tank.stopRotateTurret() msg = TankCommand() msg.id.value = self.cl_id msg.command.value = Tank.Command.STOP_ROTATING_TURRET self.send_message_safely(msg) def move_forward(self): self.tank.move(Direction.FORWARD) msg = TankCommand() msg.id.value = self.cl_id msg.command.value = Tank.Command.MOVE_FORWARD self.send_message_safely(msg) def move_backward(self): self.tank.move(Direction.BACKWARD) msg = TankCommand() msg.id.value = self.cl_id msg.command.value = Tank.Command.MOVE_BACKWARD self.send_message_safely(msg) def stop(self): self.tank.stop() msg = TankCommand() msg.id.value = self.cl_id msg.command.value = Tank.Command.STOP_MOVING self.send_message_safely(msg) def rotate_right(self): self.tank.rotate(Direction.RIGHT) msg = TankCommand() msg.id.value = self.cl_id msg.command.value = Tank.Command.ROTATE_RIGHT self.send_message_safely(msg) def rotate_left(self): self.tank.rotate(Direction.LEFT) msg = TankCommand() msg.id.value = self.cl_id msg.command.value = Tank.Command.ROTATE_LEFT self.send_message_safely(msg) def stop_rotate(self): self.tank.stopRotating() msg = TankCommand() msg.id.value = self.cl_id msg.command.value = Tank.Command.STOP_ROTATING self.send_message_safely(msg) def fire(self): if self.tank.isReloading: return self.tank.reloading = True msg = TankFire() msg.id.value = self.cl_id msg.projectile_id.value = int(time.time()) self.tank.fire(msg.projectile_id.value) self.send_message_safely(msg) if self.tank.ammo_type == Projectile.Ammo_Type.REGULAR and self.tank.ammo1 <= 0 or self.tank.ammo_type == Projectile.Ammo_Type.AP and self.tank.ammo2 <= 0: return Tank.firing_sound.play() Tank.reloading_sound.play() self.hud.update(self.tank.ammo1, self.tank.ammo2) def send_message_safely(self, msg): try: self._client.send_message(msg) except legume.exceptions.ClientError: self.connected = False if self._client.connected: self._client.send_message(msg) def send_reliable_message_safely(self, msg): try: self._client.send_message(msg) except legume.exceptions.ClientError: self.connected = False if self._client.connected: self._client.send_reliable_message(msg) def update(self, dt): dtt = 1.0 / 60.0 space.step(dtt) for tank in tanks.values(): tank.update(dtt) for p in projectiles.values(): p.update(dtt) def message_handler(self, sender, message): if legume.messages.message_factory.is_a(message, 'TankCreate'): if tanks.get(message.id.value) is None: tanks[message.id.value] = Tank.create_from_message(message) if message.id.value == self.cl_id: self.logger.info("Creating self") self.start_game() else: tanks[message.id.value].update_from_message(message) elif legume.messages.message_factory.is_a(message, 'TankUpdate'): if tanks.get(message.id.value) is None: tanks[message.id.value] = Tank.create_from_message(message) if message.id.value == self.cl_id: self.logger.info("Creating self") self.start_game() else: tanks[message.id.value].update_from_message(message) elif legume.messages.message_factory.is_a(message, 'GameOver'): if message.winner_id.value == self.CLIENT_ID: game_over_bg = glooey.Background() game_over_bg.image = pyglet.image.load( "res/PNG/GUI/overlay.png") game_over_bg.custom_alignment = 'fill' self.gui.add(game_over_bg) game_over_vbox = glooey.VBox() game_over_vbox.custom_alignment = 'center' game_over_label = TitleLabel("You Win!") score_label = SubtitleLabel("Your score is %d" % message.score.value) score_label.custom_font_size = 10 ex_button = Exit_Button() game_over_vbox.add(game_over_label) game_over_vbox.add(score_label) game_over_vbox.add(ex_button) self.gui.add(game_over_vbox) else: game_over_bg = glooey.Background() game_over_bg.image = pyglet.image.load( "res/PNG/GUI/overlay.png") game_over_bg.custom_alignment = 'fill' self.gui.add(game_over_bg) game_over_vbox = glooey.VBox() game_over_vbox.custom_alignment = 'center' game_over_label = TitleLabel("You Lose") ex_button = Exit_Button() game_over_vbox.add(game_over_label) game_over_vbox.add(ex_button) self.gui.add(game_over_vbox) elif legume.messages.message_factory.is_a(message, 'UpdateTime'): time = message.time.value self.time_label.text = '<font face="Arial" size="50" color="white"><b>%s</b></font>' % ( time) elif legume.messages.message_factory.is_a(message, 'TankFireClient'): tank = tanks[message.id.value] if tank.idn != self.tank.idn: tank.fire(message.projectile_id.value) elif legume.messages.message_factory.is_a(message, 'TankSwitchAmmo'): tank = tanks[message.id.value] tank.ammo_type = message.ammo_type.value elif legume.messages.message_factory.is_a(message, 'TankHit'): tank = tanks[message.id.value] projectile = projectiles.get(message.projectile_id.value) if projectile is not None: tank.hit(projectile.damage) if tank.idn == self.tank.idn and not self.tank.alive and not self.tank.destroyed: self.tank.destroyed = True game_over_bg = glooey.Background() game_over_bg.image = pyglet.image.load( "res/PNG/GUI/overlay.png") game_over_bg.custom_alignment = 'fill' self.gui.add(game_over_bg) game_over_vbox = glooey.VBox() game_over_vbox.alignment = 'center' game_over_label = TitleLabel("You have been eliminated") retry_button = PlayAgain_Button() ex_button = Exit_Button() def on_click(widget): self.gui.remove(game_over_bg) self.gui.remove(game_over_vbox) self.gui.add(stack) self._client.disconnect() self.cl_id = random.randint(1, 100000) self.started = False self.running = False retry_button.on_click = on_click game_over_vbox.add(game_over_label) game_over_vbox.add(retry_button) game_over_vbox.add(ex_button) self.gui.add(game_over_vbox) projectile.destroy() projectiles.pop(projectile.idn) elif legume.messages.message_factory.is_a(message, 'ProjectileDestroy'): projectile = projectiles.get(message.projectile_id.value) if projectile is not None: projectile.destroy() projectiles.pop(projectile.idn) elif legume.messages.message_factory.is_a(message, 'ProjectileCreate'): if projectiles.get(message.id.value) is None: projectiles[message.id.value] = Projectile.create_from_message( message) else: projectiles[message.id.value].update_from_message(message) elif legume.messages.message_factory.is_a(message, 'ProjectileUpdate'): if projectiles.get(message.id.value) is None: projectiles[message.id.value] = Projectile.create_from_message( message) else: projectiles[message.id.value].update_from_message(message) elif legume.messages.message_factory.is_a(message, 'MapCreate'): l = message.l.value w = message.w.value seed_a = message.seed_a.value seed_b = message.seed_b.value self.game_map = Game_Map.generate_map(l, w, seed_a, seed_b) self.minimap = Minimap(self.game_map, self.cl_id) else: self.logger.info('Message: %s' % message) def connect(self, host='localhost'): self._client.connect((host, PORT)) def send_update(self): if self.tank is not None: self.client.send_message_safely(self.tank.get_message()) for projectile in projectiles.values(): self.client.send_message_safely(projectile.get_message()) def go(self, args): try: if time.time() > self.update_timer + UPDATE_RATE: self.update_timer = time.time() self._client.update() except: self.running = False
class Character(Sprite): """Representing a character(toon) with its movements, skills, sound effects and hud. attributes -- dictionary that holds the attribute of each character skill_names -- dictionary that holds the skills of each cahracter """ attributes = {"itachi": ATTRIBUTES[0], "sasuke": ATTRIBUTES[1], "suigetsu": ATTRIBUTES[1], "naruto": ATTRIBUTES[0], "jiraiya": ATTRIBUTES[0]} skill_names = {"itachi": {"throw": "throw_shuriken", "special_1": "amaterasu", "special_2": "katon_goukakyuu"}, "sasuke": {"throw": "throw_lightning", "special_1": "katon_gouryuuka", "special_2": "chidori"}, "suigetsu": {"throw": "throw_explosive_note", "special_1": "suirou", "special_2": "kubikiri_shuriken"}, "naruto": {"throw": "rasengan", "special_1": "rasen_shuriken", "special_2": "kyuubi"}, "jiraiya": {"throw": "throw_kunai", "special_1": "rasengan_original", "special_2": "katon_endan"}} def __init__(self, player, character_name, position=Vec2D(0, 0)): """Initialize all member variables of character. damage -- numeric value, the amount of harm dealt through normal_attack lock -- bool varible, says if the character is currently casting an ability or motion action -- string, the action currently being excecuted by the character """ pygame.sprite.Sprite.__init__(self) self.name = character_name self.damage = 100 self.attribute = self.attributes[self.name] self.lock = True self.action = "introduction" self.enemy_position = pygame.Rect(0, 0, 0, 0) if not isinstance(position, Vec2D): self.position = Vec2D(position) else: self.position = position if player == 1: self.controls = P1_CONTROLS self.direction = "Right" elif player == 2: self.controls = P2_CONTROLS self.direction = "Left" else: raise SystemExit("player argument should be either 1 or 2") self.movements = {} for action in get_all_movements(self.name): self.movements[action] = Movement(self.name, action) self.skills = SkillManager() self.hud = Hud(player, self.name) self.sound_effects = SoundManager(self.name) self.update({}) def update(self, input_list): """Update the current character action, movement, position, sound effect and hud. Character.update(): return None """ self.update_action(input_list) self.movements[self.action].update(pygame.time.get_ticks()) self.image, self.rect = self.movements[self.action].get_image() self._adjust_direction() self._adjust_position() if (self.direction == "Left" and self.action in ["take_damage", "normal_attack"]): self.position -= self.movements[self.action].force else: self.position += self.movements[self.action].force self.rect.topleft = self.position if self.lock: if self.movements[self.action].done: self.movements[self.action].reset() self.lock = False if self.action in self.skill_names[self.name]: skill = Skill(self) self.skills.add(skill) self.hud.mana.value -= skill.mana_cost self.sound_effects.stop() self.sound_effects[self.action].play() self.hud.update() def update_action(self, input_list): """Update character's action given an input list. If a skill is to be cast check the mana bar if it holds enought mana and play the corresponding sound effect. Character.update_action(input_list): return None """ action_taken = False if not self.lock: if input_list[self.controls[0]]: self.action = "move_left" action_taken = True if input_list[self.controls[1]]: self.action = "move_right" action_taken = True if input_list[self.controls[2]]: self.action = "jump" self.lock = True action_taken = True if (input_list[self.controls[3]] and self.hud.mana.value >= Skill.mana_costs["throw"]): self.action = "throw" self.lock = True action_taken = True if input_list[self.controls[4]]: self.action = "normal_attack" self.lock = True action_taken = True if (input_list[self.controls[5]] and self.hud.mana.value >= Skill.mana_costs["special_1"]): self.action = "special_1" self.lock = True action_taken = True if (input_list[self.controls[6]] and self.hud.mana.value >= Skill.mana_costs["special_2"]): self.action = "special_2" self.lock = True action_taken = True if not action_taken: self.action = "stance" def draw(self, surface): """Draw the hud and the character image onto the passed surface. Call the draw methods of Hud and Sprite. Character.draw(surface): return None """ self.hud.draw(surface) super(Character, self).draw(surface) def _adjust_position(self): """Adjust the character position so the bottom side of its rect is at FLOOR_HEIGHT position. Character._adjust_position(): return None Should not be called manually. """ if (self.action != "jump" or self.movements[self.action].current_frame == 0): self.position.y = (DEFAULT_SCREEN_SIZE[1] - FLOOR_HEIGHT - self.rect.height) if self.position.x < 0: self.position.x = 0 elif self.position.x > DEFAULT_SCREEN_SIZE[0] - self.rect.width: self.position.x = DEFAULT_SCREEN_SIZE[0] - self.rect.width elif (self.position.y > (DEFAULT_SCREEN_SIZE[1] - FLOOR_HEIGHT - self.rect.height)): self.position.y = (DEFAULT_SCREEN_SIZE[1] - FLOOR_HEIGHT - self.rect.height) def _adjust_direction(self): """Adjust the character direction so it faces the opponent. This does not hold when the character is moving left or right. Character._adjust_direction(): return None Should not be called manually. """ if (self.direction == "Left" and self.action not in ["move_left", "move_right"]): self.image = pygame.transform.flip(self.image, True, False)