class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition( 'evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.alternate = 1 self.direction_floor = 1 self.imune = 0 self.move = 0 self.countmove = 0 self.rect.x = 500 self.timeenemy = 0 self.twists = [] self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 def update(self, dt, game): if game.time == 1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640, 500, 400, 300]) # Defines game mode for player action. if game.enemymode == 'static': # Enemy controlled by static movements. if self.resting == 1 and self.timeenemy >= 95 and self.timeenemy <= 110: atack1 = 1 else: atack1 = 0 if self.resting == 0: atack2 = 1 else: atack2 = 0 if (game.player.rect.right < game.enemy.rect.left and abs(game.player.rect.right - game.enemy.rect.left) <= 50) or (game.enemy.rect.right < game.player.rect.left and abs(game.enemy.rect.right - game.player.rect.left) <= 50): atack3 = 1 else: atack3 = 0 elif game.enemymode == 'ai': # Player controlled by AI algorithm. # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 3: game.print_logs( "ERROR: Enemy 1 controller must return 3 decision variables." ) sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] if atack2 == 1 and not self.gun_cooldown: atack2 = 1 else: atack2 = 0 # if the 'start game' marker is 1 if game.start == 1: self.timeenemy += 1 # increments enemy timer # moving floor, changes the movement direction from time to time. for cell in game.tilemap.layers['triggers'].collide( game.player.rect, 'blockers'): blockers = cell['blockers'] if 't' in blockers: game.player.rect.x += self.direction_floor * 100 * dt # moves player over the moving floor # limits player inside the screen if game.player.rect.left < 60: game.player.rect.left = 61 if game.player.rect.right > 665: game.player.rect.right = 665 if game.time % 120 == 0: self.direction_floor = self.direction_floor * -1 last = self.rect.copy() # copies last position state of the enemy # if player gets too close to the enemy, he jumps to the other side. if (self.resting == 1 and atack3 == 1): self.move = 1 self.dy = -900 self.resting = 0 if self.move == 1: self.rect.x += self.direction * 900 * dt if self.move == 1 and self.rect.x < 200: self.rect.x = 200 self.direction = self.direction * -1 self.move = 0 if self.move == 1 and self.rect.x > 500: self.rect.x = 500 self.direction = self.direction * -1 self.move = 0 # jumps from time to time or when player atacks if ((self.resting == 1 and atack1 == 1) or (self.resting == 1 and game.player.atacked == 1)): self.dy = -900 self.resting = 0 # releases until 4 bullets (decided randomly) after jumping or when player atacks if (atack2 == 1 and not self.gun_cooldown): self.shooting = 5 self.gun_cooldown = 3 # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) aux = numpy.random.randint(1, 4) for i in range(0, aux): self.twists.append( Bullet_e5((self.rect.x + (self.direction * (i * 30)), self.rect.top + (self.direction * (i * 20))), self.direction, game.player.rect, len(self.twists), game.sprite_e)) self.timeenemy = 0 # reinicializes enemy timer if game.player.atacked == 1: # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) self.twists.append( Bullet_e5((self.rect.x, self.rect.top), self.direction, game.player.rect, len(self.twists), game.sprite_e)) self.gun_cooldown = max( 0, self.gun_cooldown - dt) # decreases time for bullets limitation # animation, running enemy images alternation. if self.direction > 0: direction = SpriteConstants.RIGHT else: direction = SpriteConstants.LEFT if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, direction) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, direction) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, direction) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # changes the image when enemy jumps if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max( 0, game.player.life - (game.level * 0.3)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life - (game.level * 0.3)) # pushes player when he collides with the enemy game.player.rect.x += self.direction * 50 * dt # limits the player to stand on the screen space even being pushed. if game.player.rect.x < 60: game.player.rect.x = 60 if game.player.rect.x > 620: game.player.rect.x = 620 # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits agaist enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide( new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # hurt enemy animation if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -= 1 # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0, self.shooting) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition('evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.alternate = 1 self.imune = 0 self.timeenemy = 0 self.twists = [] self.bullets = 0 self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 self.gun_cooldown2 = 0 def update(self, dt, game): if game.time==1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640,500,400,300]) # defines game mode for player actionv if game.enemymode == 'static': # enemy controlled by static movements if self.timeenemy>=4 and self.timeenemy<=20 and self.timeenemy%4 == 0: atack1 = 1 else: atack1 = 0 atack2 = 1 #useless if self.timeenemy==4: atack2 = 1 else: atack2 = 0 if self.timeenemy==5: atack3 = 1 else: atack3 = 0 if self.timeenemy>=50 and self.timeenemy<80: atack4 = 1 else: atack4 = 0 if self.timeenemy == 50: atack5 = 1 else: atack5 = 0 if self.timeenemy == 100: atack6 = 1 else: atack6 = 0 elif game.enemymode == 'ai': # Player controlled by AI algorithm. # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 6: game.print_logs("ERROR: Enemy 1 controller must return 6 decision variables.") sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] atack4 = actions[3] atack5 = actions[4] atack6 = actions[5] if atack1 == 1 and not self.gun_cooldown2: atack1 = 1 else: atack1 = 0 if atack3 == 1 and not self.gun_cooldown: atack3 = 1 else: atack3 = 0 # marks the flag indicating to the player that the map is on water environment game.player.inwater = 1 # if the 'start game' marker is 1 if game.start == 1: # increments enemy timer self.timeenemy += 1 # copies last position state of the enemy last = self.rect.copy() # calculates a relative distance factor, between the player and enemy to set up the jumping strengh aux_dist = (abs(game.player.rect.right - self.rect.right)/490.0)+0.3 # shoots 5 bullets positioned over the same range if atack1 == 1: self.shooting = 5 self.gun_cooldown2 = 3 # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) rand = numpy.random.randint(0, 25, 1) self.twists.append(Bullet_e7((self.rect.x,self.rect.y), self.direction, len(self.twists), game.sprite_e)) # throws from 1 to 3 bubbles, starting at slighly different positions if self.bullets == 0: # if the bubblues have gone away, enemy is abble to realease new bubbles. rand = 2 for i in range(0,rand): if atack3 == 1: self.gun_cooldown = 3 self.bullets += 1 self.twists.append(Bullet_e72((self.rect.x+self.direction*i*30 ,self.rect.y-i*30), self.direction, len(self.twists), game.sprite_e)) # decreases time for bullets limitation self.gun_cooldown = max(0, self.gun_cooldown - dt) # decreases time for bullets limitation self.gun_cooldown2 = max(0, self.gun_cooldown2 - dt) # enemy moves during some time, after standing still for a while if atack4 == 1: self.rect.x += self.direction * 600 * aux_dist * dt * 0.7 # enemy jumps while is moving if self.resting == 1 and atack5 == 1: self.dy = -1500 self.resting = 0 # at the end of the atack cicle, enemy turns over the players direction. if atack6 == 1: if game.enemymode == 'static': if game.player.rect.right < self.rect.left: self.direction = -1 if game.player.rect.left > self.rect.right: self.direction = 1 else: self.direction = self.direction * -1 # reinicializes enemy timer self.timeenemy = 0 # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt * 0.4 # changes the image when enemy jumps or stands up if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) else: if self.direction == -1: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.RIGHT) # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max(0, game.player.life-(game.level*0.3)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life-(game.level*0.3)) game.player.rect.x += self.direction * 50 * dt # pushes player when he collides with the enemy # limits the player to stand on the screen space even being pushed if game.player.rect.x < 60: game.player.rect.x = 60 if game.player.rect.x > 620: game.player.rect.x = 620 if self.rect.x < 70: self.rect.x = 70 if self.rect.x > 610: self.rect.x = 610 game.player.hurt = 5 # Sets flag to change the player image when he is hurt. # controls screen walls and platforms limits agaist enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide(new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # hurt enemy image if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -=1 # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0,self.shooting) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition( 'evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.twists = [] self.alternate = 1 self.imune = 0 self.timeenemy = 0 self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 def update(self, dt, game): if game.time == 1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640, 500, 400, 300]) # defines game mode for player action if game.enemymode == 'static': # enemy controlled by static movements if self.timeenemy >= 120 and self.timeenemy <= 140: atack1 = 1 else: atack1 = 0 if self.timeenemy == 130: atack2 = 1 else: atack2 = 0 if self.timeenemy > 140: atack3 = 1 else: atack3 = 0 if self.timeenemy == 30: atack4 = 1 else: atack4 = 0 elif game.enemymode == 'ai': # player controlled by AI algorithm # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 4: game.print_logs( "ERROR: Enemy 1 controller must return 4 decision variables." ) sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] atack4 = actions[3] if atack4 == 1 and not self.gun_cooldown: atack4 = 1 else: atack4 = 0 # if 'start game' is true if game.start == 1: self.timeenemy += 1 # increments enemy timer # copies last position state of the enemy last = self.rect.copy() # movements of the enemy on the axis x if atack1 == 1: self.rect.x += self.direction * 180 * dt # goes forward # jumps if atack2 == 1 and self.resting == 1: self.dy = -700 self.resting = 0 # animation, running enemy images alternatetion if self.direction > 0: direction = SpriteConstants.RIGHT else: direction = SpriteConstants.LEFT if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, direction) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, direction) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, direction) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # changes the image when enemy jumps if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) else: # animation, standing up images if self.direction == -1: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.RIGHT) # restart enemy's timer from time to time, so that he stops moving. if atack3 == 1: self.timeenemy = 20 # puts the enemy turned to the player's direction if game.enemymode == 'static': if game.player.rect.right < self.rect.left: self.direction = -1 elif game.player.rect.left > self.rect.right: self.direction = 1 else: self.direction = self.direction * -1 # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max(0, game.player.life - (game.level * 1)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life - (game.level * 1)) # pushes player when he collides with the enemy game.player.rect.x += self.direction * 50 * dt # limits the player to stand on the screem space even being pushed if game.player.rect.x < 60: game.player.rect.x = 60 if game.player.rect.x > 620: game.player.rect.x = 620 # sets flag to change the player image when he is hurt game.player.hurt = 5 # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits agaist enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide( new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # enemy shoots if atack4 == 1: self.shooting = 5 self.gun_cooldown = 3 # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) # shoots 4 bullets placed in fixed places - bullets coming from the enemy. for i in range(0, 4): ay = [-10, -10, 20, -45] if self.direction > 0: ax = [-24, 50, 1, 1] self.twists.append( Bullet_e3( (self.rect.x + ax[i], self.rect.y - ay[i]), 1, 'h', len(self.twists), game.sprite_e)) else: ax = [25, -50, -7, -7] self.twists.append( Bullet_e3( (self.rect.x - ax[i], self.rect.y - ay[i]), -1, 'h', len(self.twists), game.sprite_e)) # shoots 4 bullets placed in fixed places - bullets coming from the top of the screen aux = 100 for i in range(0, 4): self.twists.append( Bullet_e3((aux, 100), 1, 'v', len(self.twists), game.sprite_e)) aux = aux + 150 # decreases time for bullets limitation self.gun_cooldown = max(0, self.gun_cooldown - dt) # hurt enemy animation if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -= 1 # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0, self.shooting) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition('evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.alternate = 1 self.just_shoot = 0 self.imune = 0 self.timeenemy = 0 self.twists = [] self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 def update(self, dt, game): if game.time==1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640,500,400,300]) # defines game mode for player action if game.enemymode == 'static': # enemy controlled by static movements if (self.timeenemy >= 1 and self.timeenemy <10) or (self.timeenemy >= 20 and self.timeenemy <30): atack1 = 1 else: atack1 = 0 if self.timeenemy == 1 or self.timeenemy == 20: atack2 = 1 else: atack2 = 0 if self.timeenemy == 9 or self.timeenemy == 29: atack3 = 1 else: atack3 = 0 if self.timeenemy >=40 and self.timeenemy <50: atack4 = 1 else: atack4 = 0 if self.timeenemy == 50: atack5 = 1 else: atack5 = 0 if ( (abs(self.rect.left-game.player.rect.left)<=200 or abs(self.rect.right-game.player.rect.right)<=200) ) and not self.gun_cooldown: atack6 = 1 else: atack6 = 0 elif game.enemymode == 'ai': # player controlled by AI algorithm # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 6: game.print_logs("ERROR: Enemy 1 controller must return 6 decision variables.") sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] atack4 = actions[3] atack5 = actions[4] atack6 = actions[5] if atack6 == 1 and not self.gun_cooldown: atack6 = 1 else: atack6 = 0 # If the 'start game' marker is 1. if game.start == 1: self.timeenemy += 1 # increments enemy timer last = self.rect.copy() # copies last position state of the enemy # jumps over the player. It happens twice. if atack1== 1 : # moves on the axis x self.rect.x += self.direction * 730 * dt if self.resting == 1 and atack2 == 1: self.dy = -900 self.resting = 0 # enemy turns to the players direction if atack3 == 1: if game.enemymode == 'static': if game.player.rect.right < self.rect.left: self.direction = -1 if game.player.rect.left > self.rect.right: self.direction = 1 else: self.direction = self.direction * -1 # runs in the player's direction, after jumping twice elif atack4 == 1 : self.rect.x += self.direction * 900 * dt # reinicializes enemy timer elif atack5 == 1: self.timeenemy = 0 # throws a bullet over the player when enemy is jumping and right over him if self.resting == 0 and self.just_shoot == 0 and atack6 == 1: self.shooting = 5 self.gun_cooldown = 5 # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) self.just_shoot = 1 rand = 3 # shoots from 1 to 3 bullets for i in range(0,rand): self.twists.append(Bullet_e8((self.rect.x+(i*60) ,self.rect.y ), i, self.direction, len(self.twists), game.sprite_e)) # decreases time for bullets limitation self.gun_cooldown = max(0, self.gun_cooldown - dt) # animation, running enemy images alternation if self.direction > 0: direction = SpriteConstants.RIGHT else: direction = SpriteConstants.LEFT if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, direction) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, direction) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, direction) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # changes the image when enemy jumps if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max(0, game.player.life-(game.level*0.3)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life-(game.level*0.3)) # sets flag to change the player image when he is hurt game.player.hurt = 5 # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits agaist enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide(new, 'blockers'): blockers = cell['blockers'] if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 self.just_shoot = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom if 'l' in blockers and last.right <= cell.left and new.right > cell.left and last.bottom>cell.top: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right and last.bottom>cell.top: new.left = cell.right # hurt enemy animation if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -=1 # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0,self.shooting) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition( 'evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.twists = [] self.alternate = 1 self.fireflash = 0 self.imune = 0 self.rect.x = 550 self.timeenemy = 0 self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 self.rect.right = 580 def update(self, dt, game): if game.time == 1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640, 500, 400, 300]) # defines game mode for player action if game.enemymode == 'static': # enemy controlled by static movements if self.timeenemy == 2: atack1 = 1 else: atack1 = 0 if self.timeenemy > 50: atack2 = 1 else: atack2 = 0 if self.timeenemy == 3: atack3 = 1 else: atack3 = 0 if (self.fireflash >= 1 and self.fireflash <= 40): atack4 = 1 else: atack4 = 0 elif game.enemymode == 'ai': # player controlled by AI algorithm # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 4: game.print_logs( "ERROR: Enemy 1 controller must return 4 decision variables." ) sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] atack4 = actions[3] if atack3 == 1 and not self.gun_cooldown: atack3 = 1 else: atack3 = 0 # if the 'start game' marker is 1 if game.start == 1: self.timeenemy += 1 # increments enemy timer last = self.rect.copy() # copies last position state of the enemy # when player atacks, enemy turns into fire and goes towards his direction if game.player.atacked == 1 and self.fireflash == 0: self.fireflash = 100 else: self.fireflash = max(0, self.fireflash - 1) if atack4 == 1: self.rect.x += self.direction * 600 * dt if self.fireflash == 1: self.direction = self.direction * -1 if self.rect.colliderect(game.player.rect): self.fireflash = 0 # otherwise he just keeps shooting towards the player direction elif self.fireflash == 0: if atack1 == 1 and self.resting == 1: self.dy = -900 self.resting = 0 self.imune = 0 # enemy is not imune to player's shooting anymore # images of the enemy standing up if self.direction == -1: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.RIGHT) # reinicializes timer and turns to the players direction if atack2 == 1: self.timeenemy = 1 if game.enemymode == 'static': if game.player.rect.right < self.rect.left: self.direction = -1 elif game.player.rect.left > self.rect.right: self.direction = 1 else: self.direction = self.direction * -1 # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max( 0, game.player.life - (game.level * 0.3)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life - (game.level * 0.3)) # pushes player when he collides with the enemy game.player.rect.x += self.direction * 50 * dt # limits the player to stand on the screen space even being pushed if game.player.rect.x < 60: game.player.rect.x = 60 if game.player.rect.x > 620: game.player.rect.x = 620 # sets flag to change the player image when he is hurt game.player.hurt = 5 # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits agaist enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide( new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # enemy shoots 3 bullets if atack3 == 1: self.shooting = 5 self.gun_cooldown = 5 # if enemy is not turned into fire, shoots, otherwise stops the time counter for a while. if self.fireflash == 0: # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound( 'evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) for i in range(0, 3): self.twists.append( Bullet_e4( (self.rect.x, self.rect.y), self.direction, i, len(self.twists), game.sprite_e)) else: self.timeenemy -= 1 self.gun_cooldown = max( 0, self.gun_cooldown - dt) # decreases time for bullets limitation. # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0, self.shooting) # changes the image when enemy is hurt and imune, as a fireball if self.imune == 1: if game.time % 2 == 0: self.image = pygame.image.load( 'evoman/images/fireball.png') else: self.image = pygame.image.load( 'evoman/images/fireball2.png') self.hurt -= 1 def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition( 'evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.twists = [] self.alternate = 1 self.imune = 0 self.timeenemy = 0 self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 def update(self, dt, game): if game.time == 1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([630, 610, 560, 530]) # defines game mode for player action. if game.enemymode == 'static': # enemy controlled by static movements if (self.timeenemy >= 210 and self.timeenemy <= 250) or (self.timeenemy >= 260 and self.timeenemy <= 300): atack1 = 1 else: atack1 = 0 if self.timeenemy == 210 or self.timeenemy == 260: atack2 = 1 else: atack2 = 0 if self.timeenemy > 300: atack3 = 1 else: atack3 = 0 if (self.timeenemy == 40) or (self.timeenemy == 110) or (self.timeenemy == 180): atack4 = 1 else: atack4 = 0 elif game.enemymode == 'ai': # player controlled by AI algorithm # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 4: game.print_logs( "ERROR: Enemy 1 controller must return 4 decision variables." ) sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] atack4 = actions[3] if atack4 == 1 and not self.gun_cooldown: atack4 = 1 else: atack4 = 0 if atack1 == 1 and self.resting == 1: atack1 = 1 else: atack1 = 0 # if the 'start game' marker is 1 if game.start == 1: # increments enemy timer self.timeenemy += 1 # copies last position state of the enemy last = self.rect.copy() # movements of the enemy on the axis x. Happens 2 to each side. if atack1 == 1: self.rect.x += self.direction * 200 * dt # jumps if atack2 == 1: self.dy = -900 self.resting = 0 # animation, running enemy images alternatetion. if self.direction > 0: direction = SpriteConstants.RIGHT else: direction = SpriteConstants.LEFT if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, direction) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, direction) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, direction) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # changes the image when enemy jumps if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) else: # animation, standing up images if self.direction == -1: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.RIGHT) # restart enemy timer and turns the enemy around if atack3 == 1: self.timeenemy = 0 self.direction = self.direction * -1 # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max(0, game.player.life - (game.level * 1)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life - (game.level * 1)) game.player.hurt = 5 # sets flag to change the player image when he is hurt. # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits agaist enemy. new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide( new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # enemy shoots if atack4 == 1: self.shooting = 5 self.gun_cooldown = 3 # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) # shoots 6 bullets placed in a fixed range for i in range(0, 6): self.twists.append( Bullet_e2((self.rect.x + 10, self.rect.bottom), self.direction, i, len(self.twists), game.sprite_e)) # decreases time for bullets limitation self.gun_cooldown = max(0, self.gun_cooldown - dt) # hurt enemy animation if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -= 1 # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0, self.shooting) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Player(pygame.sprite.Sprite): def __init__(self, location, enemyn, level, *groups): super(Player, self).__init__(*groups) self.spriteDefinition = SpriteDefinition('evoman/images/EvoManSprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.RIGHT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.resting = 0 self.dy = 0 self.direction = 1 self.alternate = 1 self.gun_cooldown = 0 self.max_life = 100 self.life = self.max_life self.atacked = 0 self.hurt = 0 self.shooting = 0 self.inwater = 0 self.twists = [] self.vx = 0 self.vy = 0 self.hy = 0 self.sensors = None def update(self, dt, game): # if the enemies are not atacking with the freezing atack (prevents player from making any movements or atacking) and also the 'start game' marker is 1. if game.freeze_p == 0 and game.start == 1: # checks water environment flag to regulate movements speed if self.inwater == 1: self.vx = 0.5 self.vy = 0.5 self.hy = -2000 else: self.vx = 1 self.vy = 1 self.hy = -900 # defines game mode for player action if game.playermode == 'human': # player controlled by keyboard/joystick # if joystick is connected, initializes it. if game.joy > 0: joystick = pygame.joystick.Joystick(0) joystick.init() # tests if the button/key was pressed or released. press = 0 release = 0 for event in game.event: if event.type == pygame.JOYBUTTONDOWN or event.type == pygame.KEYDOWN: press = 1 else: press = 0 if event.type == pygame.JOYBUTTONUP or event.type == pygame.KEYUP: release = 1 else: release = 0 # gets pressed key value key = pygame.key.get_pressed() # gets joystick value for axis x (left/right) left = 0 if game.joy > 0: if round(joystick.get_axis(0)) == -1: left = 1 if key[pygame.K_LEFT]: left = 1 right = 0 if game.joy > 0: if round(joystick.get_axis(0)) == 1: right = 1 if key[pygame.K_RIGHT]: right = 1 # gets joystick/key value for jumping jump = 0 if game.joy > 0: if int(joystick.get_button(2)) == 1 and press == 1: jump = 1 if key[pygame.K_SPACE] and press == 1: jump = 1 # gets joystick/key value for shooting shoot = 0 if game.joy > 0: if int(joystick.get_button(3)) == 1 and press == 1: shoot = 1 if key[pygame.K_LSHIFT] and press == 1: shoot = 1 elif game.playermode == 'ai': # player controlled by AI algorithm # calls the controller providing game sensors actions = game.player_controller.control(self.sensors.get(game), game.pcont) if len(actions) < 5: game.print_logs("ERROR: Player controller must return 5 decision variables.") sys.exit(0) left = actions[0] right = actions[1] jump = actions[2] shoot = actions[3] release = actions[4] # if the button is released before the jumping maximum height, them player stops going up. if release == 1 and self.resting == 0: self.dy = 0 # copies last position state of the player last = self.rect.copy() # movements on the axis x (left) if left: self.rect.x -= 200 * dt * self.vx self.direction = -1 # animation, running images alternation if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, SpriteConstants.LEFT) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, SpriteConstants.LEFT) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, SpriteConstants.LEFT) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # movements on the axis x (right) elif right: self.rect.x += 200 * dt * self.vx self.direction = 1 # animation, running player images alternation if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, SpriteConstants.RIGHT) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, SpriteConstants.RIGHT) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, SpriteConstants.RIGHT) self.alternate += 1 if self.alternate > 12: self.alternate = 1 else: # animation, standing up images if self.direction == -1: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.RIGHT) # if player is touching the floor, he is allowed to jump if self.resting == 1 and jump == 1: self.dy = self.hy # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt * self.vy # changes the image when player jumps if self.resting == 0 : if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) new = self.rect # copies new (after movement) position state of the player # controls screen walls and platforms limits agaist player self.resting = 0 for cell in game.tilemap.layers['triggers'].collide(new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left and last.bottom>cell.top: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right and last.bottom>cell.top: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 # player touches the floor new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # shoots, limiting time between bullets. if shoot == 1 and not self.gun_cooldown: self.shooting = 5 self.atacked = 1 # marks if the player has atacked enemy # creates bullets objects according to the direction. if self.direction > 0: self.twists.append(Bullet_p(self.rect.midright, 1, len(self.twists), game.sprite_p)) else: self.twists.append(Bullet_p(self.rect.midleft, -1, len(self.twists), game.sprite_p)) self.gun_cooldown = 0.4 # marks time to the bullet for allowing next bullets # sound effects if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi003.wav') c = pygame.mixer.Channel(2) c.set_volume(1) c.play(sound) else: self.atacked = 0 # decreases time for limitating bullets self.gun_cooldown = max(0, self.gun_cooldown - dt) # hurt player animation if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -= 1 self.hurt = max(0,self.hurt) self.shooting -= 1 self.shooting = max(0,self.shooting) # shooting animation if self.shooting > 0: if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING_JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING_JUMPING, SpriteConstants.RIGHT) else: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) # kills player in case he touches killers stuff, like spikes. for cell in game.tilemap.layers['triggers'].collide(self.rect, 'killers'): game.player.life = 0 # focuses screen center on player game.tilemap.set_focus(new.x, new.y) else: game.tilemap.set_focus(self.rect.x, self.rect.y) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition('evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.alternate = 1 self.direction_floor = 1 self.imune = 0 self.move = 0 self.countmove = 0 self.rect.x = 500 self.timeenemy = 0 self.twists = [] self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 def update(self, dt, game): if game.time==1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640,500,400,300]) # Defines game mode for player action. if game.enemymode == 'static': # Enemy controlled by static movements. if self.resting == 1 and self.timeenemy >= 95 and self.timeenemy <= 110: atack1 = 1 else: atack1 = 0 if self.resting == 0 : atack2 = 1 else: atack2 = 0 if (game.player.rect.right < game.enemy.rect.left and abs(game.player.rect.right - game.enemy.rect.left) <= 50 ) or (game.enemy.rect.right < game.player.rect.left and abs(game.enemy.rect.right - game.player.rect.left) <= 50): atack3 = 1 else: atack3 = 0 elif game.enemymode == 'ai': # Player controlled by AI algorithm. # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 3: game.print_logs("ERROR: Enemy 1 controller must return 3 decision variables.") sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] if atack2 == 1 and not self.gun_cooldown: atack2 = 1 else: atack2 = 0 # if the 'start game' marker is 1 if game.start == 1: self.timeenemy += 1 # increments enemy timer # moving floor, changes the movement direction from time to time. for cell in game.tilemap.layers['triggers'].collide(game.player.rect, 'blockers'): blockers = cell['blockers'] if 't' in blockers: game.player.rect.x += self.direction_floor * 100 * dt # moves player over the moving floor # limits player inside the screen if game.player.rect.left < 60: game.player.rect.left = 61 if game.player.rect.right > 665: game.player.rect.right = 665 if game.time%120 == 0: self.direction_floor = self.direction_floor *-1 last = self.rect.copy() # copies last position state of the enemy # if player gets too close to the enemy, he jumps to the other side. if (self.resting == 1 and atack3 == 1): self.move = 1 self.dy = -900 self.resting = 0 if self.move == 1: self.rect.x += self.direction * 900 * dt if self.move == 1 and self.rect.x<200: self.rect.x = 200 self.direction = self.direction * -1 self.move = 0 if self.move == 1 and self.rect.x>500: self.rect.x = 500 self.direction = self.direction * -1 self.move = 0 # jumps from time to time or when player atacks if ( (self.resting == 1 and atack1 == 1) or ( self.resting == 1 and game.player.atacked == 1)): self.dy = -900 self.resting = 0 # releases until 4 bullets (decided randomly) after jumping or when player atacks if (atack2 == 1 and not self.gun_cooldown) : self.shooting = 5 self.gun_cooldown = 3 # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) aux = numpy.random.randint(1,4,1) for i in range(0,aux): self.twists.append(Bullet_e5((self.rect.x + (self.direction*(i*30)) ,self.rect.top + (self.direction*(i*20)) ), self.direction, game.player.rect , len(self.twists), game.sprite_e)) self.timeenemy = 0 # reinicializes enemy timer if game.player.atacked == 1: # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) self.twists.append(Bullet_e5((self.rect.x ,self.rect.top ), self.direction, game.player.rect , len(self.twists), game.sprite_e)) self.gun_cooldown = max(0, self.gun_cooldown - dt) # decreases time for bullets limitation # animation, running enemy images alternation. if self.direction > 0: direction = SpriteConstants.RIGHT else: direction = SpriteConstants.LEFT if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, direction) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, direction) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, direction) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # changes the image when enemy jumps if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max(0, game.player.life-(game.level*0.3)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life-(game.level*0.3)) # pushes player when he collides with the enemy game.player.rect.x += self.direction * 50 * dt # limits the player to stand on the screen space even being pushed. if game.player.rect.x < 60: game.player.rect.x = 60 if game.player.rect.x > 620: game.player.rect.x = 620 # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits agaist enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide(new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # hurt enemy animation if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -=1 # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0,self.shooting) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition('evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.twists = [] self.alternate = 1 self.just_shoot = 0 self.imune = 0 self.timeenemy = 0 self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 def update(self, dt, game): if game.time==1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640,500,400,300]) # Defines game mode for player action. if game.enemymode == 'static': # Enemy controlled by static movements. if self.timeenemy == 105: atack1 = 1 else: atack1 = 0 if ( (abs(self.rect.left-game.player.rect.left)<=1 or abs(self.rect.right-game.player.rect.right)<=1) or self.dy>200 ): atack2 = 1 else: atack2 = 0 atack3 = 0 elif game.enemymode == 'ai': # Player controlled by AI algorithm. # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 3: game.print_logs("ERROR: Enemy 1 controller must return 3 decision variables.") sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] if atack2 == 1 and not self.gun_cooldown: atack2 = 1 else: atack2 = 0 # if the 'start game' marker is 1 if game.start == 1: self.timeenemy += 1 # increments enemy timer last = self.rect.copy() # copies last position state of the enemy # movements of the enemy on the axis x until a limit (turning aroud) if self.rect.left<60: self.direction = self.direction * -1 self.rect.left = 60 if self.rect.right>680: self.direction = self.direction * -1 self.rect.right = 680 # calculating the relative distance between enemy and player to set the jumping strengh aux_dist = (abs(game.player.rect.right - self.rect.right)/490.0)+0.1 # when atacking, enemy may accelarate his movement. if self.dy<0: self.rect.x += self.direction * (1500 *aux_dist) * dt else: self.rect.x += self.direction * 180 * dt # jumps over the player. It happens from time to time, or when the player shoots. if ((self.resting == 1 and atack1 == 1) or ( self.resting == 1 and game.player.atacked == 1)): if game.enemymode == 'static': # enemy turns to the players direction. if game.player.rect.right <= self.rect.left: self.direction = -1 if game.player.rect.left >= self.rect.right: self.direction = 1 # reinicializes enemy timer self.timeenemy = 0 self.dy = -1500 * aux_dist self.resting = 0 if atack3 == 1 and game.enemymode == 'ai': self.direction = self.direction * -1 # throws a bullet over the player when enemy is jumping and right over him if self.resting == 0 and self.just_shoot == 0 and atack2 == 1: self.shooting = 5 self.gun_cooldown = 3 # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) self.just_shoot = 1 self.twists.append(Bullet_e6((self.rect.x ,self.rect.y ), self.direction, len(self.twists), game.sprite_e)) self.gun_cooldown = max(0, self.gun_cooldown - dt) # decreases time for bullets limitation # animation, running enemy images alternation if self.direction > 0: direction = SpriteConstants.RIGHT else: direction = SpriteConstants.LEFT if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, direction) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, direction) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, direction) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # changes the image when enemy jumps if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max(0, game.player.life-(game.level*0.3)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life-(game.level*0.3)) game.player.rect.x += self.direction * 50 * dt # pushes player when he collides with the enemy # limits the player to stand on the screen space even being pushed if game.player.rect.x < 60: game.player.rect.x = 60 if game.player.rect.x > 620: game.player.rect.x = 620 game.player.hurt = 5 # sets flag to change the player image when he is hurt # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits agaist enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide(new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 self.just_shoot = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # hurt enemy animation if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -=1 # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0,self.shooting) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition('evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.twists = [] self.alternate = 1 self.imune = 0 self.timeenemy = 0 self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 def update(self, dt, game): if game.time==1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([630,610,560,530]) # defines game mode for player action. if game.enemymode == 'static': # enemy controlled by static movements if (self.timeenemy >= 210 and self.timeenemy <= 250) or (self.timeenemy >= 260 and self.timeenemy <= 300): atack1 = 1 else: atack1 = 0 if self.timeenemy == 210 or self.timeenemy == 260: atack2 = 1 else: atack2 = 0 if self.timeenemy> 300: atack3 = 1 else: atack3 = 0 if (self.timeenemy == 40) or (self.timeenemy == 110) or (self.timeenemy == 180): atack4 = 1 else: atack4 = 0 elif game.enemymode == 'ai': # player controlled by AI algorithm # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 4: game.print_logs("ERROR: Enemy 1 controller must return 4 decision variables.") sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] atack4 = actions[3] if atack4 == 1 and not self.gun_cooldown: atack4 = 1 else: atack4 = 0 if atack1 == 1 and self.resting == 1: atack1 = 1 else: atack1 = 0 # if the 'start game' marker is 1 if game.start == 1: # increments enemy timer self.timeenemy += 1 # copies last position state of the enemy last = self.rect.copy() # movements of the enemy on the axis x. Happens 2 to each side. if atack1 == 1 : self.rect.x += self.direction * 200 * dt # jumps if atack2 == 1: self.dy = -900 self.resting = 0 # animation, running enemy images alternatetion. if self.direction > 0: direction = SpriteConstants.RIGHT else: direction = SpriteConstants.LEFT if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, direction) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, direction) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, direction) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # changes the image when enemy jumps if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) else: # animation, standing up images if self.direction == -1: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.RIGHT) # restart enemy timer and turns the enemy around if atack3 == 1: self.timeenemy = 0 self.direction = self.direction * -1 # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max(0, game.player.life-(game.level*1)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life-(game.level*1)) game.player.hurt = 5 # sets flag to change the player image when he is hurt. # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits agaist enemy. new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide(new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # enemy shoots if atack4 == 1: self.shooting = 5 self.gun_cooldown = 3 # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) # shoots 6 bullets placed in a fixed range for i in range (0,6): self.twists.append(Bullet_e2((self.rect.x+10,self.rect.bottom), self.direction ,i, len(self.twists), game.sprite_e)) # decreases time for bullets limitation self.gun_cooldown = max(0, self.gun_cooldown - dt) # hurt enemy animation if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -=1 # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0,self.shooting) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Player(pygame.sprite.Sprite): def __init__(self, location, enemyn, level, *groups): super(Player, self).__init__(*groups) self.spriteDefinition = SpriteDefinition( 'evoman/images/EvoManSprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.RIGHT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.resting = 0 self.dy = 0 self.direction = 1 self.alternate = 1 self.gun_cooldown = 0 self.max_life = 100 self.life = self.max_life self.atacked = 0 self.hurt = 0 self.shooting = 0 self.inwater = 0 self.twists = [] self.vx = 0 self.vy = 0 self.hy = 0 self.sensors = None def update(self, dt, game): # if the enemies are not atacking with the freezing atack (prevents player from making any movements or atacking) and also the 'start game' marker is 1. if game.freeze_p == 0 and game.start == 1: # checks water environment flag to regulate movements speed if self.inwater == 1: self.vx = 0.5 self.vy = 0.5 self.hy = -2000 else: self.vx = 1 self.vy = 1 self.hy = -900 # defines game mode for player action if game.playermode == 'human': # player controlled by keyboard/joystick # if joystick is connected, initializes it. if game.joy > 0: joystick = pygame.joystick.Joystick(0) joystick.init() # tests if the button/key was pressed or released. press = 0 release = 0 for event in game.event: if event.type == pygame.JOYBUTTONDOWN or event.type == pygame.KEYDOWN: press = 1 else: press = 0 if event.type == pygame.JOYBUTTONUP or event.type == pygame.KEYUP: release = 1 else: release = 0 # gets pressed key value key = pygame.key.get_pressed() # gets joystick value for axis x (left/right) left = 0 if game.joy > 0: if round(joystick.get_axis(0)) == -1: left = 1 if key[pygame.K_LEFT]: left = 1 right = 0 if game.joy > 0: if round(joystick.get_axis(0)) == 1: right = 1 if key[pygame.K_RIGHT]: right = 1 # gets joystick/key value for jumping jump = 0 if game.joy > 0: if int(joystick.get_button(2)) == 1 and press == 1: jump = 1 if key[pygame.K_SPACE] and press == 1: jump = 1 # gets joystick/key value for shooting shoot = 0 if game.joy > 0: if int(joystick.get_button(3)) == 1 and press == 1: shoot = 1 if key[pygame.K_LSHIFT] and press == 1: shoot = 1 elif game.playermode == 'ai': # player controlled by AI algorithm # calls the controller providing game sensors actions = game.player_controller.control( self.sensors.get(game), game.pcont) if len(actions) < 5: game.print_logs( "ERROR: Player controller must return 5 decision variables." ) sys.exit(0) left = actions[0] right = actions[1] jump = actions[2] shoot = actions[3] release = actions[4] # if the button is released before the jumping maximum height, them player stops going up. if release == 1 and self.resting == 0: self.dy = 0 # copies last position state of the player last = self.rect.copy() # movements on the axis x (left) if left: self.rect.x -= 200 * dt * self.vx self.direction = -1 # animation, running images alternation if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, SpriteConstants.LEFT) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, SpriteConstants.LEFT) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, SpriteConstants.LEFT) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # movements on the axis x (right) elif right: self.rect.x += 200 * dt * self.vx self.direction = 1 # animation, running player images alternation if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, SpriteConstants.RIGHT) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, SpriteConstants.RIGHT) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, SpriteConstants.RIGHT) self.alternate += 1 if self.alternate > 12: self.alternate = 1 else: # animation, standing up images if self.direction == -1: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.RIGHT) # if player is touching the floor, he is allowed to jump if self.resting == 1 and jump == 1: self.dy = self.hy # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt * self.vy # changes the image when player jumps if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) new = self.rect # copies new (after movement) position state of the player # controls screen walls and platforms limits agaist player self.resting = 0 for cell in game.tilemap.layers['triggers'].collide( new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left and last.bottom > cell.top: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right and last.bottom > cell.top: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 # player touches the floor new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # shoots, limiting time between bullets. if shoot == 1 and not self.gun_cooldown: self.shooting = 5 self.atacked = 1 # marks if the player has atacked enemy # creates bullets objects according to the direction. if self.direction > 0: self.twists.append( Bullet_p(self.rect.midright, 1, len(self.twists), game.sprite_p)) else: self.twists.append( Bullet_p(self.rect.midleft, -1, len(self.twists), game.sprite_p)) self.gun_cooldown = 0.4 # marks time to the bullet for allowing next bullets # sound effects if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi003.wav') c = pygame.mixer.Channel(2) c.set_volume(1) c.play(sound) else: self.atacked = 0 # decreases time for limitating bullets self.gun_cooldown = max(0, self.gun_cooldown - dt) # hurt player animation if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -= 1 self.hurt = max(0, self.hurt) self.shooting -= 1 self.shooting = max(0, self.shooting) # shooting animation if self.shooting > 0: if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING_JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING_JUMPING, SpriteConstants.RIGHT) else: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) # kills player in case he touches killers stuff, like spikes. for cell in game.tilemap.layers['triggers'].collide( self.rect, 'killers'): game.player.life = 0 # focuses screen center on player game.tilemap.set_focus(new.x, new.y) else: game.tilemap.set_focus(self.rect.x, self.rect.y) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition('evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.time_colis = 0 self.alternate = 1 self.imune = 0 self.timeenemy = 0 self.twists = [] self.hurt = 0 self.shooting = 1 self.gun_cooldown = 0 self.gun_cooldown2 = 0 def update(self, dt, game): if game.time==1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640,500,400,300]) # increments enemy timer if game.start == 1: self.timeenemy += 1 # defines game mode for player action if game.enemymode == 'static': # controlled by static movements atack1 = 1 if self.timeenemy >= 200 and self.timeenemy < 260: atack2 = 1 else: atack2 = 0 if self.timeenemy == 220: atack3 = 1 else: atack3 = 0 atack4 = 1 elif game.enemymode == 'ai': # enemy controlled by AI algorithm # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 4: game.print_logs("ERROR: Enemy 1 controller must return 4 decision variables.") sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] atack4 = actions[3] # applies attack rules if atack2 == 1 and not self.gun_cooldown: atack2 = 1 else: atack2 = 0 if atack3 == 1 and not self.gun_cooldown2: atack3 = 1 else: atack3 = 0 # if the enemy is not atacking with the feezing atack (prevents player from making any movements) and also the 'start game' marker is 1. if game.freeze_e == 0 and game.start == 1: last = self.rect.copy()# copies last position state of the enemy if atack1 == 1: # moves the enemy on the axis x self.rect.x += self.direction * 100 * dt # chases player, switching direction as he moves. if atack4 == 1: if game.enemymode == 'static': if game.player.rect.right < self.rect.left: self.direction = -1 elif game.player.rect.left > self.rect.right: self.direction = 1 else: self.direction = self.direction * -1 # animation, running enemy images alternation. if self.direction > 0: direction = SpriteConstants.RIGHT else: direction = SpriteConstants.LEFT if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, direction) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, direction) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, direction) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # sprite loses life points, according to the difficult level of the game (the more difficult, the more it loses). # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max(0, game.player.life-(game.level*1)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life-(game.level*1)) # counts duration of the collision to jump from time to time during the collision self.time_colis += 1 if self.time_colis > 15: self.time_colis = 0 self.dy = -600 # sets flag to change the player image when he is hurt game.player.hurt = 5 # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits towards enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide(new, 'blockers'): blockers = cell['blockers'] if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom if 'l' in blockers and last.right <= cell.left and new.right > cell.left and last.bottom>cell.top: new.right = cell.left # Jumps when finds a wall in the middle plataforms. if new.left<600: self.dy = -600 if 'r' in blockers and last.left >= cell.right and new.left < cell.right and last.bottom>cell.top: new.left = cell.right # Jumps when finds a wall in the middle plataforms. if new.left>29: self.dy = -600 # Changes the image when enemy jumps. if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) # Hurt enemy animation. if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -=1 # Enemy atack: freezes the player (preeveting him from making any movements or atacking) and also himself from moving. Freenzing endures according to the timer. if atack2 == 1: self.gun_cooldown = 6 game.freeze_p = 1 game.freeze_e = 1 # Enemy shooting after freezing. if atack3 == 1: self.shooting = 5 self.gun_cooldown2 = 6 # Bullets sound effect. if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) # Shoots 8 bullets placed in a fixed range with a little random variation in their position (x and y). for i in range (0,8): rand = numpy.array([30,20,10,15,9,25,18,5]) rand2 = numpy.array([1,2,3,4,5,2,4,3]) rand = rand[i] rand2 = rand2[i] # Start position of the bullets vary according to the position of the enemy. if self.direction > 0: self.twists.append(Bullet_e1((self.rect.x+(i*rand),self.rect.y+10+(i*rand2)), 1, len(self.twists), game.sprite_e)) else: self.twists.append(Bullet_e1((self.rect.x-(i*rand)+46,self.rect.y+10+(i*rand2)), -1, len(self.twists), game.sprite_e)) # Decreases time for bullets and freezing limitation. self.gun_cooldown = max(0, self.gun_cooldown - dt) self.gun_cooldown2 = max(0, self.gun_cooldown2 - dt) # Changes bullets images according to the enemy direction. if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0,self.shooting) # Releases movement. if self.gun_cooldown <= 5: game.freeze_p = 0 game.freeze_e = 0 # Reinicializes enemy atacking timer. if self.timeenemy == 260: self.timeenemy = 0 def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition( 'evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.twists = [] self.alternate = 1 self.just_shoot = 0 self.imune = 0 self.timeenemy = 0 self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 def update(self, dt, game): if game.time == 1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640, 500, 400, 300]) # Defines game mode for player action. if game.enemymode == 'static': # Enemy controlled by static movements. if self.timeenemy == 105: atack1 = 1 else: atack1 = 0 if ((abs(self.rect.left - game.player.rect.left) <= 1 or abs(self.rect.right - game.player.rect.right) <= 1) or self.dy > 200): atack2 = 1 else: atack2 = 0 atack3 = 0 elif game.enemymode == 'ai': # Player controlled by AI algorithm. # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 3: game.print_logs( "ERROR: Enemy 1 controller must return 3 decision variables." ) sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] if atack2 == 1 and not self.gun_cooldown: atack2 = 1 else: atack2 = 0 # if the 'start game' marker is 1 if game.start == 1: self.timeenemy += 1 # increments enemy timer last = self.rect.copy() # copies last position state of the enemy # movements of the enemy on the axis x until a limit (turning aroud) if self.rect.left < 60: self.direction = self.direction * -1 self.rect.left = 60 if self.rect.right > 680: self.direction = self.direction * -1 self.rect.right = 680 # calculating the relative distance between enemy and player to set the jumping strengh aux_dist = (abs(game.player.rect.right - self.rect.right) / 490.0) + 0.1 # when atacking, enemy may accelarate his movement. if self.dy < 0: self.rect.x += self.direction * (1500 * aux_dist) * dt else: self.rect.x += self.direction * 180 * dt # jumps over the player. It happens from time to time, or when the player shoots. if ((self.resting == 1 and atack1 == 1) or (self.resting == 1 and game.player.atacked == 1)): if game.enemymode == 'static': # enemy turns to the players direction. if game.player.rect.right <= self.rect.left: self.direction = -1 if game.player.rect.left >= self.rect.right: self.direction = 1 # reinicializes enemy timer self.timeenemy = 0 self.dy = -1500 * aux_dist self.resting = 0 if atack3 == 1 and game.enemymode == 'ai': self.direction = self.direction * -1 # throws a bullet over the player when enemy is jumping and right over him if self.resting == 0 and self.just_shoot == 0 and atack2 == 1: self.shooting = 5 self.gun_cooldown = 3 # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) self.just_shoot = 1 self.twists.append( Bullet_e6((self.rect.x, self.rect.y), self.direction, len(self.twists), game.sprite_e)) self.gun_cooldown = max( 0, self.gun_cooldown - dt) # decreases time for bullets limitation # animation, running enemy images alternation if self.direction > 0: direction = SpriteConstants.RIGHT else: direction = SpriteConstants.LEFT if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, direction) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, direction) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, direction) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # changes the image when enemy jumps if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max( 0, game.player.life - (game.level * 0.3)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life - (game.level * 0.3)) game.player.rect.x += self.direction * 50 * dt # pushes player when he collides with the enemy # limits the player to stand on the screen space even being pushed if game.player.rect.x < 60: game.player.rect.x = 60 if game.player.rect.x > 620: game.player.rect.x = 620 game.player.hurt = 5 # sets flag to change the player image when he is hurt # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits agaist enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide( new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 self.just_shoot = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # hurt enemy animation if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -= 1 # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0, self.shooting) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition('evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.twists = [] self.alternate = 1 self.fireflash = 0 self.imune = 0 self.rect.x = 550 self.timeenemy = 0 self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 self.rect.right = 580 def update(self, dt, game): if game.time==1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640,500,400,300]) # defines game mode for player action if game.enemymode == 'static': # enemy controlled by static movements if self.timeenemy == 2: atack1 = 1 else: atack1 = 0 if self.timeenemy> 50: atack2 = 1 else: atack2 = 0 if self.timeenemy == 3: atack3 = 1 else: atack3 = 0 if (self.fireflash>=1 and self.fireflash <=40): atack4 = 1 else: atack4 = 0 elif game.enemymode == 'ai': # player controlled by AI algorithm # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 4: game.print_logs("ERROR: Enemy 1 controller must return 4 decision variables.") sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] atack4 = actions[3] if atack3 == 1 and not self.gun_cooldown: atack3 = 1 else: atack3 = 0 # if the 'start game' marker is 1 if game.start == 1: self.timeenemy += 1 # increments enemy timer last = self.rect.copy() # copies last position state of the enemy # when player atacks, enemy turns into fire and goes towards his direction if game.player.atacked == 1 and self.fireflash == 0: self.fireflash = 100 else: self.fireflash = max(0,self.fireflash -1) if atack4 == 1: self.rect.x += self.direction * 600 * dt if self.fireflash == 1: self.direction = self.direction * -1 if self.rect.colliderect(game.player.rect): self.fireflash = 0 # otherwise he just keeps shooting towards the player direction elif self.fireflash == 0: if atack1 == 1 and self.resting == 1: self.dy = -900 self.resting = 0 self.imune = 0 # enemy is not imune to player's shooting anymore # images of the enemy standing up if self.direction == -1: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.RIGHT) # reinicializes timer and turns to the players direction if atack2 == 1: self.timeenemy = 1 if game.enemymode == 'static': if game.player.rect.right < self.rect.left: self.direction = -1 elif game.player.rect.left > self.rect.right: self.direction = 1 else: self.direction = self.direction *-1 # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max(0, game.player.life-(game.level*0.3)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life-(game.level*0.3)) # pushes player when he collides with the enemy game.player.rect.x += self.direction * 50 * dt # limits the player to stand on the screen space even being pushed if game.player.rect.x < 60: game.player.rect.x = 60 if game.player.rect.x > 620: game.player.rect.x = 620 # sets flag to change the player image when he is hurt game.player.hurt = 5 # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits agaist enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide(new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # enemy shoots 3 bullets if atack3 == 1: self.shooting = 5 self.gun_cooldown = 5 # if enemy is not turned into fire, shoots, otherwise stops the time counter for a while. if self.fireflash == 0: # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) for i in range (0,3): self.twists.append(Bullet_e4((self.rect.x ,self.rect.y ), self.direction, i, len(self.twists), game.sprite_e)) else : self.timeenemy -= 1 self.gun_cooldown = max(0, self.gun_cooldown - dt) # decreases time for bullets limitation. # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0,self.shooting) # changes the image when enemy is hurt and imune, as a fireball if self.imune == 1: if game.time%2==0: self.image = pygame.image.load('evoman/images/fireball.png') else: self.image = pygame.image.load('evoman/images/fireball2.png') self.hurt -=1 def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition('evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.twists = [] self.alternate = 1 self.imune = 0 self.timeenemy = 0 self.hurt = 0 self.shooting = 0 self.gun_cooldown = 0 def update(self, dt, game): if game.time==1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640,500,400,300]) # defines game mode for player action if game.enemymode == 'static': # enemy controlled by static movements if self.timeenemy >= 120 and self.timeenemy <= 140: atack1 = 1 else: atack1 = 0 if self.timeenemy == 130: atack2 = 1 else: atack2 = 0 if self.timeenemy> 140: atack3 = 1 else: atack3 = 0 if self.timeenemy == 30: atack4 = 1 else: atack4 = 0 elif game.enemymode == 'ai': # player controlled by AI algorithm # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 4: game.print_logs("ERROR: Enemy 1 controller must return 4 decision variables.") sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] atack4 = actions[3] if atack4 == 1 and not self.gun_cooldown: atack4 = 1 else: atack4 = 0 # if 'start game' is true if game.start == 1: self.timeenemy += 1 # increments enemy timer # copies last position state of the enemy last = self.rect.copy() # movements of the enemy on the axis x if atack1 == 1: self.rect.x += self.direction * 180 * dt # goes forward # jumps if atack2 == 1 and self.resting == 1: self.dy = -700 self.resting = 0 # animation, running enemy images alternatetion if self.direction > 0: direction = SpriteConstants.RIGHT else: direction = SpriteConstants.LEFT if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, direction) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, direction) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, direction) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # changes the image when enemy jumps if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) else: # animation, standing up images if self.direction == -1: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.STANDING, SpriteConstants.RIGHT) # restart enemy's timer from time to time, so that he stops moving. if atack3 == 1: self.timeenemy = 20 # puts the enemy turned to the player's direction if game.enemymode == 'static': if game.player.rect.right < self.rect.left: self.direction = -1 elif game.player.rect.left > self.rect.right: self.direction = 1 else: self.direction = self.direction * -1 # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max(0, game.player.life-(game.level*1)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life-(game.level*1)) # pushes player when he collides with the enemy game.player.rect.x += self.direction * 50 * dt # limits the player to stand on the screem space even being pushed if game.player.rect.x < 60: game.player.rect.x = 60 if game.player.rect.x > 620: game.player.rect.x = 620 # sets flag to change the player image when he is hurt game.player.hurt = 5 # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits agaist enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide(new, 'blockers'): blockers = cell['blockers'] if 'l' in blockers and last.right <= cell.left and new.right > cell.left: new.right = cell.left if 'r' in blockers and last.left >= cell.right and new.left < cell.right: new.left = cell.right if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom # enemy shoots if atack4 == 1: self.shooting = 5 self.gun_cooldown = 3 # bullets sound effect if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) # shoots 4 bullets placed in fixed places - bullets coming from the enemy. for i in range (0,4): ay = [-10,-10,20,-45] if self.direction > 0: ax = [-24,50,1,1] self.twists.append(Bullet_e3((self.rect.x+ax[i],self.rect.y-ay[i]), 1, 'h', len(self.twists), game.sprite_e)) else: ax = [25,-50,-7,-7] self.twists.append(Bullet_e3((self.rect.x-ax[i],self.rect.y-ay[i]), -1, 'h', len(self.twists), game.sprite_e)) # shoots 4 bullets placed in fixed places - bullets coming from the top of the screen aux = 100 for i in range (0,4): self.twists.append(Bullet_e3((aux,100), 1, 'v',len(self.twists),game.sprite_e)) aux = aux + 150 # decreases time for bullets limitation self.gun_cooldown = max(0, self.gun_cooldown - dt) # hurt enemy animation if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -=1 # changes bullets images according to the enemy direction if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0,self.shooting) def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)
class Enemy(pygame.sprite.Sprite): def __init__(self, location, *groups): super(Enemy, self).__init__(*groups) self.spriteDefinition = SpriteDefinition( 'evoman/images/EnemySprites.png', 0, 0, 43, 59) self.updateSprite(SpriteConstants.STANDING, SpriteConstants.LEFT) self.rect = pygame.rect.Rect(location, self.image.get_size()) self.direction = -1 self.max_life = 100 self.life = self.max_life self.resting = 0 self.dy = 0 self.time_colis = 0 self.alternate = 1 self.imune = 0 self.timeenemy = 0 self.twists = [] self.hurt = 0 self.shooting = 1 self.gun_cooldown = 0 self.gun_cooldown2 = 0 def update(self, dt, game): if game.time == 1: # puts enemy in random initial position if game.randomini == 'yes': self.rect.x = numpy.random.choice([640, 500, 400, 300]) # increments enemy timer if game.start == 1: self.timeenemy += 1 # defines game mode for player action if game.enemymode == 'static': # controlled by static movements atack1 = 1 if self.timeenemy >= 200 and self.timeenemy < 260: atack2 = 1 else: atack2 = 0 if self.timeenemy == 220: atack3 = 1 else: atack3 = 0 atack4 = 1 elif game.enemymode == 'ai': # enemy controlled by AI algorithm # calls the controller providing game sensors actions = game.enemy_controller.control(self.sensors.get(game), game.econt) if len(actions) < 4: game.print_logs( "ERROR: Enemy 1 controller must return 4 decision variables." ) sys.exit(0) atack1 = actions[0] atack2 = actions[1] atack3 = actions[2] atack4 = actions[3] # applies attack rules if atack2 == 1 and not self.gun_cooldown: atack2 = 1 else: atack2 = 0 if atack3 == 1 and not self.gun_cooldown2: atack3 = 1 else: atack3 = 0 # if the enemy is not atacking with the feezing atack (prevents player from making any movements) and also the 'start game' marker is 1. if game.freeze_e == 0 and game.start == 1: last = self.rect.copy() # copies last position state of the enemy if atack1 == 1: # moves the enemy on the axis x self.rect.x += self.direction * 100 * dt # chases player, switching direction as he moves. if atack4 == 1: if game.enemymode == 'static': if game.player.rect.right < self.rect.left: self.direction = -1 elif game.player.rect.left > self.rect.right: self.direction = 1 else: self.direction = self.direction * -1 # animation, running enemy images alternation. if self.direction > 0: direction = SpriteConstants.RIGHT else: direction = SpriteConstants.LEFT if self.alternate == 1: self.updateSprite(SpriteConstants.START_RUNNING, direction) if self.alternate == 4 or self.alternate == 10: self.updateSprite(SpriteConstants.RUNNING_STEP1, direction) if self.alternate == 7: self.updateSprite(SpriteConstants.RUNNING_STEP2, direction) self.alternate += 1 if self.alternate > 12: self.alternate = 1 # checks collision of the player with the enemy if self.rect.colliderect(game.player.rect): # sprite loses life points, according to the difficult level of the game (the more difficult, the more it loses). # choses what sprite penalise according to config if game.contacthurt == "player": game.player.life = max(0, game.player.life - (game.level * 1)) if game.contacthurt == "enemy": game.enemy.life = max(0, game.enemy.life - (game.level * 1)) # counts duration of the collision to jump from time to time during the collision self.time_colis += 1 if self.time_colis > 15: self.time_colis = 0 self.dy = -600 # sets flag to change the player image when he is hurt game.player.hurt = 5 # gravity self.dy = min(400, self.dy + 100) self.rect.y += self.dy * dt # controls screen walls and platforms limits towards enemy new = self.rect self.resting = 0 for cell in game.tilemap.layers['triggers'].collide( new, 'blockers'): blockers = cell['blockers'] if 't' in blockers and last.bottom <= cell.top and new.bottom > cell.top: self.resting = 1 new.bottom = cell.top self.dy = 0 if 'b' in blockers and last.top >= cell.bottom and new.top < cell.bottom: new.top = cell.bottom if 'l' in blockers and last.right <= cell.left and new.right > cell.left and last.bottom > cell.top: new.right = cell.left # Jumps when finds a wall in the middle plataforms. if new.left < 600: self.dy = -600 if 'r' in blockers and last.left >= cell.right and new.left < cell.right and last.bottom > cell.top: new.left = cell.right # Jumps when finds a wall in the middle plataforms. if new.left > 29: self.dy = -600 # Changes the image when enemy jumps. if self.resting == 0: if self.direction == -1: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.JUMPING, SpriteConstants.RIGHT) # Hurt enemy animation. if self.hurt > 0: if self.direction == -1: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.HURTING, SpriteConstants.RIGHT) self.hurt -= 1 # Enemy atack: freezes the player (preeveting him from making any movements or atacking) and also himself from moving. Freenzing endures according to the timer. if atack2 == 1: self.gun_cooldown = 6 game.freeze_p = 1 game.freeze_e = 1 # Enemy shooting after freezing. if atack3 == 1: self.shooting = 5 self.gun_cooldown2 = 6 # Bullets sound effect. if game.sound == "on" and game.playermode == "human": sound = pygame.mixer.Sound('evoman/sounds/scifi011.wav') c = pygame.mixer.Channel(3) c.set_volume(10) c.play(sound) # Shoots 8 bullets placed in a fixed range with a little random variation in their position (x and y). for i in range(0, 8): rand = numpy.array([30, 20, 10, 15, 9, 25, 18, 5]) rand2 = numpy.array([1, 2, 3, 4, 5, 2, 4, 3]) rand = rand[i] rand2 = rand2[i] # Start position of the bullets vary according to the position of the enemy. if self.direction > 0: self.twists.append( Bullet_e1((self.rect.x + (i * rand), self.rect.y + 10 + (i * rand2)), 1, len(self.twists), game.sprite_e)) else: self.twists.append( Bullet_e1( (self.rect.x - (i * rand) + 46, self.rect.y + 10 + (i * rand2)), -1, len(self.twists), game.sprite_e)) # Decreases time for bullets and freezing limitation. self.gun_cooldown = max(0, self.gun_cooldown - dt) self.gun_cooldown2 = max(0, self.gun_cooldown2 - dt) # Changes bullets images according to the enemy direction. if self.shooting > 0: if self.direction == -1: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.LEFT) else: self.updateSprite(SpriteConstants.SHOOTING, SpriteConstants.RIGHT) self.shooting -= 1 self.shooting = max(0, self.shooting) # Releases movement. if self.gun_cooldown <= 5: game.freeze_p = 0 game.freeze_e = 0 # Reinicializes enemy atacking timer. if self.timeenemy == 260: self.timeenemy = 0 def updateSprite(self, state, direction): self.image = self.spriteDefinition.getImage(state, direction)