def bersihkanInGame(cont): #disable pulse mode of all sensors of all objects scene = bge.logic.getCurrentScene() print('disabling usePosPulseMode of allObjects') for i in scene.objects: for j in i.sensors: j.usePosPulseMode = False print("removing all objects parent in inGame scene...") for i in scene.objects: i.removeParent() var.tikets = ['inf', 10, 10] var.navigator = None var.waymesh = None var.waypoints = [] try: #removing scene HUD print('removing HUD...') HUD.end() except AttributeError: print('HUD may not exist, ignoring...') #end all of objects of scene print('removing all objects...') for i in scene.objects: if i != cont.owner: i.endObject() # - section of variables cleaning - bersihkan = True if bersihkan == True: pass
def show(lvl): """ Display level on screen @param lvl: Dictionnary containing all information about one \"Level\" object @type lvl: dict @return: - @rtype: void """ assertLevel(lvl) Object.show(lvl["bgItem0"]) Object.show(lvl["bgItem1"]) #showBackground(lvl,lvl["bgItem0"]) #showBackground(lvl,lvl["bgItem1"]) Object.show(lvl["fgItem0"]) Object.show(lvl["fgItem1"]) for a in lvl["enemyList"]: Enemy.show(a) Player.show(lvl["playerItem"]) HUD.show(lvl["HUD"]) return
def draw(self): self.orientWorld() for item in self.simulation.world.all: Render.render(item) HUD.draw(self.zoomedShip) self.drawSidebar()
def nodeInit(self): self.sg = self.view.getSceneGraph() self.coord = CoinNodes.coordinate3Node([(0, 0, 0)]) self.markers = CoinNodes.markerSetNode((1, 0.35, 0.8), 70) self.polygon = coin.SoLineSet( ) #CoinNodes.sensorPolyNode((0.0,0.5,0.0),1) #self.polygon.transparency = 0.7 #self.polygon.linkTo(self.coord) self.switch = coin.SoSwitch() self.empty = coin.SoSeparator() self.sepa = coin.SoSeparator() self.switch.addChild(self.sepa) self.switch.addChild(self.empty) self.switch.whichChild = 0 self.sepa.addChild(self.coord) self.sepa.addChild(self.markers) self.sg.addChild(self.switch) self.info = [ "LMB : add pole", "Del : remove last pole", "I / D : Increase / Decrease degree", "Left CTRL : snap", "Enter : Accept", "Esc : Abort" ] self.Block1 = HUD.textArea() self.Block1.setFont("Sans", 12.0, (0., 0., 0.)) self.Block1.text = self.info + ["Degree : %s" % self.curve.Degree] self.myHud = HUD.HUD() self.myHud.addBlock(self.Block1) self.myHud.add()
class HUDWindow(): def __init__(self, main): #print 'In HUDWindow() __init__' #Create HUD background screen self.hud = HUD() self.main = main #Create canvas on which HUD image will be drawn and load basic image self.canvas = Canvas(self.main, width=HUD_WIDTH, height=HUD_HEIGHT) self.canvas.grid(row=0, column=0) self.image = ImageTk.PhotoImage(self.hud.scope_canvas.display_image) self.canvas_image = self.canvas.create_image(0, 0, anchor=NW, image=self.image) #Call redraw initially self.main.after(1000, self.redraw) def redraw(self): #print 'In HUDWindow() redraw' #TEMP #END TEMP #Create updated HUD image according to current data self.hud.work() redraw_image = ImageTk.PhotoImage(self.hud.scope_canvas.display_image) self.canvas.itemconfig(self.canvas_image, image=redraw_image) #Hang onto new image to avoid garbage collector self.image = redraw_image #Call redraw after delay self.main.after(100, self.redraw)
class TestApp(Label): def __init__(self, **kwargs): super(TestApp, self).__init__(**kwargs) Window.bind(on_key_down=self.onKeyDown) self.key_label = CoreLabel(text='', font_size=15) self.hud = HUD(self.canvas) self.gps_status_label = CoreLabel(text='', font_size=12) self.gps_location_label = CoreLabel(text='', font_size=12) self.uid_label = CoreLabel(text='UID: ', font_size=12) self.my_lat = 0 self.my_lon = 0 self.my_heading = 0 def onKeyDown(self, something, keycode, text, something_else, modifiers, **kwargs): print('The key', keycode, 'have been pressed') print(' - text is %r' % text) print(' - modifiers are %r' % modifiers) self.hud.scope_canvas.camera.setZoom(int(keycode)) if keycode == ENTER: self.hud.myUID = self.hud.data.pickUID(self.hud.myUID) self.uid_label.text = 'UID: ' + str(self.hud.myUID) ###TODO: Include pickUID(keycode) def updateDisplay(self, text): print 'Inside updateDisplay' self.hud.my_lat = self.my_lat self.hud.my_lon = self.my_lon self.hud.my_heading = self.my_heading self.canvas.clear() #Clears canvas for fresh draw self.hud.scope_canvas.paintDisplayBackground( ) #Reinitializes the canvas with HUD background self.hud.work( ) #Retrieves data and draws appropriately on HUD background canvas #TEMPORARY label drawing for debugging purposes with self.canvas: #Display gps_location Color(.5, 1, 0, mode='rgb') self.gps_location_label.refresh() texture = self.gps_location_label.texture texture_size = list(texture.size) Rectangle(pos=(BAR_TEXT_OFFSET + 10, GRAPH_OFFSET_TOP_BOTTOM), texture=texture, size=texture_size) #Display UID Color(.5, 1, 0, mode='rgb') self.uid_label.refresh() texture = self.uid_label.texture texture_size = list(texture.size) Rectangle(pos=(HUD_WIDTH - BAR_TEXT_OFFSET - GRAPH_WIDTH - 100, GRAPH_OFFSET_TOP_BOTTOM - 20), texture=texture, size=texture_size)
def __init__(self, **kwargs): super(TestApp, self).__init__(**kwargs) Window.bind(on_key_down=self.onKeyDown) self.key_label = CoreLabel(text='', font_size=15) self.hud = HUD(self.canvas) self.gps_status_label = CoreLabel(text='', font_size=12) self.gps_location_label = CoreLabel(text='', font_size=12) self.uid_label = CoreLabel(text='UID: ', font_size=12) self.my_lat = 0 self.my_lon = 0 self.my_heading = 0
def subMunculkan(cont): own = cont.owner print('\nend of spawning object') print("..........................................") own['endAdding'] = None #for i in dir(HUD): print(i) HUD.addHUD() #print(scene.objects) #print(bge.logic.getSceneList()) #cekKamus(cont) var.status = 'loadgameobject' #obj.addLookAt() own.endObject()
def init(): global screen, fonts, resolution, camera resx, resy = settings.get_resolution() resolution = [resx, resy] # Create camera camera = Camera([0, 0], 1, resolution) # Create the game screen screen = pygame.display.set_mode(resolution) # Set window info pygame.display.set_icon(screen) pygame.display.set_caption('Solaris') # Generate fonts pygame.font.init() for i in range(0, 10): fonts.append(pygame.font.SysFont('Arial', i * 10)) # Make the main menu global action_listener action_listener = ActionListener() global current_menu current_menu = Menu.main_menu(fonts, resolution, action_listener) global star_systems, nearest_system star_systems = Bodies.generate_systems(10, action_listener) nearest_system = star_systems[0] global player player = Bodies.Player([500, 500], (255, 100, 100), 3, [0, 0], action_listener) global current_hud current_hud = HUD.test_hud(fonts, resolution, action_listener)
def get_newgame(): '''returns the game scene''' scene = Scene() # model model = GameModel() # controller ctrl = GameCtrl(model) # view hud = HUD() view = GameView(model, hud) # set controller in model model.set_controller(ctrl) # add controller scene.add(ctrl, z=1, name="controller") # add view scene.add(hud, z=3, name="hud") scene.add(BackgroundLayer(), z=0, name="background") scene.add(view, z=2, name="view") return scene
def __init__(self, file_path): super(Scene, self).__init__() pygame.mixer.init(44100, -16, 4, 2048) self.position = ['goalkeeper', 'defender', 'midfielder', 'attacker'] self.all_object_list = pygame.sprite.LayeredUpdates() self.selection_circle = [] # Prototype self.left_player = Player() # Prototype self.right_player = Player() # Prototype self.teams = collections.defaultdict(dict) self.field = Object() self.field_border = Object() self.goal = [] self.ball = Ball() self.hud = HUD() self.goal_image = EffectObject() self.formation = {Team_side.LEFT: [1, 4, 3, 3], Team_side.RIGHT: [1, 4, 4, 2]} self.sound_list = dict() # Game config self.game_mode = Game_mode.PvP self.P1_controlled_team = Team_side.LEFT self.P1_controlled_position = 'midfielder' self.P2_controlled_team = Team_side.RIGHT self.P2_controlled_position = 'midfielder' # Load scene's resources self.read_scene(file_path)
def nodeInit(self): self.sg = self.view.getSceneGraph() self.coord = CoinNodes.coordinate3Node([(0,0,0)]) self.markers = CoinNodes.markerSetNode((1,0.35,0.8),70) self.polygon = coin.SoLineSet() #CoinNodes.sensorPolyNode((0.0,0.5,0.0),1) #self.polygon.transparency = 0.7 #self.polygon.linkTo(self.coord) self.switch = coin.SoSwitch() self.empty = coin.SoSeparator() self.sepa = coin.SoSeparator() self.switch.addChild(self.sepa) self.switch.addChild(self.empty) self.switch.whichChild = 0 self.sepa.addChild(self.coord) self.sepa.addChild(self.markers) self.sg.addChild(self.switch) self.info = ["LMB : add pole", "Del : remove last pole", "I / D : Increase / Decrease degree", "Left CTRL : snap", "Enter : Accept", "Esc : Abort"] self.Block1 = HUD.textArea() self.Block1.setFont("Sans", 12.0, (0.,0.,0.)) self.Block1.text = self.info + ["Degree : %s"%self.curve.Degree] self.myHud = HUD.HUD() self.myHud.addBlock(self.Block1) self.myHud.add()
def setTarget(self,target): if not target == None: self.target=target self.mira= HUD.mira(self.img) else: self.target = None self.mira = None
def __init__(self, main): #print 'In HUDWindow() __init__' #Create HUD background screen self.hud = HUD() self.main = main #Create canvas on which HUD image will be drawn and load basic image self.canvas = Canvas(self.main, width=HUD_WIDTH, height=HUD_HEIGHT) self.canvas.grid(row=0, column=0) self.image = ImageTk.PhotoImage(self.hud.scope_canvas.display_image) self.canvas_image = self.canvas.create_image(0, 0, anchor=NW, image=self.image) #Call redraw initially self.main.after(1000, self.redraw)
def __init__(self, **kwargs): super(TestApp, self).__init__(**kwargs) Window.bind(on_key_down=self.onKeyDown) Window.bind(on_touch_down=self.onTouch) #TOUCH CAPABILITY self.touch_count = 0 #TOUCH CAPABILITY DEBUGGING COUNTER self.touch_count_label = CoreLabel( text='', font_size=15) #TOUCH CAPABILITY DEBUGGING COUNTER self.key_label = CoreLabel(text='', font_size=15) self.hud = HUD(self.canvas) self.gps_status_label = CoreLabel(text='', font_size=12) self.gps_location_label = CoreLabel(text='', font_size=12) self.uid_label = CoreLabel(text='UID: ', font_size=12) self.my_lat = 0 self.my_lon = 0 self.my_heading = 0 self.my_accuracy = 0 self.DEBUG = True
def setTarget(self,target): if not target == None: self.target=target self.mira= HUD.mira(self.imagenesDelJuego) else: self.target = None self.mira = None
def __init__(self,img): Util.Object.__init__(self) self.imagen=img.imgEscudo self.vista=6 self.centro = None self.atenuador=0 self.alive=True self.energia= 5 self.hud = HUD.barraDeVida(img,Util.Vector(0,0))
def main(): from Mediator import Mediator pygame.init() WINDOW_SIZE = (1024, 768) clock = pygame.time.Clock() screen = pygame.display.set_mode(WINDOW_SIZE, 0, 32) display = pygame.Surface((256, 192)) player = Player(display, 'player', Mediator) print(Mediator.i) Mediator.all_game_entities.append(player) gameMap = GameMap(display, 'tiles', Mediator, player) hud = HUD(display, player) while True: display.fill((57, 138, 215)) Mediator.all_game_tiles.clear() gameMap.draw_map() hud.draw_overlay() for object in Mediator.all_game_entities: object.loop() object.draw() Mediator.all_game_entities = [ object for object in Mediator.all_game_entities if object not in Mediator.to_be_removed ] Mediator.to_be_removed.clear() for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit( 0 ) #TODO remember to exit with a code so we dont throw an exception i think surf = pygame.transform.scale(display, WINDOW_SIZE) screen.blit(surf, (0, 0)) pygame.display.update() clock.tick(60)
def combat(player, enemy): mouseX = 0 mouseY = 0 clicked = False attackButton = Button("src/art/attack_button.png", (WINDOWWIDTH / 2, 600)) playerDamage = 0 enemyDamage = 0 lastDamage = 0 while (True): #event handler for event in pygame.event.get(): if event.type == QUIT: terminate() elif event.type == MOUSEBUTTONUP: mouseX, mouseY = event.pos clicked = True #event controller if attackButton.rect.collidepoint((mouseX, mouseY)) and clicked: clicked = False playerDamage = player.attack('standard') enemyDamage = enemy.attack(numpy.random.choice(('standard', ))) lastDamage = enemyDamage #wombat controller enemy.health -= playerDamage player.health -= enemyDamage if enemy.health <= 0: fightWon(enemy) return if player.health <= 0: showGameOver() #drawing DISPLAYSURF.fill(BLACK) DISPLAYSURF.blit(pygame.image.load("src/art/combat_floor.png"), (0, 0, 1600, 900)) drawFight(player, enemy) DISPLAYSURF.blit(attackButton.image, attackButton.rect) #drawCombatHUD(player.health, player.mana) #drawEnemyHUD(enemy.name, enemy.health) comDisp.drawHUDWin(DISPLAYSURF) comDisp.healthBar(DISPLAYSURF, player.health * 7, player.health) comDisp.manaBar(DISPLAYSURF) comDisp.damageInfo(DISPLAYSURF, enemyDamage, enemy.health, lastDamage) pygame.display.update() #Reset variables playerDamage = 0 enemyDamage = 0 FPSCLOCK.tick(FPS)
def __init__(self): super(Scene, self).__init__() self.all_object_list = pygame.sprite.Group() self.troll_list = pygame.sprite.Group() self.bullet_list = pygame.sprite.Group() self.player = Player() self.background = Object() self.hud = HUD() self.score = 0 self.game_over = False
def __init__(self): self.mHUD = HUD() self.actualLevel = 0 self.portalTiles = None self.cityTiles = None self.selectedTower = "" self.selectedSkill = "" mE.updateOnPause = ["Mouse", "Button","InfoTabBar", "SkillTimeStop"] self.playerWins = True pass
def nodeInit(self): self.sg = self.view.getSceneGraph() self.coord = CoinNodes.coordinate3Node([(0, 0, 0)]) self.markers = CoinNodes.markerSetNode((1, 0.35, 0.8), 70) self.polygon = CoinNodes.sensorPolyNode((0.0, 0.5, 0.0), 1) self.polygon.transparency = 0.7 self.polygon.linkTo(self.coord) self.sg.addChild(self.coord) self.sg.addChild(self.markers) self.info = [ "LMB : add pole", "Del : remove last pole", "Page Up / Down : degree", "Left CTRL : snap", "Enter : Accept", "Esc : Abort" ] self.Block1 = HUD.textArea() self.Block1.setFont("Sans", 10.0, (0., 0., 0.)) self.Block1.text = self.info + ["Degree : %s" % self.curve.Degree] self.myHud = HUD.HUD() self.myHud.addBlock(self.Block1) self.myHud.add()
def __init__(self): pygame.init() # Initializing file manager and loading icon self.fileManager = FileManager.FileManager('Textures', 'Sounds') # Display properties pygame.display.set_icon(self.fileManager.icon) self.screen = pygame.display.set_mode((800, 600)) pygame.display.set_caption('Pulse') # Setting background self.fileManager.loadBackground() self.background = self.fileManager.backgroundTexture # Display update self.cleanWindow() pygame.display.flip() # Initializing game files self.fileManager.loadGameFiles() # Initializing game objects self.gameObjects = GameObjects.GameObjects() # Initializing level manager self.levelManager = LevelManager.LevelManager(self.fileManager, self.gameObjects) # Initializing menues self.menues = Menues.Menues(self.fileManager, self.levelManager) # Initializing HUD self.HUD = pygame.sprite.RenderPlain() self.HUDObject = HUD.HUD(self.levelManager.currentLevel(), True) self.HUD.add(self.HUDObject) # Adding notifieras to gameObjects self.gameObjects.addNotifier(self.HUDObject) self.gameObjects.addNotifier(self.levelManager) # Initializing clock self.clock = pygame.time.Clock() # Game running. Showing nenu on False. self.gameRunning = False # Starting music pygame.mixer.music.play(-1) # Showing main menu self.menues.main()
def __init__(self): super(Scene, self).__init__() pygame.mixer.init(44100, -16, 4, 2048) self.all_object_list = pygame.sprite.LayeredUpdates() self.zombie_list = pygame.sprite.Group() self.blood_splash = BloodSplash() self.background = Object() self.player = Player() self.zombie_sprite = [] self.grave_list = [] self.hud = HUD() self.sound_list = dict() self.bg_music = pygame.mixer.music self.game_over = False self.time = pygame.time.get_ticks()
def Debug_modeINIT(self): self.zombies = [] self.level_cam() self.pistol = gc.Gun(self.screen, self.mouse, 'pistol', -1) self.AR = gc.Gun(self.screen, self.mouse, 'AR', 50) self.SG = gc.Gun(self.screen, self.mouse, 'shootgun', 25) self.pistol.InHands = True self.guns = [self.pistol, self.AR, self.SG] self.player = hc.Players_Hero('Синий', self.screen, self.guns) self.hud = HUD.HUD(self.screen, self.hud_sprites, 100, self.player.GunType) self.pistol.Taken = True
def load(self): self.loadMenuAnimations() self.loadMenuSounds() self.splash = Entity() mE.mEntityManager.addEntity(self.splash, "SplashScreen", "SplashScreen") mE.mAnimationManager.setEntityAnimation(self.splash, "SplashScreen") self.mHud = HUD() self.background = Entity() mE.mEntityManager.addEntity(self.background, "Background", "BG") mE.mAnimationManager.setEntityAnimation(self.background, "Background") self.mHud.addButton(self.startGame, None, Vec2d(100 + 44,100 + 200), "PlayButton", Vec2d(192,64)) self.mHud.addButton(self.endGame, None, Vec2d(180 + 44,240 + 200), "QuitButton", Vec2d(192,64)) mE.mAnimationManager.addAnimation(lImagesHPBarEnemyS[0], lImagesHPBarEnemyS[1], "CooldownBarStart") mE.mAnimationManager.addAnimation(lImagesHPBarEnemyE[0], lImagesHPBarEnemyE[1], "CooldownBarEnd") mE.mAnimationManager.addAnimation(lImagesHPBarEnemyM[0], lImagesHPBarEnemyM[1], "CooldownBarMiddle") mE.mEntityManager.defineLayerOrder(["Splash","BG"])
class Execute: screen = pygame.display.set_mode((constants.WIDTH, constants.HEIGHT)) clock = pygame.time.Clock() fps = 300 cross = HUD.Crosshair() pygame.mouse.set_visible(False) player = live_objects.Player((50, 200)) player.weapon = weapons.Knife(player) floor = environment.Floor((0, constants.HEIGHT - 20), (constants.WIDTH, 20)) second_floor = environment.Floor((constants.WIDTH - 150 - 700, 150), (700, 20)) ceiling = environment.Floor((0, 0), (constants.WIDTH, 20)) left_wall = environment.Wall((0, 0), (20, constants.HEIGHT)) middle_wall = environment.Wall((constants.WIDTH - 150, 150), (20, constants.HEIGHT - 270)) right_wall = environment.Wall((constants.WIDTH - 20, 0), (20, constants.HEIGHT)) while True: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() if event.type == pygame.KEYDOWN or event.type == pygame.KEYUP: player.command() if event.type == pygame.MOUSEMOTION: cross.draw(event.pos) player.rotate_weapon(event.pos) if event.type == pygame.MOUSEBUTTONDOWN: player.shoot(event.pos) screen.fill('black') sprites.all_sprites.update() sprites.all_sprites.draw(screen) clock.tick(fps) pygame.display.flip()
class GameManager: def __init__(self): self.mHUD = HUD() self.actualLevel = 0 self.portalTiles = None self.cityTiles = None self.selectedTower = "" self.selectedSkill = "" mE.updateOnPause = ["Mouse", "Button","InfoTabBar", "SkillTimeStop"] self.playerWins = True pass def load(self): mE.setGlobalVariable("Money",10) mE.mGlobalVariables["EndGame"] = False self.loadAnimations() self.loadUI() self.loadMap() self.loadSounds() self.loadParticles() def loadParticles(self): mE.mParticleManager.addUpdateFunction(lImagesSlowParticle[0], lImagesSlowParticle[1], cascate , "cascate") #Explosions mE.mParticleManager.addUpdateFunction(lImagesCommonExplosion[0], lImagesCommonExplosion[1], explosion , "commonExplosion") mE.mParticleManager.addUpdateFunction(lImagesSlowParticle[0], lImagesSlowParticle[1], explosion , "slowExplosion") mE.mParticleManager.addUpdateFunction(lImagesPoisonParticle[0], lImagesPoisonParticle[1], explosion , "poisonExplosion") mE.mParticleManager.addUpdateFunction(lImagesFarmParticle[0], lImagesFarmParticle[1], explosion , "farmExplosion") mE.mParticleManager.addUpdateFunction(lImagesHealParticle[0], lImagesHealParticle[1], spin , "healParticle") mE.mParticleManager.addUpdateFunction(lImagesSmokeParticle[0], lImagesSmokeParticle[1], spin , "Smoke") mE.mParticleManager.addUpdateFunction(lImagesMeteorParticle[0], lImagesMeteorParticle[1], cascate , "MeteorCascate") def loadSounds(self): mE.mJukebox.LoadSong(levelSong, "LevelSong") mE.mJukebox.LoadSong(bossFight, "BossFight") mE.mJukebox.LoadSound(newTowerSound, "NewTower") mE.mJukebox.LoadSound(destructedTower, "TowerDown") mE.mJukebox.LoadSound(error, "Error") mE.mJukebox.LoadSound(damage, "Damage") mE.mJukebox.LoadSound(magic, "Magic") mE.mJukebox.LoadSound(teleport, "Teleport") mE.mJukebox.LoadSound(heart, "Heart") mE.mJukebox.LoadSound(heal, "Heal") mE.mJukebox.LoadSound(timeRunning, "TimeRunning") mE.mJukebox.LoadSound(alarmClock, "AlarmClock") mE.mJukebox.LoadSound(explosionSound, "Explosion") mE.mGlobalVariables["General"] = GeneralVoices() for monsterSound in lMonstersSounds: mE.mJukebox.LoadSound(monsterSound[0], monsterSound[1]) def loadAnimations(self): #Especial Tiles Animations mE.mAnimationManager.addAnimation(lImagesPortal[0], lImagesPortal[1], "Portal") mE.mAnimationManager.addAnimation(lImagesVillage[0], lImagesVillage[1], "Village") #Towers mE.mAnimationManager.addAnimation(lImagesSlowTower[0], lImagesSlowTower[1], "SlowTower") mE.mAnimationManager.addAnimation(lImagesDamageTower[0], lImagesDamageTower[1], "HitTower") mE.mAnimationManager.addAnimation(lImagesPoisonTower[0], lImagesPoisonTower[1], "PoisonTower") mE.mAnimationManager.addAnimation(lImagesFarmTower[0], lImagesFarmTower[1], "FarmTower") #Enemys Animation for mAni in lMonstersStats: mE.mAnimationManager.addAnimation(mAni["Animation"]["Up"][0], mAni["Animation"]["Up"][1], mAni["AnimationTag"]+"Up") mE.mAnimationManager.addAnimation(mAni["Animation"]["Down"][0], mAni["Animation"]["Down"][1], mAni["AnimationTag"]+"Down") mE.mAnimationManager.addAnimation(mAni["Animation"]["Left"][0], mAni["Animation"]["Left"][1], mAni["AnimationTag"]+"Left") mE.mAnimationManager.addAnimation(mAni["Animation"]["Right"][0], mAni["Animation"]["Right"][1], mAni["AnimationTag"]+"Right") mE.mAnimationManager.addAnimation(lImagesTombstone[0],lImagesTombstone[1], "Tombstone") #UI mE.mAnimationManager.addAnimation(lImagesMouse[0],lImagesMouse[1], "Mouse") mE.mAnimationManager.addAnimation(lImagesMouseHit[0],lImagesMouseHit[1], "MouseHit") mE.mAnimationManager.addAnimation(lImagesMouseSlow[0],lImagesMouseSlow[1], "MouseSlow") mE.mAnimationManager.addAnimation(lImagesMousePoison[0],lImagesMousePoison[1], "MousePoison") mE.mAnimationManager.addAnimation(lImagesMuteButtonOn[0],lImagesMuteButtonOn[1], "MuteButtonON") mE.mAnimationManager.addAnimation(lImagesMuteButtonOff[0],lImagesMuteButtonOff[1], "MuteButtonOFF") mE.mAnimationManager.addAnimation(lImagesTabBar[0],lImagesTabBar[1], "TabBar") mE.mAnimationManager.addAnimation(lImagesBottomBar[0],lImagesBottomBar[1], "BottomBar") mE.mAnimationManager.addAnimation(lImagesMoneyBar [0],lImagesMoneyBar[1], "MoneyUIBar") #Icons mE.mAnimationManager.addAnimation(lImagesSlowIcon[0], lImagesSlowIcon[1], "SlowIcon") mE.mAnimationManager.addAnimation(lImagesDamageIcon[0], lImagesDamageIcon[1], "DamageIcon") mE.mAnimationManager.addAnimation(lImagesPoisonIcon[0], lImagesPoisonIcon[1], "PoisonIcon") mE.mAnimationManager.addAnimation(lImagesFarmIcon[0], lImagesFarmIcon[1], "FarmIcon") mE.mAnimationManager.addAnimation(lImagesTimeStopIcon[0], lImagesTimeStopIcon[1], "TimeStopIcon") mE.mAnimationManager.addAnimation(lImagesHealIcon[0], lImagesHealIcon[1], "HealIcon") mE.mAnimationManager.addAnimation(lImagesFireBallIcon[0], lImagesFireBallIcon[1], "FireBallIcon") #HealthBars Enemysself.selectedSkill mE.mAnimationManager.addAnimation(lImagesHPBarEnemyS[0], lImagesHPBarEnemyS[1], "EnemyHealthBarStart") mE.mAnimationManager.addAnimation(lImagesHPBarEnemyE[0], lImagesHPBarEnemyE[1], "EnemyHealthBarEnd") mE.mAnimationManager.addAnimation(lImagesHPBarEnemyM[0], lImagesHPBarEnemyM[1], "EnemyHealthBarMiddle") #HealthBars Towers mE.mAnimationManager.addAnimation(lImagesHPBarTowerS[0], lImagesHPBarTowerS[1], "TowerHealthBarStart") mE.mAnimationManager.addAnimation(lImagesHPBarTowerE[0], lImagesHPBarTowerE[1], "TowerHealthBarEnd") mE.mAnimationManager.addAnimation(lImagesHPBarTowerM[0], lImagesHPBarTowerM[1], "TowerHealthBarMiddle") #CooldownBars Towers mE.mAnimationManager.addAnimation(lImagesHPBarTowerS[0], lImagesHPBarTowerS[1], "CooldownBarStart") mE.mAnimationManager.addAnimation(lImagesHPBarTowerE[0], lImagesHPBarTowerE[1], "CooldownBarEnd") mE.mAnimationManager.addAnimation(lImagesHPBarTowerM[0], lImagesHPBarTowerM[1], "CooldownBarMiddle") #ProgressBar mE.mAnimationManager.addAnimation(lImagesProgressStart[0], lImagesProgressStart[1], "ProgressBarStart") mE.mAnimationManager.addAnimation(lImagesProgressMiddle[0], lImagesProgressMiddle[1], "ProgressBarMiddle") mE.mAnimationManager.addAnimation(lImagesProgressEnd[0], lImagesProgressEnd[1], "ProgressBarEnd") mE.mAnimationManager.addAnimation(lImagesProgressBarMF[0], lImagesProgressBarMF[1], "ProgressBarMF") mE.mAnimationManager.addAnimation(lImagesProgressBarEF[0], lImagesProgressBarEF[1], "ProgressBarEF") #Projectiles mE.mAnimationManager.addAnimation(lImagesSimpleProjectil[0],lImagesSimpleProjectil[1], "SimpleProjectil") mE.mAnimationManager.addAnimation(lImagesSlowProjectil[0],lImagesSlowProjectil[1], "SlowProjectil") mE.mAnimationManager.addAnimation(lImagesPoisonProjectil[0],lImagesPoisonProjectil[1], "PoisonProjectil") mE.mAnimationManager.addAnimation(lImagesFarmProjectil[0],lImagesFarmProjectil[1], "FarmProjectil") mE.mAnimationManager.addAnimation(lImagesFireBall[0],lImagesFireBall[1], "FireBall") #HealthBar City mE.mEntityManager.defineLayerOrder(["Tombstone","Towers", "Monsters", "BackUI", "UI"]) def setPortalCoordinates(self): self.portalTiles = mE.mMapManager.getTiles("3") mapPortal = self.portalTiles[0][0] portalCoord = self.portalTiles[0][1][0] portalCoord = mapPortal.toMapCoordinate(portalCoord.position) portalCoord = (0,portalCoord[0] * tileWidth,portalCoord[1] * tileHeigth) #Create a global variable PortalCoord who have the position of the portal mE.setGlobalVariable("PortalCoord", portalCoord) mE.setGlobalVariable("PortalMapCoord", mapPortal) def setCityCoordinates(self): #Do the same thing with City Coordinates self.cityTiles = mE.mMapManager.getTiles("4") mapCity = self.cityTiles[0][0] cityCoord = self.cityTiles[0][1][0] cityCoord = mapCity.toMapCoordinate(cityCoord.position) cityCoord = (0,cityCoord[0] * tileWidth, cityCoord[1] * tileHeigth) mE.setGlobalVariable("CityCoord", cityCoord) mE.setGlobalVariable("CityMapCoor", mapCity) def loadUI(self): self.mHUD.loadEntitys() #Load the fonts mE.mTextManager.addFont(pygame.font.Font(None,16), "None14") mE.mTextManager.addFont(pygame.font.Font(None,20), "None20") mE.mTextManager.addFont(pygame.font.Font(None,28), "None32") #Create the bottomBar bottomBar = Entity() mE.mEntityManager.addEntity(bottomBar,"BottomBar","UI") mE.mAnimationManager.setEntityAnimation(bottomBar, "BottomBar") bottomBar.setPosition(50 ,686) self.icons = {} #Create the SlowIcon slowButton = self.mHUD.addCooldownButton(self.selectTower, "Slow",Vec2d(79,712),"SlowIcon", Vec2d(34,34), ) slowButton.cooldownBar.setPosition(Vec2d(86,751)) self.icons["Slow"] = slowButton #Create DamageIcon hitButton = self.mHUD.addCooldownButton(self.selectTower, "Hit", Vec2d(123 , 712), "DamageIcon", Vec2d(34,34)) hitButton.cooldownBar.setPosition(Vec2d(130,751)) self.icons["Hit"] = hitButton #Create PoisonIcon poisonButton = self.mHUD.addCooldownButton(self.selectTower, "Poison", Vec2d(167 , 712), "PoisonIcon", Vec2d(34,34), cooldown = 15.0) poisonButton.cooldownBar.setPosition(Vec2d(174,751)) self.icons["Poison"] = poisonButton #Create FarmIcon farmButton = self.mHUD.addCooldownButton(self.selectTower, "Farm", Vec2d(211, 712), "FarmIcon", Vec2d(34,34)) farmButton.cooldownBar.setPosition(Vec2d(218,751)) self.icons["Farm"] = farmButton #Create the bottomBar skillBar = Entity() mE.mEntityManager.addEntity(skillBar,"BottomBar","UI") mE.mAnimationManager.setEntityAnimation(skillBar, "BottomBar") skillBar.setPosition(424 + 180,686) self.skillIcons = {} #Create the TimeStopIcon timeStopButton = self.mHUD.addCooldownButton(self.selectSkill, "TimeStop",Vec2d(79-50+ 424+180,712),"TimeStopIcon", Vec2d(34,34), cooldown = 180.0) timeStopButton.cooldownBar.setPosition(Vec2d(86-50+ 424+180,751)) self.skillIcons["TimeStop"] = timeStopButton #Create the HealIcon healButton = self.mHUD.addCooldownButton(self.selectSkill, "Heal",Vec2d(123-50+ 424+180,712),"HealIcon", Vec2d(34,34), cooldown = 90.0) healButton.cooldownBar.setPosition(Vec2d(130-50+ 424+180,751)) self.skillIcons["Heal"] = healButton #Create the FireBallIcon fireBallButton = self.mHUD.addCooldownButton(self.selectSkill, "FireBall",Vec2d(167-50+ 424+180,712),"FireBallIcon", Vec2d(34,34), cooldown = 300.0) fireBallButton.cooldownBar.setPosition(Vec2d(174-50+ 424+180,751)) self.skillIcons["FireBall"] = fireBallButton #Add TabBar for tower stats self.tabBar = TabBar() tabBarPos = (1024, 80) self.tabBar.setMinDesloc(tabBarPos[0],tabBarPos[1]) self.tabBar.setMaxDesloc(tabBarPos[0]-180,tabBarPos[1]) self.tabBar.vecMaxSpeedDesloc = 10 self.mHUD.addTabBar(self.tabBar, "Info") #Create the texts for tower stats self.addTextTabBar((tabBarPos[0] +10,120),"Description0") self.addTextTabBar((tabBarPos[0] +10,140),"Description1") self.addTextTabBar((tabBarPos[0] +10,160),"Description2") self.pauseUI = Text() self.pauseUI.setPosition(500, 200) mE.mTextManager.addText(self.pauseUI,"PauseUI") mE.mTextManager.setTextFont("PauseUI", "None32") #Add a circle around the mouse self.circle = Circle() self.circle.color = (55,151,125) mE.mPrimitiveManager.addPrimitive(self.circle, "MouseCircle") #Add the Twinkle little text self.tText = createTwinkleText("- Shapen the arrows - ","None32") self.tText.startTwinkle() self.tText.setPosition(400,200) mE.mEntityManager.addEntity(self.tText, "TwinkleText") #Add the money ui bar moneyBar = Entity() mE.mEntityManager.addEntity(moneyBar,"MoneyUIBar","UI") mE.mAnimationManager.setEntityAnimation(moneyBar, "MoneyUIBar") moneyBar.setPosition(424,710) #Add texts to HUD self.moneyUI = Text() self.moneyUI.color = (255,255,255) self.mHUD.addText(self.moneyUI, "Money", "None32", "MoneyUI") self.moneyUI.setPosition(470, 725) #Create Mute Button self.muteButton = self.mHUD.addButton(toggleSound,None, Vec2d(960,6), "MuteButtonON", Vec2d(34,34)) self.muteButton.params = self.muteButton def addTextTabBar(self, position, tag): t = Text() t.color = (255,255,255) t.setPosition(position) self.tabBar.addEntity(t) mE.mTextManager.addText(t,tag) mE.mTextManager.setTextFont(tag, "None14") def gameLoop(self): self.end = False mE.mJukebox.PlaySong("LevelSong",True) #mE.mJukebox.PlaySong("BossFight") while not self.end: mE.update() if(mE.keyboard.isPressed(pygame.K_ESCAPE)): self.selectedTower = "" self.selectedSkill = "" mouse = self.mHUD.mouseEntity mE.mAnimationManager.setEntityAnimation(mouse,"Mouse") #self.end = True if(self.selectedTower != "" and self.canPutTower()): mousePosition = mE.mouse.getPosition() self.circle.position = (mousePosition[0], mousePosition[1]) self.circle.radius = dicTowers[self.selectedTower]["Range"] if(mE.mouse.isPressed("LEFT")): self.createTower(self.selectedTower, mousePosition) elif(self.selectedSkill != "" and self.canCastSkill()): mousePosition = mE.mouse.getPosition() self.circle.position = (mousePosition[0], mousePosition[1]) self.circle.radius = dicSkills[self.selectedSkill]["Range"] if(mE.mouse.isPressed("LEFT")): self.castSkill(self.selectedSkill, mousePosition) else: self.circle.position = (-2,-2) self.circle.radius = (1) if(self.isOver()): break print "Game Over" if(mE.keyboard.isPressed(pygame.K_UP)): self.playerWins = False break self.showInfo() self.addTimeCash() #print self.tText.text.content self.mHUD.update() mE.render() def canPutTower(self): mouse = self.mHUD.mouseEntity lCollisionTowerMouse = mE.mEntityManager.collision("Mouse", "Tower") lCollisionMouseWalkable = [] for t in walkable: lCollisionMouseWalkable += mE.mMapManager.getCollisions(mouse, t) if(not lCollisionTowerMouse and not self.icons[self.selectedTower].cooldownBar.isActive() and lCollisionMouseWalkable): return True return False def canCastSkill(self): mouse = self.mHUD.mouseEntity lCollisionMouseWalkable = [] for t in walkable: lCollisionMouseWalkable += mE.mMapManager.getCollisions(mouse, t) if(not self.skillIcons[self.selectedSkill].cooldownBar.isActive() and lCollisionMouseWalkable): return True return False def showInfo(self): lCollisionIconMouse = mE.mEntityManager.collision("Mouse", "Button") if(lCollisionIconMouse): button = lCollisionIconMouse[0][1] if(button != self.muteButton): self.showDescription(button.params) else: self.tabBar.disappear() def addTimeCash(self): pass def castSkill(self, tag, position = Vec2d(0,0)): params = {"Position": position, "Range": dicSkills[tag]["Range"]} dicSkills[tag]["Function"](params) self.skillIcons[self.selectedSkill].activeCooldown() def createTower(self,tag,position = Vec2d(0,0)): global mE global dicTowers #If have money if(mE.mGlobalVariables["Money"] >= dicTowers[tag]["Cost"]): #Update the UI mE.mGlobalVariables["Money"] += -dicTowers[tag]["Cost"] self.moneyUI.content = "Money: " + str(mE.mGlobalVariables["Money"]) #Create the tower t = Tower() mE.mAnimationManager.setEntityAnimation(t, tag+"Tower") mE.mEntityManager.addEntity(t,"Tower", "Towers") t.tag = tag t.towerEffect = dicTowers[tag]["Effect"] #t.hp.maxHealth = dicTowers[tag]["HP"] #t.hp.health = dicTowers[tag]["HP"] t.slow = dicTowers[tag]["Slow"] t.poison = dicTowers[tag]["PoisonDamage"] t.damage = dicTowers[tag]["HitDamage"] t.cooldownShoot = dicTowers[tag]["Cooldown"] t.range = dicTowers[tag]["Range"] t.hp = HealthBar(dicTowers[tag]["HP"]) t.hp.addToEntityManager() t.hp.setAnimation("TowerHealthBarStart", "TowerHealthBarEnd", "TowerHealthBarMiddle") if(dicTowers[tag]["ChooseMethod"] != None): t.chooseTargetMethod = dicTowers[tag]["ChooseMethod"] t.setCollisionBlock(Vec2d(tileWidth,tileHeigth)) t.setPosition(position) t.setCenterBoundingCircle(32,32) t.setRadiusBoundingCircle(32) #Put on Graph graph = mE.mGlobalVariables["Graph"] graph.changeWeight(t.graphPosition,100) self.recalculateRouteAllMonsters() #Start iconCooldown self.icons[self.selectedTower].activeCooldown() mE.mJukebox.PlaySound("NewTower") return t else: mE.mJukebox.PlaySound("Error") def recalculateRouteAllMonsters(self): monsters = mE.mEntityManager.getTagEntitys("Monster") for m in monsters: m.recalculateRoute() def selectTower(self,params): self.selectedSkill = "" self.selectedTower = params mouse = self.mHUD.mouseEntity mE.mAnimationManager.setEntityAnimation(mouse,"Mouse"+ params) def selectSkill(self,params): self.selectedSkill = params self.selectedTower = "" mouse = self.mHUD.mouseEntity mE.mAnimationManager.setEntityAnimation(mouse, "Mouse") def showDescription(self, params): tDescription0 = mE.mTextManager.texts["Description0"] tDescription0.content = Descriptions[params][0] tDescription1 = mE.mTextManager.texts["Description1"] tDescription1.content = Descriptions[params][1] tDescription2 = mE.mTextManager.texts["Description2"] tDescription2.content = Descriptions[params][2] self.tabBar.appear() def loadTileset(self, tileset, mMap): global tilesets for tile in tilesets[tileset]: animation = tilesets[tileset][tile]["Animation"] symbol = tilesets[tileset][tile]["Symbol"] mMap.mAnimationManager.addAnimation( animation[0], animation[1], tile ) mMap.createFactoryTile(Tile, {}, tile, symbol) mMap.mAnimationManager.addAnimation(lImagesPortal[0],lImagesPortal[1],"Portal") mMap.mAnimationManager.addAnimation(lImagesVillage[0],lImagesVillage[1],"City") mMap.createFactoryTile(Portal, {"ParticleManager": mE.mParticleManager , "Waves": self.waves}, "Portal", "3") mMap.createFactoryTile(City, {}, "City", "4") def loadMap(self): global graph global lMaps global PortalGraph global mE self.actualMap = lMaps[self.actualLevel] mapFile = self.actualMap[0] waveFile = self.actualMap[1] tileset = self.actualMap[2] #Load the wave f = open(waveFile).read().split('\n') self.nWaves = len(f)-1 self.waves = {} i = 0 for line in f: l = line.split('\t') self.waves[i] = [] for enemy in l: self.waves[i] += [int(enemy)] i +=1 #Load the map i = 0 for m in mapFile: mMap = Map(tileWidth,tileHeigth, 0,0) self.loadTileset(tileset, mMap) mMap.loadMap(m) mE.mMapManager.addMap(mMap, m) i += 1 #Put the layers on order... mE.mMapManager.setMapLayers(mapFile) graph = TowerDefenseGraph() graph.walkable = walkable graph.loadGraphFromMaps(mapFile, tileWidth, tileHeigth) #graph.loadWeigths() mE.mGlobalVariables["Graph"] = graph self.setPortalCoordinates() self.setCityCoordinates() def isOver(self): #if there is no monster alive monster = mE.mEntityManager.getTagEntitys("Monster") #if there is no monster to spawn pTile = self.portalTiles[0][1][0] if(not pTile.gonnaSpawnMore() and monster == []): #the player wins self.playerWins = True return True if(mE.mGlobalVariables["EndGame"]): self.playersWins = False return True #if the city has no more hp #the player loose self.playerWins = False return False def saveGame(self): pass
class Game: def __init__(self): global graph self.end = False self.mStageSelection = StageSelection() self.mGameManager = GameManager() self.tIniLoop = mE.getGameTime() def startGame(self): global PortalGraph mE.pushState() self.mStageSelection.load() self.mStageSelection.update() mE.popState() mE.mJukebox.PlaySong("MenuSong") def load(self): self.loadMenuAnimations() self.loadMenuSounds() self.splash = Entity() mE.mEntityManager.addEntity(self.splash, "SplashScreen", "SplashScreen") mE.mAnimationManager.setEntityAnimation(self.splash, "SplashScreen") self.mHud = HUD() self.background = Entity() mE.mEntityManager.addEntity(self.background, "Background", "BG") mE.mAnimationManager.setEntityAnimation(self.background, "Background") self.mHud.addButton(self.startGame, None, Vec2d(100 + 44,100 + 200), "PlayButton", Vec2d(192,64)) self.mHud.addButton(self.endGame, None, Vec2d(180 + 44,240 + 200), "QuitButton", Vec2d(192,64)) mE.mAnimationManager.addAnimation(lImagesHPBarEnemyS[0], lImagesHPBarEnemyS[1], "CooldownBarStart") mE.mAnimationManager.addAnimation(lImagesHPBarEnemyE[0], lImagesHPBarEnemyE[1], "CooldownBarEnd") mE.mAnimationManager.addAnimation(lImagesHPBarEnemyM[0], lImagesHPBarEnemyM[1], "CooldownBarMiddle") mE.mEntityManager.defineLayerOrder(["Splash","BG"]) def loadMenuAnimations(self): mE.mAnimationManager.addAnimation(lImagesSplashScreen[0],lImagesSplashScreen[1],"SplashScreen") mE.mAnimationManager.addAnimation(lImagesBackground[0],lImagesBackground[1],"Background") mE.mAnimationManager.addAnimation(lImagesPlayButton[0],lImagesPlayButton[1],"PlayButton") mE.mAnimationManager.addAnimation(lImagesOptionsButton[0],lImagesOptionsButton[1],"OptionsButton") mE.mAnimationManager.addAnimation(lImagesQuitButton[0],lImagesQuitButton[1],"QuitButton") mE.mAnimationManager.addAnimation(lImagesButton[0],lImagesButton[1], "Button") mE.mAnimationManager.addAnimation(lImagesMouse[0],lImagesMouse[1], "Mouse") def loadMenuSounds(self): mE.mJukebox.LoadSong(menuSong, "MenuSong") mE.mJukebox.LoadSound(bubbleSound, "BubbleSound") mE.mJukebox.PlaySound("BubbleSound") def menuLoop(self): global mE self.end = False mE.mJukebox.PlaySong("MenuSong") while not self.end: mE.update() if(mE.getGameTime() - self.tIniLoop >= 3.0 and self.splash != None): mE.mEntityManager.removeEntity(self.splash, "SplashScreen") self.splash = None self.mHud.update() mE.render() print "Acabou" def endGame(self): self.end = True
class Scene(State): def __init__(self, file_path): super(Scene, self).__init__() pygame.mixer.init(44100, -16, 4, 2048) self.position = ['goalkeeper', 'defender', 'midfielder', 'attacker'] self.all_object_list = pygame.sprite.LayeredUpdates() self.selection_circle = [] # Prototype self.left_player = Player() # Prototype self.right_player = Player() # Prototype self.teams = collections.defaultdict(dict) self.field = Object() self.field_border = Object() self.goal = [] self.ball = Ball() self.hud = HUD() self.goal_image = EffectObject() self.formation = {Team_side.LEFT: [1, 4, 3, 3], Team_side.RIGHT: [1, 4, 4, 2]} self.sound_list = dict() # Game config self.game_mode = Game_mode.PvP self.P1_controlled_team = Team_side.LEFT self.P1_controlled_position = 'midfielder' self.P2_controlled_team = Team_side.RIGHT self.P2_controlled_position = 'midfielder' # Load scene's resources self.read_scene(file_path) def init(self): # Set teams info # Left team self.game_mode = self.get_shared_var('mode') self.formation[self.P1_controlled_team] = self.get_shared_var('P1_formation') team1_id = self.get_shared_var('P1_team_ID') self.hud.set_left_team_name(Team_name[team1_id]) self.left_player.setImage(ResourceManager.instance().image_path_list[56 + team1_id]) # Right team self.formation[self.P2_controlled_team] = self.get_shared_var('P2_formation') team2_id = self.get_shared_var('P2_team_ID') self.hud.set_right_team_name(Team_name[team2_id]) self.right_player.setImage(ResourceManager.instance().image_path_list[56 + team2_id]) # Calculate players and ball position self.calculate_position() # Set controlled team self.controlled_team = Team_side.LEFT # Randomize ball direction self.ball.set_angle(random.randrange(0, 360, 20)) # Game control self.game_over = False self.match_state = Match_state.KICKOFF self.match_time = 120000 self.time = self.match_time # Reset score self.hud.reset_score() # Set background music pygame.mixer.stop() self.sound_list['background'].play().set_endevent(pygame.constants.USEREVENT) def process_key_press(self, key): if key[pygame.K_w]: apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'move_up') if key[pygame.K_s]: apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'move_down') if key[pygame.K_UP]: apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'move_up') if key[pygame.K_DOWN]: apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'move_down') def process_events(self, event): if event.type == pygame.USEREVENT: self.sound_list['background'].play() elif event.type == pygame.MOUSEBUTTONDOWN: return '' elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: if self.is_running: self.pause() else: self.resume() elif event.key == pygame.K_a: apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'stop') self.P1_controlled_position = self.position[max(0, self.position.index(self.P1_controlled_position) - 1)] elif event.key == pygame.K_d: apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'stop') self.P1_controlled_position = self.position[min(3, self.position.index(self.P1_controlled_position) + 1)] elif event.key == pygame.K_LEFT: apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'stop') self.P2_controlled_position = self.position[min(3, self.position.index(self.P2_controlled_position) + 1)] elif event.key == pygame.K_RIGHT: apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'stop') self.P2_controlled_position = self.position[max(0, self.position.index(self.P2_controlled_position) - 1)] elif event.type == pygame.KEYUP: if event.key == pygame.K_w or event.key == pygame.K_s: apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'stop') elif event.key == pygame.K_UP or event.key == pygame.K_DOWN: if self.game_mode is Game_mode.PvP: apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'stop') def update(self): if (not self.is_running): return if self.match_state == Match_state.KICKOFF: self.sound_list['whistle'].play() pygame.time.delay(1500) self.match_state = Match_state.PLAYING elif self.match_state == Match_state.PLAYING: # Logic processing self.time -= 1000 / 60 if self.time <= 0.0: self.match_state = Match_state.KICKOFF self.reset_game() self.hud.set_time(int(self.time)) self.process_ball() elif self.match_state == Match_state.GOAL: goal_image = self.goal_image.clone() goal_image.set_appear_time(500) goal_image.show() self.all_object_list.add(goal_image) self.match_state = Match_state.KICKOFF self.reset_game() # Update all objects self.all_object_list.update() self.hud.update() def draw(self, screen): screen.fill(BLACK) self.all_object_list.draw(screen) apply_all(self.teams[self.P1_controlled_team][self.P1_controlled_position], 'show_selection_circle', screen) if self.game_mode is Game_mode.PvP: apply_all(self.teams[self.P2_controlled_team][self.P2_controlled_position], 'show_selection_circle', screen) self.hud.draw(screen) def reset_game(self): self.calculate_position() self.match_state = Match_state.KICKOFF #--------------------------------------LOGIC PROCESSING SECTION----------------------------------------------- def process_ball(self): # Check if hit goals if (pygame.sprite.collide_mask(self.ball, self.goal[0])) is not None: self.sound_list['goal'].play() self.hud.update_right_score() self.match_state = Match_state.GOAL return elif pygame.sprite.collide_mask(self.ball, self.goal[1]) is not None: self.sound_list['goal'].play() self.hud.update_left_score() self.match_state = Match_state.GOAL return # Check if hit field's border self.process_collide_border() # Check if hit players player_list = [players for sublist in (list(self.teams[Team_side.LEFT].values()) + list(self.teams[Team_side.RIGHT].values())) for players in sublist] hit_player = pygame.sprite.spritecollideany(self.ball, player_list, pygame.sprite.collide_circle) if hit_player is not None: self.sound_list['ball_kick'].play() self.ball.collide_object(hit_player) # Process AI list(chain(*self.teams[Team_side.LEFT].values())) """for position in self.teams[Team_side.RIGHT].keys(): action = 'move_up' if random.randrange(0, 2) is 0 else 'move_down' apply_all(self.teams[Team_side.RIGHT][position], action)""" def process_collide_border(self): """Check if ball touch field's border and calculate rebound direction """ ball_pos = self.ball.get_pos() if ball_pos[0] < 50: self.ball.move_to(51, self.ball.get_pos()[1]) self.ball.toggle_x_vel() elif (ball_pos[0] + self.ball.get_width()) > SCREEN_WIDTH - 50: self.ball.move_to(SCREEN_WIDTH - 51 - self.ball.get_width(), self.ball.get_pos()[1]) self.ball.toggle_x_vel() elif ball_pos[1] < 20: self.ball.move_to(self.ball.get_pos()[0], 21) self.ball.toggle_y_vel() elif (ball_pos[1] + self.ball.get_height()) > SCREEN_HEIGHT - 20: self.ball.move_to(self.ball.get_pos()[0], SCREEN_HEIGHT - 21 - self.ball.get_height()) self.ball.toggle_y_vel() def calculate_position(self): """Calculate and move ball and players to the right position """ # Calculate ball postion x = (SCREEN_WIDTH - self.ball.get_width()) // 2 y = (SCREEN_HEIGHT - 8 - self.ball.get_height()) // 2 self.ball.move_to(x, y) # Generate and calculate red team players for i in range(len(self.formation[Team_side.LEFT])): if len(self.teams[Team_side.LEFT]) == 4: apply_all(self.teams[Team_side.LEFT][self.position[i]], 'kill') self.teams[Team_side.LEFT].update({self.position[i]: []}) # Calculate offset x_offset = 100 y_offset = (self.field.get_height() - 8 - self.left_player.get_height() * self.formation[Team_side.LEFT][i]) // (self.formation[Team_side.LEFT][i] + 1) for j in range(self.formation[Team_side.LEFT][i]): # Calculate position x = self.left_player.get_pos()[0] + (x_offset * (i ** 1.69)) y = y_offset * (j + 1) + self.left_player.get_height() * j + 4 self.teams[Team_side.LEFT][self.position[i]].append(self.left_player.clone()) self.teams[Team_side.LEFT][self.position[i]][j].move_to(x, y) self.teams[Team_side.LEFT][self.position[i]][-1].set_layer(1) self.teams[Team_side.LEFT][self.position[i]][-1].set_radius() self.teams[Team_side.LEFT][self.position[i]][j].set_max_offset(y_offset - 20) self.all_object_list.add(self.teams[Team_side.LEFT][self.position[i]][-1]) # Generate and calculate blue team players for i in range(len(self.formation[Team_side.RIGHT])): if len(self.teams[Team_side.RIGHT]) == 4: apply_all(self.teams[Team_side.RIGHT][self.position[i]], 'kill') self.teams[Team_side.RIGHT].update({self.position[i]: []}) # Calculate offset x_offset = 100 y_offset = (self.field.get_height() - 8 - self.right_player.get_height() * self.formation[Team_side.RIGHT][i]) // (self.formation[Team_side.RIGHT][i] + 1) for j in range(self.formation[Team_side.RIGHT][i]): # Calculate position x = self.right_player.get_pos()[0] - (x_offset * (i ** 1.69)) y = y_offset * (j + 1) + self.right_player.get_height() * j + 4 self.teams[Team_side.RIGHT][self.position[i]].append(self.right_player.clone()) self.teams[Team_side.RIGHT][self.position[i]][j].move_to(x, y) self.teams[Team_side.RIGHT][self.position[i]][-1].set_layer(1) self.teams[Team_side.RIGHT][self.position[i]][-1].set_radius() self.teams[Team_side.RIGHT][self.position[i]][j].set_max_offset(y_offset - 20) self.all_object_list.add(self.teams[Team_side.RIGHT][self.position[i]][-1]) # Assign selection_circle to each player # Left team for player in [players for sublist in list(self.teams[Team_side.LEFT].values()) for players in sublist]: player.selection_circle = self.selection_circle[0].clone() # Right team for player in [players for sublist in list(self.teams[Team_side.RIGHT].values()) for players in sublist]: player.selection_circle = self.selection_circle[1].clone() #----------------------------------------READ FILE SECTION----------------------------------------------------- def read_scene(self, file_path): with open(file_path) as file: self.read_hud(file) self.read_field(file) self.read_red_team(file) self.read_blue_team(file) self.read_selection_circle(file) self.read_ball(file) self.read_effect(file) self.read_sound(file) def read_hud(self, file): file.readline() hud_id = int(file.readline().strip().split(' ')[1]) self.hud.init(ResourceManager.instance().hud_path_list[hud_id]) def read_field(self, file): # Read field file.readline() image_id = int(file.readline().strip().split(' ')[1]) self.field.init('Image', file_name = ResourceManager.instance().image_path_list[image_id]) self.field.scale_to(SCREEN_WIDTH, SCREEN_HEIGHT) self.all_object_list.add(self.field) # Read goal file.readline() image_id_1, image_id_2 = list(map(int, file.readline().strip().split(' ')[1:])) self.goal.append(Object()) self.goal[-1].init('Image', file_name = ResourceManager.instance().image_path_list[image_id_1]) self.goal[-1].scale_to(SCREEN_WIDTH, SCREEN_HEIGHT) self.goal[-1].set_layer(-1) self.goal.append(Object()) self.goal[-1].init('Image', file_name = ResourceManager.instance().image_path_list[image_id_2]) self.goal[-1].scale_to(SCREEN_WIDTH, SCREEN_HEIGHT) self.goal[-1].set_layer(-1) self.all_object_list.add(self.goal) def read_red_team(self, file): self.teams[Team_side.LEFT] = dict() file.readline() image_id = int(file.readline().strip().split(' ')[1]) # Prototype self.left_player.init('Image', file_name = ResourceManager.instance().image_path_list[image_id]) self.left_player.rotate(float(file.readline().strip().split(' ')[1])) self.left_player.scale(*map(float, file.readline().strip().split(' ')[1:])) self.left_player.translate(*map(int, file.readline().strip().split(' ')[1:])) def read_blue_team(self, file): self.teams[Team_side.RIGHT] = dict() file.readline() image_id = int(file.readline().strip().split(' ')[1]) # Prototype self.right_player.init('Image', file_name = ResourceManager.instance().image_path_list[image_id]) self.right_player.rotate(float(file.readline().strip().split(' ')[1])) self.right_player.scale(*map(float, file.readline().strip().split(' ')[1:])) self.right_player.translate(*map(int, file.readline().strip().split(' ')[1:])) def read_selection_circle(self, file): file.readline() image_id = list(map(int, (file.readline().strip().split(' ')[1:]))) image_id_green = image_id[0] image_id_red = image_id[1] # Green circle self.selection_circle.append(Object()) self.selection_circle[-1].init('Image', file_name = ResourceManager.instance().image_path_list[image_id_green], alpha = True) self.selection_circle[-1].rotate(float(file.readline().strip().split(' ')[1])) self.selection_circle[-1].scale(*map(float, file.readline().strip().split(' ')[1:])) self.selection_circle[-1].translate(*map(int, file.readline().strip().split(' ')[1:])) # Red circle self.selection_circle.append(self.selection_circle[-1].clone()) self.selection_circle[-1].setImage(ResourceManager.instance().image_path_list[image_id_red]) def read_ball(self, file): file.readline() image_id = int(file.readline().strip().split(' ')[1]) self.ball.init('Image', file_name = ResourceManager.instance().image_path_list[image_id], alpha = True) self.ball.rotate(float(file.readline().strip().split(' ')[1])) self.ball.scale(*map(float, file.readline().strip().split(' ')[1:])) self.ball.translate(*map(int, file.readline().strip().split(' ')[1:])) self.ball.set_radius() self.all_object_list.add(self.ball) def read_effect(self, file): file.readline() image_id = int(file.readline().strip().split(' ')[1]) self.goal_image.init('Image', file_name = ResourceManager.instance().image_path_list[image_id], alpha = True) self.goal_image.rotate(float(file.readline().strip().split(' ')[1])) self.goal_image.scale(*map(float, file.readline().strip().split(' ')[1:])) self.goal_image.translate(*map(int, file.readline().strip().split(' ')[1:])) self.goal_image.set_layer(5) def read_sound(self, file): sound_num = int(file.readline().strip().split(' ')[1]) for i in range(sound_num): sound_type = file.readline().strip().replace('#', '') sound_id = int(file.readline().strip().split(' ')[1]) sound = pygame.mixer.Sound(ResourceManager.instance().sound_path_list[sound_id]) self.sound_list.update({sound_type: sound})
pygame.display.set_caption("CastleThing") """ def generateColor(f):#0<f<1 g = f+1.0/3 h = g+1.0/3 return [127*(1+cos(f*2*pi)),127*(1+cos(g*2*pi)),127*(1+cos(h*2*pi))] """ universe = CreateUniverse() gc = GraphicConfig() gc.mainSurface = window gc.trailSurface = trails gc.hudSurface = hud gc.font = pygame.font.Font(None, 20) hud = HUD() weapons = {} weapons[K_1] = Bullet weapons[K_2] = SplitBullet weapons[K_3] = AngleBullet weapons[K_4] = CarpetBomb weapons[K_5] = PineappleBomb weapons[K_6] = Frag weapons[K_7] = PowerBullet weapons[K_p] = PlayerSpawn ammo = {} ammo[Bullet] = 1000 ammo[SplitBullet] = 10000 ammo[AngleBullet] = 1000 ammo[PowerBullet] = 1000
def main(): pygame.init() # Constant variables SCREEN_SIZE = (600, 800) DISPLAY_SIZE = (300, 400) DARK_GREY = (50, 50, 50) RUNNING = True FPS = 60 timer = 0 fpsClock = pygame.time.Clock() #The real screen screen = pygame.display.set_mode(SCREEN_SIZE) #To cast to display = pygame.Surface((DISPLAY_SIZE)) player = Player(display, 'player') generator = Generator(display) Soundplayer.load_music(Soundplayer()) Soundplayer.play_music(Soundplayer()) hud = HUD(display, player, DISPLAY_SIZE, generator) menu = Menu(display, DISPLAY_SIZE) # Title and Icon pygame.display.set_caption("The Falcon") icon = pygame.image.load( menu.resource_path('Game/sprites/playerLV1.png')) pygame.display.set_icon(icon) ## git ignore while RUNNING: ## Draw Menu ## if menu.get_menu: menu.draw_background() menu.draw_menu() for event in pygame.event.get(): if event.type == pygame.QUIT: RUNNING = False pygame.quit() sys.exit() menu.menu_input(event) if not menu.get_menu: Mediator.all_game_objects.append(player) surf = pygame.transform.scale(display, SCREEN_SIZE) screen.blit(surf, (0, 0)) pygame.display.update() else: ## Game loop ## for event in pygame.event.get(): if event.type == pygame.QUIT: RUNNING = False menu.draw_background_scrolling(display, DISPLAY_SIZE) for object in Mediator.all_game_objects: object.loop() object.draw() generator.generate() Mediator.all_game_objects = [ i for i in Mediator.all_game_objects if i not in Mediator.to_be_removed ] hud.draw_HUD() Mediator.to_be_removed.clear() ## Check if player is dead or game is completed if player.player_dead() or generator.get_game_complete(): generator = Generator(display) hud = HUD(display, player, DISPLAY_SIZE, generator) Mediator.all_game_objects.clear() menu.player_dead() player.reset_player() surf = pygame.transform.scale(display, SCREEN_SIZE) screen.blit(surf, (0, 0)) pygame.display.update() fpsClock.tick(FPS)
gameLoad.get_canvas_size() #Setup and classes text = TEXT.Text(0, 0, "YOU WON", SETTINGS.WHITE, "DUGAFONT.ttf", 48) beta = TEXT.Text(5, 5, "META ALFA BUILD V.1.6", SETTINGS.WHITE, "DUGAFONT.ttf", 20) text.update_pos( SETTINGS.canvas_actual_width / 2 - text.layout.get_width() / 2, SETTINGS.canvas_target_height / 2 - text.layout.get_height() / 2) #Classes for later use gameMap = MAP.Map(SETTINGS.levels_list[SETTINGS.current_level].array) gameCanvas = Canvas(SETTINGS.canvas_map_width, SETTINGS.canvas_map_height) gamePlayer = PLAYER.Player(SETTINGS.player_pos) gameRaycast = RAYCAST.Raycast(gameCanvas.canvas, gameCanvas.window) gameInv = INVENTORY.inventory({'bullet': 150, 'shell': 25, 'ferromag': 50}) gameHUD = HUD.hud() #More loading - Level specific gameLoad.load_new_level() #Controller classes menuController = MENU.Controller(gameCanvas.window) musicController = MUSIC.Music() tutorialController = TUTORIAL.Controller() #Run at last main_loop()
def tick(self, dt): HUD.clear() self.simulation.tick()
def Level(levelName, saveName): """ \"Level\" type constructor @param levelName: levelName containing all informations about the level @type levelName: str @param saveName: Path to save levelName of current player @type saveName: str @return: Dictionnary containing all informations about level @rtype: dict """ assert type("Levels/" + levelName) is str lsFiles = os.listdir("Levels/" + levelName) assert "background.pic" in lsFiles, "Load level from %r failed : missing file : background.pic" % levelName assert "foreground.pic" in lsFiles, "Load level from %r failed : missing file : foreground.pic" % levelName bgItem0 = Item.Item( Tools.createDatasFromPic("Levels/" + levelName + "/background.pic", True), 0, 0, [70, 70, 70], fgSpeed + 30) bgItem1 = Item.Item( Tools.createDatasFromPic("Levels/" + levelName + "/background.pic", True), Item.getBaseWidth(bgItem0), 0, [70, 70, 70], fgSpeed + 30) fgItem0 = Item.Item( Tools.createDatasFromPic("Levels/" + levelName + "/foreground.pic"), 0, 0, [0, 170, 0], fgSpeed) fgItem1 = Item.Item( Tools.createDatasFromPic("Levels/" + levelName + "/foreground.pic"), Item.getBaseWidth(fgItem0) - 1, 0, [0, 170, 0], fgSpeed) playerItem = loadPlayer(saveName) object = { "levelName": levelName, "bgItem0": bgItem0, "bgItem1": bgItem1, "fgItem0": fgItem0, "fgItem1": fgItem1, "playerItem": playerItem, "keyBinder": None, "enemyList": [], "playerScore": 0 } kb = KeyBinder.KeyBinder(levelName[levelName.rfind("/") + 1:]) KeyBinder.addAction(kb, "z", movePlayerUp, object) KeyBinder.addAction(kb, "q", movePlayerLeft, object) KeyBinder.addAction(kb, "s", movePlayerDown, object) KeyBinder.addAction(kb, "d", movePlayerRight, object) object["keyBinder"] = kb Item.setVX(object["playerItem"], 2.) Item.setVY(object["playerItem"], 1.) #load datas from config file : file = open("Levels/" + levelName + "/config", "r") content = file.read() file.close() exec(content) object["scoreObjective"] = scoreObjective object["maxEnemysNumber"] = maxEnemysNumber object["availableEnemys"] = availableEnemys hud = HUD.HUD(scoreObjective, Player.getMaxLife(playerItem)) object["HUD"] = hud #print start screen Tools.sysExec("clear") startText = "\033[18;" + str( int(round((Object.SCREEN_WIDTH / 2) + (len(str(scoreObjective)) / 2))) ) + "H\033[4;1m\033[38;2;200;0;0m" + str(scoreObjective) + "\033[0m" Menu.printScreen("Pictures/startLevelScreen.pic", 110) sys.stdout.write(startText) print("") KeyBinder.waitForKeyPressed() for i in range(0, maxEnemysNumber): addEnemy(object) return object
def interact(lvl): """ Interaction inside the level @param lvl: Dictionnary containing all information about one \"Level\" object @type lvl: dict @return: Code corresponding to level state : -1=Error; 0=In progress ; 1=Lose ; 2=Win @rtype: int """ assertLevel(lvl) if (lvl["playerScore"] >= lvl["scoreObjective"]): time.sleep(0.7) KeyBinder.clearBuffer() Menu.printScreen("Pictures/winText.pic", 45, "\033[1;92m") KeyBinder.waitForKeyPressed() return 2 if (Player.getLife(lvl["playerItem"]) <= 0): time.sleep(0.7) KeyBinder.clearBuffer() Menu.printScreen("Pictures/loseText.pic", 45, "\033[1;31;7;5m") KeyBinder.waitForKeyPressed() return 1 KeyBinder.interact(lvl["keyBinder"]) Item.move(lvl["bgItem0"], dt) Item.move(lvl["bgItem1"], dt) Item.move(lvl["fgItem0"], dt) Item.move(lvl["fgItem1"], dt) # ------- Manage background and foreground x = Object.getX(lvl["bgItem1"]) baseWidth = Item.getBaseWidth(lvl["bgItem0"]) #place part 1 of the background after the part 0 if (x <= -baseWidth): Object.setX(lvl["bgItem1"], baseWidth + Object.getX(lvl["bgItem0"])) #place part 0 of the background after the part 1 x = Object.getX(lvl["bgItem0"]) if (x <= -baseWidth): Object.setX(lvl["bgItem0"], baseWidth + Object.getX(lvl["bgItem1"])) x = Object.getX(lvl["fgItem1"]) baseWidth = Item.getBaseWidth(lvl["fgItem0"]) #place part 1 of the foreground after the part 2 if (x <= -baseWidth): Object.setX(lvl["fgItem1"], baseWidth + Object.getX(lvl["fgItem0"]) - 1) #place part 2 of the foreground after the part 1 x = Object.getX(lvl["fgItem0"]) if (x <= -baseWidth): Object.setX(lvl["fgItem0"], baseWidth + Object.getX(lvl["fgItem1"]) - 1) Player.interact(lvl["playerItem"]) # ----------- Manage enemys for i in lvl["enemyList"]: if (Object.getX(i) < -Item.getBaseWidth(i)): Enemy.kill(i) if (Enemy.interact(i) ): #if enemy dead and all his shots have disappeared lvl["enemyList"].remove(i) while (countAliveEnemys(lvl) < lvl["maxEnemysNumber"]): addEnemy(lvl) # ----------- Manage collisions #collisions between player and foreground if (Item.tryCollide(lvl["fgItem0"], lvl["playerItem"]) or Item.tryCollide(lvl["fgItem1"], lvl["playerItem"])): Player.takeDamage(lvl["playerItem"], 50) Player.giveImmute(lvl["playerItem"], 3) #collisions btween players shots and... for i in Player.getShotList(lvl["playerItem"]): #player shot and foregrounds if (Item.tryCollide(lvl["fgItem0"], i) or Item.tryCollide(lvl["fgItem1"], i)): delPlayerShot(lvl, i) #player shot and enemys for j in lvl["enemyList"]: if (Item.tryCollide(i, j)): Enemy.takeDamage(j, Player.getDamageValue(lvl["playerItem"])) if (Enemy.getIsDead(j) == False ): #if enemy is not dead, del shot delPlayerShot(lvl, i) #if enemy destroyed if (Enemy.getLife(j) == 0): addPlayerScore(lvl, Enemy.getScoreValue(j)) Enemy.setLife(j, -1) Enemy.kill(j) #collisions btween enemys and ... for j in lvl["enemyList"]: for i in Enemy.getShotList(j): #enemys shots and foreground if (Item.tryCollide(lvl["fgItem0"], i) or Item.tryCollide(lvl["fgItem1"], i)): delEnemyShot(j, i) #enemys shots and player if (Item.tryCollide(i, lvl["playerItem"])): Player.takeDamage(lvl["playerItem"], Enemy.getDamageValue(j)) delEnemyShot(j, i) HUD.refreshValues(lvl["HUD"], Player.getLife(lvl["playerItem"]), lvl["playerScore"]) return 0
class Scene(State): def __init__(self): super(Scene, self).__init__() pygame.mixer.init(44100, -16, 4, 2048) self.all_object_list = pygame.sprite.LayeredUpdates() self.zombie_list = pygame.sprite.Group() self.blood_splash = BloodSplash() self.background = Object() self.player = Player() self.zombie_sprite = [] self.grave_list = [] self.hud = HUD() self.sound_list = dict() self.bg_music = pygame.mixer.music self.game_over = False self.time = pygame.time.get_ticks() def init(self): self.read_scene() # Bring cursor to front self.all_object_list.move_to_front(self.player) # Set background music self.sound_list['background'].play().set_endevent(pygame.constants.USEREVENT) # Scale background to screen size self.background.image = pygame.transform.scale(self.background.image, (SCREEN_WIDTH, SCREEN_HEIGHT)) def process_events(self, event): if event.type == pygame.USEREVENT: self.sound_list['background'].play() elif event.type == pygame.MOUSEBUTTONDOWN: self.sound_list['gunshot'].play() self.process_raycast() elif event.type == pygame.KEYDOWN: if (event.key == pygame.K_p): if self.is_running: self.pause() else: self.resume() def update(self): if (not self.is_running): return # Process game self.process_zombie() # Update all objects self.all_object_list.update(self.hud) self.hud.update() def draw(self, screen): screen.fill(WHITE) self.all_object_list.draw(screen) apply_all(self.zombie_list.sprites(), 'show_timer', screen) self.hud.draw(screen) #--------------------------------------LOGIC PROCESSING SECTION----------------------------------------------- def process_zombie(self): # Randomly choose an interval between 0.5 to 1.5 second to spawn another zombie if (pygame.time.get_ticks() - self.time >= random.randrange(1, 3) * 500): # Random location for zombie zombie_pos = random.randrange(0, len(self.grave_list)) # Check if grave's position already had zombie if (not next((True for zombie in self.zombie_list.sprites() if zombie.pos == zombie_pos), False)): # Randomly pick zombie from zombie sprite list zombie = deepcopy(self.zombie_sprite[random.randrange(0, len(self.zombie_sprite))]) zombie.set_pos(zombie_pos) # Set zombie to the right position zombie.move_to(*self.grave_list[zombie_pos].get_pos()) zombie.translate(35, -10) # Set zombie layer zombie.set_layer(self.grave_list[zombie_pos]._layer - 1) # Add to zombie list and object list self.zombie_list.add(zombie) self.all_object_list.add(zombie) # Reset timer self.time = pygame.time.get_ticks() def process_raycast(self): mouse_pos = pygame.mouse.get_pos() hit_zombie = next((zombie for zombie in self.zombie_list.sprites() if zombie.collide_point(list(map(operator.sub, mouse_pos, zombie.get_pos())))), None) if (hit_zombie is not None): # Play zombie's death sound self.sound_list['dying_scream'].play() # Update hit count self.hud.update_hit() # Splash blood blood = deepcopy(self.blood_splash) blood.move_to(*self.player.get_pos()) blood.set_layer(self.all_object_list.get_top_layer() + 1) blood.show() self.all_object_list.add(blood) hit_zombie.kill() #----------------------------------------READ FILE SECTION----------------------------------------------------- def read_scene(self): with open(ResourceManager.scene_path_list[0]) as file: self.read_hud(file) self.read_background(file) self.read_player(file) self.read_grave(file) self.read_zombie(file) self.read_blood_splash(file) self.read_sound(file) def read_hud(self, file): file.readline() hud_id = int(file.readline().strip().split(' ')[1]) self.hud.init(ResourceManager.hud_path_list[hud_id]) def read_background(self, file): file.readline() image_id = int(file.readline().strip().split(' ')[1]) self.background.init('Image', file_name = ResourceManager.image_path_list[image_id]) self.all_object_list.add(self.background) def read_player(self, file): file.readline() image_id = int(file.readline().strip().split(' ')[1]) self.player.init('Image', file_name = ResourceManager.image_path_list[image_id], alpha = True) self.player.translate(*map(int, file.readline().strip().split(' ')[1:])) self.player.rotate(float(file.readline().strip().split(' ')[1])) self.player.scale(*map(float, file.readline().strip().split(' ')[1:])) self.all_object_list.add(self.player) def read_grave(self, file): file.readline() image_id = int(file.readline().strip().split(' ')[1]) grave = Object() grave.init('Image', file_name = ResourceManager.image_path_list[image_id], alpha = True) grave.translate(*map(int, file.readline().strip().split(' ')[1:])) grave.rotate(float(file.readline().strip().split(' ')[1])) grave.scale(*map(float, file.readline().strip().split(' ')[1:])) for i in range(3): for j in range(3): self.grave_list.append(deepcopy(grave)) self.grave_list[-1].translate(200 * j, 100 * i) self.grave_list[-1].set_layer(2 * (i + 1)) self.all_object_list.add(self.grave_list) def read_zombie(self, file): zombie_num = int(file.readline().strip().split(' ')[1]) for i in range(zombie_num): image_id = int(file.readline().strip().split(' ')[1]) self.zombie_sprite.append(Zombie()) self.zombie_sprite[-1].init('Image', file_name = ResourceManager.image_path_list[image_id], alpha = True) self.zombie_sprite[-1].translate(*map(int, file.readline().strip().split(' ')[1:])) self.zombie_sprite[-1].rotate(float(file.readline().strip().split(' ')[1])) self.zombie_sprite[-1].scale(*map(float, file.readline().strip().split(' ')[1:])) def read_blood_splash(self, file): file.readline() blood_id = int(file.readline().strip().split(' ')[1]) self.blood_splash.init('Image', file_name = ResourceManager.image_path_list[blood_id], alpha = True) self.blood_splash.translate(*map(int, file.readline().strip().split(' ')[1:])) self.blood_splash.rotate(float(file.readline().strip().split(' ')[1])) self.blood_splash.scale(*map(float, file.readline().strip().split(' ')[1:])) def read_sound(self, file): sound_num = int(file.readline().strip().split(' ')[1]) for i in range(sound_num): sound_type = file.readline().strip().replace('#', '') sound_id = int(file.readline().strip().split(' ')[1]) sound = pygame.mixer.Sound(ResourceManager.sound_path_list[sound_id]) self.sound_list.update({sound_type: sound})
def main(): pygame.init() pygame.mixer.init() # GET THE LIST liste = parser.parse_level() pygame.display.set_mode(get_coords(liste)) mainS = pygame.display.get_surface() platformGroup = pygame.sprite.Group() platformGroup, normGroup = add_platforms(platformGroup, liste) checkGroup = platformGroup.copy() checkGroup.add(normGroup) # playa = playerC.Player((100, 200)) playa = create_main(liste) enem = add_enemy(liste) enemGroup = pygame.sprite.Group(enem) # enemGroup.add(enem) # Create collectible items coll_itemG = pygame.sprite.Group() coll_itemG = create_collectible_items(coll_itemG, liste) slopeGroup = pygame.sprite.Group() slopeGroup = add_slopes(slopeGroup) actionG = add_action_items(liste) actionG = pygame.sprite.Group(actionG) otherG = add_other_items(liste) otherG = pygame.sprite.Group(otherG) extraG = add_extra(liste) clock = pygame.time.Clock() nowTime = 0 # current time timeSum = 0 # sum of time sp_blitpos = None myCam = scrollerC.Camera(scrollerC.complex_camera, level_w, level_h) # HUD myBar = HUD.HealthBar((10, 0)) myCoinHUD = HUD.itemHUD(coinHUDPath, GOLD, (10, myBar.h + 10)) myKeyHUD = HUD.itemHUD(keyHUDPath, GREEN, (myCoinHUD.rect.width + 64, myBar.h + 10)) myCursor = cursorC.Cursor() pygame.mouse.set_visible(False) # hide the actual mouse # DUMMY DATA OUTLIST = [0, 0] while True: for event in pygame.event.get(): if event.type == pygame.QUIT: handleQuit() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: playa.jump() elif event.key == pygame.K_z: for enem in enemGroup: if isinstance(enem, enemyC.Frog): print("{} {}", enem.y_vel, enem.mutex) elif event.key == pygame.K_x and playa.action_contact: if playa.action_obj.type == "SWITCH": playa.action_obj.used = not playa.action_obj.used # DEBUG INFO elif event.key == pygame.K_w: print(" PL {} MS {}".format(playa.rect.center, playa.intMousePos)) elif event.type == pygame.MOUSEBUTTONDOWN: playa.shoot_fire(myCam) myCursor.clicked = True keys = pygame.key.get_pressed() curPos = pygame.mouse.get_pos() mainS.fill(BLUE) # Main updates OUTLIST = playa.update(keys, myCam, mainS, checkGroup, actionG, slopeGroup, extraG) myCam.update(playa) # playa.canShift = False # remove player's ability to shift gravity doRotate = OUTLIST[0] nowTime = OUTLIST[1] # get current time mainTime = time.time() timeSum += mainTime - nowTime # toogle canShift on if sufficient time has passed if timeSum - (mainTime - nowTime) > 0.04: timeSum = 0 # reset counter playa.canShift = True platformGroup.update(mainS, doRotate) enemGroup.update(checkGroup, playa.powerGroup, playa, mainS, myCam) # check for dead enems for enemy in enemGroup: if not enemy.alive: enemGroup.remove(enemy) coll_itemG.update(playa) for item in coll_itemG: if item.consumed: coll_itemG.remove(item) actionG.update() otherG.update() extraG.update() switch_actlist = [] for item in actionG: if item.type == "SWITCH": switch_actlist.append(item) for item in otherG: if item.type == "DOOR": toogleItemState(item, switch_actlist) # apply camera for each in checkGroup: mainS.blit(each.image, myCam.use_cam(each)) sp_blitpos = myCam.use_cam(playa) for enemy in enemGroup: r1 = myCam.use_cam(enemy) mainS.blit(enemy.image, r1) for item in coll_itemG: mainS.blit(item.image, myCam.use_cam(item)) for slope in slopeGroup: mainS.blit(slope.image, myCam.use_cam(slope)) for each in actionG: mainS.blit(each.image, myCam.use_cam(each)) for each in otherG: mainS.blit(each.image, myCam.use_cam(each)) for each in extraG: mainS.blit(each.image, myCam.use_cam(each)) mainS.blit(playa.image, myCam.use_cam(playa)) myCoinHUD.update("coins", playa, mainS) myKeyHUD.update("keys", playa, mainS) myBar.update(playa.health, mainS) myCursor.final(mainS, curPos) pygame.display.update() clock.tick(60)
class TestApp(Label): def __init__(self, **kwargs): super(TestApp, self).__init__(**kwargs) Window.bind(on_key_down=self.onKeyDown) Window.bind(on_touch_down=self.onTouch) #TOUCH CAPABILITY self.touch_count = 0 #TOUCH CAPABILITY DEBUGGING COUNTER self.touch_count_label = CoreLabel( text='', font_size=15) #TOUCH CAPABILITY DEBUGGING COUNTER self.key_label = CoreLabel(text='', font_size=15) self.hud = HUD(self.canvas) self.gps_status_label = CoreLabel(text='', font_size=12) self.gps_location_label = CoreLabel(text='', font_size=12) self.uid_label = CoreLabel(text='UID: ', font_size=12) self.my_lat = 0 self.my_lon = 0 self.my_heading = 0 self.my_accuracy = 0 self.DEBUG = True def onTouch(self, touch, arg2): if self.DEBUG: print 'touch: ' + str(touch) print 'arg2: ' + str(arg2) if touch: try: self.hud.myUID = self.hud.data.pickUID(self.hud.myUID) self.uid_label.text = 'UID: ' + str(self.hud.myUID) if self.DEBUG: self.touch_count = self.touch_count + 1 except: print 'Touch event not handled correctly' def onKeyDown(self, something, keycode, text, something_else, modifiers, **kwargs): if self.DEBUG: print('The key', keycode, 'have been pressed') if self.DEBUG: print(' - text is %r' % text) if self.DEBUG: print(' - modifiers are %r' % modifiers) self.hud.scope_canvas.camera.setZoom(int(keycode)) if keycode == ENTER: self.hud.myUID = self.hud.data.pickUID(self.hud.myUID) self.uid_label.text = 'UID: ' + str(self.hud.myUID) def updateDisplay(self, text): if self.DEBUG: print 'Inside updateDisplay' self.hud.my_lat = self.my_lat self.hud.my_lon = self.my_lon self.hud.my_heading = self.my_heading self.canvas.clear( ) #Alias for scope_canvas. Actually clears scope_canvas for fresh draw (naming convention can be misleading) self.hud.scope_canvas.paintDisplayBackground( ) #Reinitializes the canvas with HUD background self.hud.work( ) #Retrieves data and draws appropriately on HUD background canvas #TEMPORARY label drawing for debugging purposes if self.DEBUG: with self.canvas: #Display gps_location Color(.5, 1, 0, mode='rgb') self.gps_location_label.refresh() texture = self.gps_location_label.texture texture_size = list(texture.size) Rectangle(pos=(BAR_TEXT_OFFSET + 10, GRAPH_OFFSET_TOP_BOTTOM + 20), texture=texture, size=texture_size) #Display UID Color(.5, 1, 0, mode='rgb') self.uid_label.refresh() texture = self.uid_label.texture texture_size = list(texture.size) Rectangle(pos=(HUD_WIDTH - BAR_TEXT_OFFSET - GRAPH_WIDTH - 100, GRAPH_OFFSET_TOP_BOTTOM - 20), texture=texture, size=texture_size) #Display touch count Color(.5, 1, 0, mode='rgb') self.touch_count_label.text = str(self.touch_count) self.touch_count_label.refresh() texture = self.touch_count_label.texture texture_size = list(texture.size) Rectangle(pos=(HUD_WIDTH - GRAPH_WIDTH - BAR_TEXT_OFFSET - 35, HUD_HEIGHT / 4), texture=texture, size=texture_size)
def playGame(screen, character, currentInfoText): screen_rect = screen.get_rect() level = LevelTutorial("level/tutorial/tutorial.txt", character, currentInfoText) world = level.world crashman = level.crashman pygame.mouse.set_visible(True) camera = Camera(screen, crashman.rect, level) all_sprite = level.all_sprite clock = pygame.time.Clock() up = down = left = right = False x, y = 0, 0 #randomly selects an enemy port enemy_list=[] activePortIndex=random.randrange(len(level.enemy_ports)) activePort=level.enemy_ports[activePortIndex] #untilNextSpawn=level.spawn_delay untilNextSpawn=0 totalTime=0 enemyCount=0 hud=HUD() #this is the while true loop while crashman.alive : for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() if event.type == KEYDOWN and (event.key == K_ESCAPE or event.key==K_RETURN): up=down=left=right=False pauseScreen(screen,character) #control crashman keys = pygame.key.get_pressed() #checking pressed keys if keys[pygame.K_UP] or keys[pygame.K_SPACE]: up=True else: up=False if keys[pygame.K_DOWN]: down=True else: down=False if keys[pygame.K_LEFT]: left=True else: left=False if keys[pygame.K_RIGHT]: right=True else: right=False #sequential spawn order if untilNextSpawn<=0 and enemyCount<level.enemy_max: print "ENEMY HERE NOW" e=Enemy(activePort[0],activePort[1],activePort[2],level) enemy_list.append(e) level.all_sprite.add(e) world.append(e) activePortIndex+=1 if activePortIndex>=len(level.enemy_ports): activePortIndex=0 activePort=level.enemy_ports[activePortIndex] untilNextSpawn=level.spawn_delay enemyCount+=1 #random spawn order """if untilNextSpawn<=0 and enemyCount<level.enemy_max: print "ENEMY HERE NOW" e=Enemy(activePort[0],activePort[1],activePort[2],level) enemy_list.append(e) level.all_sprite.add(e) world.append(e) activePortIndex=random.randrange(len(level.enemy_ports)) activePort=level.enemy_ports[activePortIndex] untilNextSpawn=level.spawn_delay enemyCount+=1""" #removes dead enemies for e in enemy_list: if e.alive==False: print "ded del thjo" enemy_list.remove(e) all_sprite.remove(e) world.remove(e) enemyCount-=1 if e.freshkick==True: hud.enemies_defeated+=1 hud.update() e.freshkick=False #timer and spawn countdown #updates hud time tpt = tps(clock, FPS) totalTime+=tpt if hud.time!=math.floor(totalTime): hud.time=math.floor(totalTime) hud.update() if enemyCount<level.enemy_max: untilNextSpawn-=tpt print str(enemyCount)+": "+str(untilNextSpawn) #DRAW ORDER: #bg, world, elemental, hud #camera.draw_sprites(screen, all_sprite) level.drawBG(screen) camera.draw_sprites_prio(screen, all_sprite, crashman) if level.elemental: level.elementalOverlay.draw(screen) hud.draw(screen) level.drawInfo(screen) #final updates crashman.update(up, down, left, right) for e in enemy_list: e.update(tpt) camera.update() pygame.display.flip() ################################# #game complete #pygame.display.flip() playGame(screen,character, level.currentInfoBlock.infoText)
#Probably temporary object init #SETTINGS.current_level = 5 #temporary if __name__ == '__main__': gameLoad = Load() gameLoad.load_resources() gameLoad.load_entities() mapGenerator = GENERATION.Generator() mapGenerator.generate_levels(5, 4) gameLoad.get_canvas_size() #Setup and classes thanks = TEXT.Text(150, 250, "THANKS FOR PLAYING DUGA TECH DEMO", SETTINGS.WHITE, "DUGAFONT.ttf", 24) #Classes for later use gameMap = MAP.Map(SETTINGS.levels_list[SETTINGS.current_level].array) gameCanvas = Canvas(SETTINGS.canvas_map_width, SETTINGS.canvas_map_height) gamePlayer = PLAYER.Player(SETTINGS.player_pos) gameRaycast = RAYCAST.Raycast(gameCanvas.canvas, gameCanvas.window) gameInv = INVENTORY.inventory({'bullet': 150, 'shell': 25, 'ferromag': 50}) gameHUD = HUD.hud(path.join('graphics', 'hud.png')) #More loading - Level specific gameLoad.load_new_level() #Run at last main_loop()
screen = pygame.display.set_mode(size) sound_profile = Sounds() Splash().start_screen(screen, GetImage('Rules.png').load_image()) motion_events_1 = [26, 4, 22, 7] motion_events_2 = [82, 80, 81, 79] change_event_1 = 44 change_event_2 = 229 forfeit_event_1 = 9 forfeit_event_2 = 228 board_width = 7 board_height = 7 board = Board(board_width, board_height, size) hud = HUD.Hud(size, board_width * board.cell_size, screen) game = Game.Game(board_width * board_height - 2, hud, sound_profile) running = True screen.fill((255, 255, 255)) board.render(screen) board.set_players() pygame.display.flip() while running: if game.won or game.check_end(): pass else: board.update(screen) board.render(screen) hud.draw(game, board.player1, board.player2)
def launch(self, diff): print('Launching game ...') self.screen = pygame.display.set_mode( [self.screen_width, self.screen_height]) pygame.display.set_caption("Road to Mordor") self.clock = pygame.time.Clock() self.joueur = joueur_classe.Joueur("Player 1", "humain", 1) self.joueurIA = joueur_classe.Joueur("Computer", "orc", 0) self.hud = HUD.UserInterface(self.screen, self.joueur, self.joueurIA) self.grille = grille_classe.Grille( 16, 20, diff, self.screen.subsurface((205, 50, 1000, 800)), self.hud, self.joueurIA, self.joueur) self.IA = IA.IA(self.grille, self.joueurIA) self.ig_menu = ig_menu_classe.InGameMenu(self.screen) self.rules = regles_classe.Regles(self.screen) self.game_over = fin_jeu.Fin(self.screen) pygame.mixer.music.load('Musique/Musiquedefond.mp3') pygame.mixer.music.play(-1) turn = 0 done = False show_regles = False show_gameOver = False # -------- Main Program Loop ----------- keys_pressed = dict() pygame.event.Event(pygame.USEREVENT, {'key': 0, 'unicode': ''}) while not done: turn += 1 # --- Main event loop for event in pygame.event.get(): #print('EVENT ', pygame.event.event_name(event.type)) if event.type == pygame.QUIT: print('Ending game ... and QUIT !') return False elif event.type == pygame.KEYDOWN: #keys_pressed[event.key] = {'key': event.key, 'unicode': event.unicode} # Create KEYPRESS events if len(keys_pressed) > 0: pygame.time.set_timer(pygame.USEREVENT, 150) if self.paused: if show_regles: show_regles = False else: if event.key == pygame.K_RETURN: res_m = self.ig_menu.getSelected() if res_m == 0: pygame.mixer.music.unpause() self.paused = False elif res_m == 1: show_regles = True elif res_m == 2: self.paused = False print('Ending game ...') return True elif event.key == pygame.K_ESCAPE: self.paused = False pygame.mixer.music.unpause() elif event.key == pygame.K_LEFT: self.ig_menu.selectPrev() else: self.ig_menu.switchSelected() elif show_gameOver: print('Ending game ...') self.game_over.stop() return True else: # Handle KEYDOWN if event.unicode == 'd': self.hud.selectNext() elif event.unicode == 'q': # Q sur un Azerty self.hud.selectPrev() elif event.unicode == 'a': # A sur un Azerty self.hud.switchMode() elif event.unicode == '-': print('- HEY !') elif event.unicode == '.': self.joueurIA.setVieChateau(0) elif event.key == pygame.K_ESCAPE: self.paused = True pygame.mixer.music.pause() elif event.key == pygame.K_UP: self.grille.selectUp() elif event.key == pygame.K_DOWN: self.grille.selectDown() elif event.key == pygame.K_LEFT: self.grille.selectLeft() elif event.key == pygame.K_RIGHT: self.grille.selectRight() elif event.key == pygame.K_RETURN: if self.hud.canUse(): if self.hud.getMode() == 'towers': if self.grille.canBuild( self.grille.getSelected(), self.joueur.getEquipe()): tour = self.joueur.createBuild( self.hud.getSelected(), self.grille, self.grille.getSelected()) if tour == False: self.hud.showMessage( "Argent insufisant ...", 70) print('Argent insufisant') else: self.grille.place(tour) self.hud.use() else: self.hud.showMessage( "Placement impossible !", 70) print('Placement impossible') else: if self.grille.canSpawn( self.grille.getRoute(), self.joueur.getEquipe()): unit = self.joueur.createUnit( self.hud.getSelected(), self.grille, self.grille.getRoute()) if unit == False: self.hud.showMessage( "Argent insufisant ...", 70) print('Argent insufisant') else: self.grille.place(unit) self.hud.use() else: self.hud.showMessage( "Placement impossible !", 70) print('Placement impossible') else: self.hud.showMessage("Cooldown en cours.", 70) print('Cooldown en cours') """ elif event.type == pygame.KEYUP: keys_pressed.pop(event.key) # Create KEYPRESS events if len(keys_pressed)<=0: pygame.time.set_timer(pygame.USEREVENT,0) # Remove timer elif event.type == pygame.USEREVENT: for key,item in keys_pressed.iteritems(): if key == pygame.K_UP: self.grille.selectUp() elif key == pygame.K_DOWN: self.grille.selectDown() elif key == pygame.K_LEFT: self.grille.selectLeft() elif key == pygame.K_RIGHT: self.grille.selectRight() """ # --- Game logic should go here #pygame.display.update() self.screen.fill((75, 75, 75)) if self.paused: if show_regles: self.rules.draw() else: self.ig_menu.draw() elif show_gameOver: self.game_over.draw() else: self.grille.draw() self.hud.draw() if turn % 300 == 0: self.joueur.recevoirArgent(100) self.joueurIA.recevoirArgent(100) if turn % 5 == 0: self.IA.play() if turn % 10 == 0: self.grille.play() # --- Check if the game is over if self.joueur.getVieChateau() == 0 and not show_gameOver: show_gameOver = True pygame.mixer.music.stop() self.game_over.start(False) elif self.joueurIA.getVieChateau() == 0 and not show_gameOver: show_gameOver = True pygame.mixer.music.stop() self.game_over.start(True) # --- Go ahead and update the screen with what we've drawn. pygame.display.flip() # --- Limit to 60 frames per second self.clock.tick(60) # Close the window and quit. print('Ending game ...') return True
def on_draw(self): arcade.start_render() if self.empezado: if self.pausado: HUD.dibujar_hud_pausado(self.buffs_activos) elif self.final_malo: HUD.dibujar_hud_gameover(True) elif self.jugador.muerto: HUD.dibujar_hud_gameover(False) else: # Draw the background texture arcade.draw_lrwh_rectangle_textured(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, self.rooms[self.current_room].background) HUD.dibujar_hud(self.vida_jugador, self.carga_fantasmal_jugador) if self.jugador.estado_fantasmal: HUD.dibujar_contador_de_muerte(self.jugador.contador_de_muerte) self.rooms[self.current_room].wall_list.draw() self.player_list.draw() self.bullet_list.draw() self.lista_balas_laser.draw() self.lista_balas_gas.draw() self.lista_balas_boss.draw() # Mostramos mensajes relacionados con los buffs que vayamos cogiendo if self.recogido_buff1: HUD.mostrar_mensaje_buff(1) if self.contador_quitar_mensaje == 0: self.recogido_buff1 = False self.contador_quitar_mensaje = 600 else: self.contador_quitar_mensaje -= 1 elif self.recogido_buff2: HUD.mostrar_mensaje_buff(2) if self.contador_quitar_mensaje == 0: self.recogido_buff2 = False self.contador_quitar_mensaje = 600 else: self.contador_quitar_mensaje -= 1 elif self.recogido_buff3: HUD.mostrar_mensaje_buff(3) if self.contador_quitar_mensaje == 0: self.recogido_buff3 = False self.contador_quitar_mensaje = 600 else: self.contador_quitar_mensaje -= 1 elif self.recogido_buff4: HUD.mostrar_mensaje_buff(4) if self.contador_quitar_mensaje == 0: self.recogido_buff4 = False self.contador_quitar_mensaje = 600 else: self.contador_quitar_mensaje -= 1 elif self.recogido_buff5: HUD.mostrar_mensaje_buff(5) if self.contador_quitar_mensaje == 0: self.recogido_buff5 = False self.contador_quitar_mensaje = 600 else: self.contador_quitar_mensaje -= 1 self.rooms[self.current_room].recargas_list.draw() if self.rooms[self.current_room].buffs_list is not None: self.rooms[self.current_room].buffs_list.draw() HUD.dibujar_partes_artefacto(self.buffs_activos) self.rooms[self.current_room].enemigos_list.draw() self.rooms[self.current_room].boss_list.draw() self.rooms[self.current_room].balas_list.draw() if self.current_room == 68: # Ponemos a la dama observando if len(self.dama_list) == 0 and not self.ending_activado: # para poner solo 1 dama a la vez self.dama_list.append(self.dama_fant_der) if self.ending_activado: if self.contador_espera_mover_dama == 0: # Ponemos a la dama en la habitacion if len(self.dama_list) == 0: self.dama_list.append(self.dama_fant_abajo) if self.contador_espera_poner_artefacto == 0: # Ponemos el dispositivo fantasmal disp_f = arcade.load_texture("sprites_master" + os.path.sep + "DISPOSITIVOFANTASMA.png") arcade.draw_texture_rectangle(self.jugador.center_x, self.jugador.center_y + 100, 50, 50, disp_f) if self.contador_espera_transformar_dama == 0: if self.dama_fant_abajo in self.dama_list: self.dama_list.pop(0) self.dama_list.append(self.dama_abajo) if self.contador_espera_pantalla_final == 0: # Dibujamos la pantalla final self.dama_list.pop(0) HUD.dibujar_pantalla_final() else: self.contador_espera_pantalla_final -= 1 else: self.contador_espera_transformar_dama -= 1 else: self.contador_espera_poner_artefacto -= 1 else: self.contador_espera_mover_dama -= 1 self.dama_list.draw() else: if self.mirando_controles: HUD.dibujar_controles() else: HUD.dibujar_pantalla_de_inicio()
class GameManager(object): screen = None buffer = None gameObject = None targetFPS = 60 clock = None buttonHandler = None hud = HUD.HUD() drawHUD = True piFaceManager = None gameState = None needQuit = False sound = None def __init__(self, initialGameObject, targetFPS, buttonHandler, piFaceManager, test=False): if test: self.initializeTest() else: self.gameState = GameStateSaver.GameStateSaver() self.gameObject = initialGameObject self.hud.gameState = self.gameState self.targetFPS = targetFPS self.buttonHandler = buttonHandler self.piFaceManager = piFaceManager self.initialize() return super(GameManager, self).__init__() def setCurrentGameObject(self, gameObject): if not gameObject.initialized: pygame.time.set_timer(USEREVENT + 1, 0) pygame.time.set_timer(USEREVENT + 2, 0) gameObject.gameManager = self gameObject.initialize() self.buttonHandler.unlock() self.gameObject = gameObject self.gameObject.sound = self.sound self.sound.resetGameObjectSound() self.piFaceManager.setPlayerButtonColor(0, "off") gameObject.switchedTo() self.gameState.save() def update(self, time, events): self.gameObject.update(time, events) self.hud.update(time, events) def draw(self): '''Draws current GameObject. Since fbcon seems to have most performance on raspi but doesn't support double buffering, a surface is used to simulate double buffering to prevent flickering (won't solve all problems though)''' self.gameObject.draw(self.buffer) if self.drawHUD: self.hud.draw(self.buffer) self.screen.blit(self.buffer, (0, 0)) def initialize(self): pygame.init() self.screen = pygame.display.set_mode( (1024, 768), pygame.DOUBLEBUF | pygame.HWSURFACE | pygame.FULLSCREEN) pygame.mouse.set_visible(True) self.buffer = pygame.Surface(self.screen.get_size()) self.buffer = self.buffer.convert() self.buffer.fill((250, 0, 250)) self.screen.blit(self.buffer, (0, 0)) pygame.display.flip() print "Using driver", pygame.display.get_driver() print "Set SDL_VIDEODRIVER to change" print "-----------------------------" print "Driver Info:" print pygame.display.Info() self.clock = pygame.time.Clock() self.hud.initialize() self.sound = SoundObject.SoundObject(self.gameState.appdir) self.gameObject.sound = self.sound def initializeTest(self): pygame.init() self.screen = pygame.display.set_mode( (1024, 768), pygame.DOUBLEBUF | pygame.HWSURFACE) pygame.mouse.set_visible(True) self.buffer = pygame.Surface(self.screen.get_size()) self.buffer = self.buffer.convert() self.buffer.fill((250, 0, 250)) self.screen.blit(self.buffer, (0, 0)) pygame.display.flip() print "Using driver", pygame.display.get_driver() print "Set SDL_VIDEODRIVER to change" print "-----------------------------" print "Driver Info:" print pygame.display.Info() self.clock = pygame.time.Clock() font = pygame.font.Font(pygame.font.get_default_font(), 45) size = font.size("OK") r = 0 g = 0 b = 255 tor = True tog = False tob = False while 1: if tor: r += 1 b -= 1 if b == 0: tor = False tog = True if tog: g += 1 r -= 1 if r == 0: tog = False tob = True if tob: b += 1 g -= 1 if g == 0: tob = False tor = True currentMillis = self.clock.tick(self.targetFPS) events = pygame.event.get() self.buffer.fill((r, g, b)) self.buffer.blit(font.render("OK", True, (255, 255, 255)), ((1024 - size[0]) / 2, (768 - size[1]) / 2)) self.screen.blit(self.buffer, (0, 0)) pygame.display.flip() #Handle Input Events - FOR TESTING ONLY - Events have to be checked by the GameObjects... for event in events: if event.type == QUIT: pygame.display.quit() return elif event.type == KEYDOWN and event.key == K_ESCAPE: pygame.display.quit() return def run(self): # try: while 1: currentMillis = self.clock.tick(self.targetFPS) events = pygame.event.get() self.update(currentMillis, events) self.draw() pygame.display.flip() #Handle Input Events - FOR TESTING ONLY - Events have to be checked by the GameObjects... for event in events: if event.type == QUIT: pygame.display.quit() self.sound.resetGameObjectSound() return elif event.type == KEYDOWN and event.key == K_ESCAPE: pygame.display.quit() self.sound.resetGameObjectSound() return if self.needQuit: pygame.display.quit() self.sound.resetGameObjectSound() return
from HUD import * pygame.init() WINDOW_SIZE = (1024,768) clock = pygame.time.Clock() screen = pygame.display.set_mode(WINDOW_SIZE,0,32) display = pygame.Surface((256,192)) mediator = Mediator() player = Player(display, 'player', mediator) mediator.all_game_entities.append(player) gameMap = GameMap(display, 'tiles', mediator, player) hud = HUD(display,player) while True: display.fill((57, 138, 215)) mediator.all_game_tiles.clear() gameMap.draw_map() hud.draw_overlay() for object in mediator.all_game_entities: object.loop() object.draw() mediator.all_game_entities = [object for object in mediator.all_game_entities if object not in mediator.to_be_removed] mediator.to_be_removed.clear()
from time import sleep from HUD import * from Game import Game hud = HUD() game = Game() game.start() while game.isRunning: gameState = game.getState() game.clearWithHUD() game.update() hud.update(gameState[0], gameState[1], gameState[2]) hud.print() game.render() # print(game.balls[0].position, game.balls[0].dir, game.balls[0].speed, " ") sleep(0.06)
def run_Game(): main_menu = Main_menu() pause_menu = Pause_menu() main_menu.draw() onMenu = 1 onGame = 0 tick = 0 while onMenu: for ev in event.get(): if ev.type == QUIT: display.quit() quit() return elif ev.type == KEYDOWN: if not first_screen(main_menu, ev): if not second_screen(main_menu, ev): third_screen(main_menu, ev) main_menu.drawFocus() if main_menu.current_screen == len(main_menu.screens): onMenu = 0 onGame = 1 main_menu.current_screen -= 1 display.update() clock.tick(60) display.set_mode((1024, 700)) if main_menu.charSelect == 0: player = WaveController() else: player = SpearBearer() hud = HUD(player) level = LevelOne() level.draw() camera = Camera(level.image.get_size()[0], level.image.get_size()[1]) while onGame: if level.cleared() == 1: player.hp = player.hpmax player.mana = player.manamax level = LevelTwo() elif level.cleared() == 2: player.hp = player.hpmax player.mana = player.manamax level = LevelTwoPointOne() keys = key.get_pressed() for ev in event.get(): if ev.type == QUIT: display.quit() quit() return elif ev.type == KEYDOWN: if ev.key == K_p: image.save(screen, path + "/.tmp/game.png") pause_menu.paused() elif ev.key == K_k: all_sprites.remove(enemies) enemies.empty() else: player.action(ev.key, tick) if keys[K_DOWN]: player.move_down() level.update(player, 2) if keys[K_UP]: level.update(player, 3) player.move_up() if keys[K_RIGHT]: player.move_right() level.update(player, 1) if keys[K_LEFT]: player.move_left() level.update(player, 0) check_collisions() level.draw() player.update(tick) all_sprites.draw(screen) hud.draw(player) enemies.update(player, tick) spells.draw(screen) e_spells.draw(screen) display.update() tick += 1 clock.tick(60) quit()