def __init__(self, g, pos):
Enemy.__init__(self, g, pos, "nurse")
hitSoundFile = os.path.join("effects", "critter6.wav")
self.birdhit = pygame.mixer.Sound(hitSoundFile)
self.health = 2
self.speed = 4
self.direction = random.randint(0, 2) % 2
self.mode = "walking"
self.changedDirLastTick = 0
def __init__(self, game, xStart = 0, yStart = 0, zStart = 0): models = MODELS_PATH + "TankyHovercraft" anims = None Enemy.__init__(self, models, anims, "**/enemyCollisionSphere", game, xStart, yStart, zStart) self.cooldownLength = random.randint(6, 8) self.cooldownLeft = self.cooldownLength self.preferedDistanceFromPlayer = random.randint(20, 40) self.clockwise = random.choice((True, False))
def setUp(self):
self.enemy_alive = Enemy(100, 0, 20)
self.enemy_1fourthalive = Enemy(25, 0, 20)
self.enemy_dead = Enemy(0, 50, 20)
self.enemy_halfalive = Enemy(50, 0, 20)
self.enemy_3fourthsalive = Enemy(75, 5, 60)
self.knife = Weapon("knife", 20)
self.spell = Spell("Fireball", 30, 50, 2)
def __init__(self, game, player, xStart = 0, yStart = 0, zStart = 0): models = MODELS_PATH + "HovercraftOne" anims = None Enemy.__init__(self, models, anims, "**/enemyCollisionSphere", game, xStart, yStart, zStart) self.health = 10 self.pointValue = 1 self.player = player
def __init__(self, g, pos):
Enemy.__init__(self, g, pos, 'bugs')
self.frm1 = g.images['inventory'][0].subsurface((7 * 32, 7 * 32, 32, 32))
self.frm2 = g.images['inventory'][0].subsurface((6 * 32, 7 * 32, 32, 32))
self.rect.y += 2
self.rect.x += random.randint(-4,4)
self.flying = 0
self.vecx = random.randint(-5,5)
self.vecy = 0
def __init__(self, g, pos):
Enemy.__init__(self, g, pos, 'monster1')
hitSoundFile = os.path.join("effects", "critter4.wav")
self.birdhit = pygame.mixer.Sound(hitSoundFile)
self.health = 20
self.rect.height = 64
self.waketype = 'near' # either near or water
self.wet = 0
self.squirt2 = pygame.mixer.Sound(os.path.join("effects", "squirt2.wav"))
def __init__(self, x, y, direction=c.DIR_RIGHT):
Enemy.__init__(self, x, y, c.SCORE_GOOMBA, direction)
self.goomba_frames = []
self.dead_frame = None
self.x_vel = 2
self.init_frames()
self.refresh_image(self.goomba_frames[0])
class TestEnemy(unittest.TestCase):
def setUp(self):
self._enemy = Enemy(health=100, mana=100, damage=20)
def test_init(self):
self.assertTrue(isinstance(self._enemy, Enemy))
with self.assertRaises(ValueError):
Enemy(health=-1, mana=100, damage=20)
with self.assertRaises(ValueError):
Enemy(health=150, mana=100, damage=20)
with self.assertRaises(ValueError):
Enemy(health=100, mana=-1, damage=20)
with self.assertRaises(ValueError):
Enemy(health=100, mana=150, damage=20)
with self.assertRaises(ValueError):
Enemy(health=100, mana=100, damage=-20)
with self.assertRaises(TypeError):
Enemy(health="str", mana=100, damage=20)
with self.assertRaises(TypeError):
Enemy(health=100, mana="str", damage=20)
with self.assertRaises(TypeError):
Enemy(health=100, mana=100, damage="str")
def test_get_health(self):
self.assertEqual(self._enemy.get_health(), self._enemy.health)
def test_get_mana(self):
self.assertEqual(self._enemy.get_mana(), self._enemy.mana)
def test_is_alive(self):
self.assertTrue(self._enemy.is_alive())
def test_can_cast(self):
self.assertTrue(self._enemy.can_cast())
def test_take_healing(self):
damaged_enemy = Enemy(health=50, mana=100, damage=20)
self.assertTrue(damaged_enemy.take_healing(30))
def test_take_mana(self):
down_mana_enemy = Enemy(health=100, mana=40, damage=20)
down_mana_enemy.take_mana(30)
self.assertEqual(down_mana_enemy.mana, 40)
def test_attack(self):
pass
def __init__(self, image, x, y, direction = RIGHT, topSpeed = 5, health = 50):
"""
initialize stuff
"""
Enemy.__init__(self, image, x, y, direction, topSpeed, health)
self.originalTopSpeed = topSpeed
self.lastTurbo = 0
self.currentTurbo = 0
self.turboDelay = 3000
self.turboTime = 700
def __init__(self, startingpos=[0, 0]):
Enemy.__init__(self)
image_path = os.path.join(os.path.realpath('.'), 'Images', 'jelly.gif')
self.image = pygame.image.load(image_path).convert()
self.rect = self.image.get_rect()
self.rect.left += startingpos[0]
self.rect.top += startingpos[1]
self.speed = [1, 1]
self.health = 100
self.hitbox = self.rect
def __init__(self, g, pos):
Enemy.__init__(self, g, pos, 'monster5')
hitSoundFile = os.path.join("effects", "critter7.wav")
self.birdhit = pygame.mixer.Sound(hitSoundFile)
self.health = 8
self.speed = 3
self.direction = random.randint(0, 2) % 2
self.mode = 'idle'
self.jumpvel = 0.0
self.jumpstart = 8.0
def __init__(self, width, height, x, y): Enemy.__init__(self, width, 20, x, y) self.dir = 'D' self.speed = 1 # initialize sprite lists ss = SpriteSheet(path.join(get_art_dir(), 'Spider', 'Spider_spritesheet.png'), 4) self.sprites_walk_left = ss.get_sprites(size=(30, 20)) self.sprites_walk_right = [pygame.transform.flip(s, True, False) for s in self.sprites_walk_left] self.image = self.sprites_walk_left[0]
def make_enemy():
random_health = randint(0, 100)
random_mana = randint(0, 100)
random_damage = randint(0, 20)
enemy = Enemy(random_health, random_mana, random_damage)
enemy.equip(Weapon("Bow", 10))
enemy.learn(Spell("Golden Arrow", 10, 10, 2))
return enemy
def __init__(self, x, y, shell_group, direction=c.DIR_LEFT):
Enemy.__init__(self, x, y, c.SCORE_KOOPA, direction)
self.shell_group = shell_group
self.koopa_frames = []
self.x_vel = 1.5
self.init_frames()
self.refresh_image(self.koopa_frames[0])
def __init__(self, x, y):
Enemy.__init__(self, x, y, Sprite("gullug"))
self.set_animation_state(first=0, last=2, delay=6, loop=True)
self.ticks = 0
self.hp = 24
self.hurtable = True
self.radius = 50 # how large a circle from his origin he flies in
self.speed = 1.5 # how fast he flies his circular path
self.ox = self.x # origin point x
self.oy = self.y # origin point y
def __init__(self, startingpos=[0, 0], routine=1): #routine can be either 0 or 1
Enemy.__init__(self)
image_path = os.path.join(os.path.realpath('.'), 'Images', 'sunfish.gif')
self.image = pygame.image.load(image_path).convert()
self.rect = self.image.get_rect()
self.rect.left += startingpos[0]
self.rect.top += startingpos[1]
self.speed = [2, 0]
self.health = 100
self.counter = 0
self.hitbox = self.rect
def testRead(self):
enemy = Enemy()
enemy.read("10 12 5 False 20 2 True 3 4")
self.assertEqual(enemy.x, 10)
self.assertEqual(enemy.y, 12)
self.assertEqual(enemy.timer, 5)
self.assertFalse(enemy.destroyed)
self.assertEqual(enemy.hits, 20)
self.assertEqual(enemy.regenerate, 2)
self.assertEqual(enemy.shooting, True)
self.assertEqual(enemy.dirs, (3,4))
def create_enemies(self,count): # loob uusi vastaseid
for i in range(count):
if(random.randint(1,5) > 1): # 20% et tulistaja
temp = Enemy(self.enemytype["tavaline"])
temp.elusi = random.randint(1,self.level)
else:
temp = Enemy(self.enemytype["tulistaja"])
temp.elusi = random.randint(2,self.level*2)
if(random.randint(1,5) > 3):
temp.poiklemine = 1
self.pahad.append(temp)
def testMoveOnDestroyedPiece(self):
board = Board(5, 5)
player = Player()
enemy = Enemy()
enemy.destroyed = True
board.rows[1][1] = player
board.rows[2][2] = enemy
board.move_piece((1, 1), (2, 2))
self.assertEqual(board.rows[2][2], player)
self.assertIsNone(board.rows[1][1])
self.assertEqual(player.hits, MAX_HEALTH)
def go_forward(self, cells):
"""
前に進む
Parameters
----------
cells : int
進むマス目の数
Returns
-------
なし
"""
# 引数のマス目だけ進む
self.cur_pos += cells
# 現在位置を表示
print("現在位置は" + str(self.cur_pos) + "です。")
# 止まったマス目のイベントを取得する
event_nm = field_map.get_event(self.cur_pos)
if event_nm == "BattleVsZako":
# ザコキャラ「スラスラ」と戦う
zako = Enemy("スラスラ")
self.battle(zako)
elif event_nm == "GoMoreForward":
# 2マスさらに前に進む
self.go_more_forward(2)
elif event_nm == "GoBack":
# 3マス戻る
self.go_back(3)
elif event_nm == "GoBackToStart":
# 振り出しに戻る
self.go_back_to_start()
elif event_nm == "HealingLake":
# 癒しの湖(全回復)
self.healed_in_lake()
elif event_nm == "PoisonSwamp":
# 毒の沼(20のダメージ)
self.poisoned_in_swamp()
def test_enemy_move_with_same_x_level_as_hero_and_y_in_range_to_attack_with_weapon_should_reduce_hero_health(
self):
h = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
weapon = Weapon(name='Pruchka', damage=40)
enemy = Enemy(health=100, mana=40, damage=20)
enemy.x = 3
enemy.y = 2
enemy.equip(weapon)
fight = Fight(enemy)
h.x = 3
h.y = 3
fight.enemy_move(h)
self.assertEqual(h.health, 60)
def test_enemy_move_with_same_x_level_as_hero_and_y_in_range_to_attack_with_spell_should_reduce_hero_health(
self):
h = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
s = Spell('fireball', damage=45, mana_cost=15, cast_range=3)
enemy = Enemy(health=100, mana=40, damage=20)
enemy.x = 3
enemy.y = 2
enemy.learn(s)
fight = Fight(enemy)
h.x = 3
h.y = 3
fight.enemy_move(h)
self.assertEqual(h.health, 55)
def addEnemy():
from enemy import Enemy
E = Enemy(world, (0, 0, World.SIZE/2))
E.speed = .05
E['eyes'] = 'none'
E['ears'] = 'none'
E['nose'] = 'none'
E['beard'] = 'none'
E['hair'] = 'none'
E['body'] = 'skeleton'
E['shirt'] = 'none'
E['shoes'] = 'none'
E['pants'] = 'skirt'
E['right hand'] = 'dagger'
E.acts = [attackEnemy, death]
E.speed = 1.5
import random
E.cen = world.map.openTiles[random.randint(0, len(world.map.openTiles) - 1)].cen()
E.target = E.cen()
world.entityList.add(E)
def Reset():
gfw.world.clear()
gfw.world.init([
'bg', 'bossbullet', 'boss', 'zombiebullet', 'bullet', 'zombie', 'p',
'obj_dead'
])
global bg
bg.init()
gfw.world.add(gfw.layer.bg, bg)
global p
p = player.Player()
gfw.world.add(gfw.layer.p, p)
global zombie, zombies
for i in range(0, 20):
zombie = Enemy(random.randint(500, 1600), 115, random.randint(1, 2))
gfw.world.add(gfw.layer.zombie, zombie)
global boss
boss = bs.Boss()
gfw.world.add(gfw.layer.boss, boss)
def create_map(self):
layouts = {
'boundary': import_csv_layout('../map/mapateste_barreira.csv'),
'entities': import_csv_layout('../map/mapateste_inimigos.csv')
}
for style, layout in layouts.items():
for row_index, row in enumerate(layout):
for col_index, col in enumerate(row):
if col != '-1':
x = col_index * TILESIZE
y = row_index * TILESIZE
if style == 'boundary':
Tile((x, y), [self.obstacle_sprites], 'invisible')
if style == 'entities':
if col == '394':
self.player = Player(
(x, y), [self.visible_sprites],
self.obstacle_sprites, self.create_attack,
self.destroy_attack, self.create_magic)
else:
if col == '390':
monster_name = 'duende'
elif col == '389':
monster_name = 'boss'
else:
monster_name = 'esqueleto'
self.inimigo = Enemy(
monster_name, (x, y), [
self.visible_sprites,
self.attackable_sprites
], self.obstacle_sprites,
self.damage_player,
self.trigger_death_particles, self.add_exp,
self.setOpenGameWins)
self.inimigos.append(self.inimigo)
def test_enemy_with_same_x_as_hero_and_y_in_range_to_attack_choose_normal_attack_reduces_hero_health_3(
self):
# test with weapon only and enemy dmg > weapon dmg
h = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
enemy = Enemy(health=100, mana=40, damage=60)
enemy.x = 3
enemy.y = 2
weapon = Weapon(name='Pruchka', damage=50)
enemy.equip(weapon)
fight = Fight(enemy)
h.x = 3
h.y = 3
fight.enemy_move(h)
self.assertEqual(h.health, 40)
def test_enemy_with_same_x_as_hero_and_y_in_range_to_attack_choose_normal_attack_reduces_hero_health_2(
self):
# test with spell only and enemy dmg > spell dmg
h = Hero(name="Bron",
title="Dragonslayer",
health=100,
mana=100,
mana_regeneration_rate=2)
enemy = Enemy(health=100, mana=40, damage=60)
enemy.x = 3
enemy.y = 2
s = Spell('fireball', damage=45, mana_cost=15, cast_range=3)
enemy.learn(s)
fight = Fight(enemy)
h.x = 3
h.y = 3
fight.enemy_move(h)
self.assertEqual(h.health, 40)
def run_game():
# Initialize all pygame stuff
pygame.init()
# Set up tuple for screen size
screen_size = (1000, 800)
# Set up a tuple for the bg color
background_color = (82, 135, 53)
# Create pygame screen to use
screen = pygame.display.set_mode(screen_size)
# Set a caption on the terminal window
pygame.display.set_caption("Mars Defender")
the_player = Player(screen, 100, 100)
bad_guy = Enemy(screen)
the_player_group = Group()
the_player_group.add(the_player)
enemies = Group()
enemies.add(bad_guy)
bullets = Group()
# Main game loop
while 1:
screen.fill(background_color)
check_events(the_player, screen, bullets)
# Draw the player
for player in the_player_group:
the_player.draw_me()
# Draw and update the bad guy
bad_guy.update_me(the_player)
bad_guy.draw_me()
# update and draw the bullets
for bullet in bullets:
bullet.update()
bullet.draw_bullet()
# Check for collisions
hero_died = groupcollide(the_player_group, enemies, True, False)
pygame.display.flip()
def __init__(self, screen):
self.gamestate["gameover"] = False
# define the game borders
self.gamestate['min_x'] = -screen.window_width() / 2
self.gamestate['max_x'] = screen.window_width() / 2
self.gamestate['min_y'] = -screen.window_height() / 2
self.gamestate['max_y'] = screen.window_height() / 2
self.gamestate['enemies'] = [] # list of enemy positions
self.gamestate['enemy_radius'] = Enemy.radius # the collision box
self.gamestate['food_radius'] = Food.radius # the collision box
self.gamestate['bullet_radius'] = Bullet.radius
self.me = Player(
starting_ammo=self.starting_ammo) # initialize the player
self.gamestate[
'score'] = self.me.score # get player's initial score (0)
self.gamestate['lives'] = self.me.lives
self.bullets = []
self.gamestate['bullets'] = []
self.food = Food(self.gamestate) # initialize the food
self.gamestate['food'] = self.food._food.pos() # get the food position
self.enemies = [] # initialize list of enemies
for _ in range(self.num_enemies):
self.enemies.append(Enemy(
self.gamestate)) # create enemies one by one
# add each enemy's initial position to gamestate
self.gamestate['enemies'].append(self.enemies[-1]._enemy.pos())
# create the scoreboard
self.scoreboard = Scoreboard(self.gamestate)
def go_forward(self, cells):
"""
前に進む
Parameters
----------
cells : int
進むマス目の数
Returns
-------
なし
"""
self.cur_pos += cells
print("現在位置は" + str(self.cur_pos) + "です。")
event_nm = field_map.get_event(self.cur_pos)
if event_nm == "BattleVsZako":
zako = Enemy("スラスラ")
self.battle(zako)
elif event_nm == "GoMoreForward":
self.go_more_forward(2)
elif event_nm == "GoBack":
self.go_back(3)
elif event_nm == "GoBackToStart":
self.go_back_to_start()
elif event_nm == "HealingLake":
self.healed_in_lake()
elif event_nm == "PoisonSwamp":
self.poisoned_in_swamp()
def __init__(self):
self.walls = self.get_blank_map()
self.treasure = self.get_blank_map()
self.enemy = self.get_blank_map()
self.floor = self.get_blank_map()
self.wall_list = pygame.sprite.Group()
self.enemy_list = pygame.sprite.Group()
self.treasure_list = pygame.sprite.Group()
self.chamber_list = []
self.get_chambers()
self.connect_chambers()
for t in xrange(TREASURES):
while 1:
col = randint(0, COLUMNS - 1)
row = randint(0, ROWS - 1)
treasure = Treasure((row * TILE_SIZE), (col * TILE_SIZE))
if not self.walls[row][col] and self.floor[row][col]:
self.treasure[row][col] = treasure
self.treasure_list.add(treasure)
break
for m in xrange(ENEMIES):
while 1:
col = randint(0, COLUMNS - 1)
row = randint(0, ROWS - 1)
enemy = Enemy()
enemy.rect.left = row * TILE_SIZE
enemy.rect.top = col * TILE_SIZE
if not self.treasure[row][col] and self.floor[row][col]:
self.enemy[row][col] = enemy
self.enemy_list.add(enemy)
break
self.fill_map()
def __init__(self, hub):
""" Initializing default values """
self.game_hub = hub
# Initialize player ship: This will be remove as we will loading in levels soon
self.player_ship = Ship(self.game_hub)
# Create a group for bullets
self.bullets = Group()
# Create a group for enemies
self.enemies = Group()
self.enemy = Enemy(self.game_hub)
self.available_space_x = self.game_hub.WINDOW_WIDTH - 2 * self.enemy.rect.width
self.number_enemies_x = int(self.available_space_x /
(2 * self.enemy.rect.width))
self.number_of_rows = 3
# Create play button
self.play_button = Button(self.game_hub, "Play")
# Create score board
self.sb = ScoreBoard(self.game_hub)
def enter():
gfw.world.init(['bigground','background', 'enemy', 'abigail', 'simon', 'bullet', 'enemy_bullet', 'frontground', 'ui', 'platform'])
map_loader.load()
#gfw.world.init(['background', 'enemy', 'simon', 'bullet', 'enemy_bullet', 'frontground'])
global simon
simon = Simon()
gfw.world.add(gfw.layer.simon, simon)
global bigground
bigground = BiggroundScroll('bigground_demo.png')
gfw.world.add(gfw.layer.bigground, bigground)
global background
background = BackgroundScroll('background.png')
gfw.world.add(gfw.layer.background, background)
global frontground
frontground = FrontgroundScroll('frontground.png')
gfw.world.add(gfw.layer.frontground, frontground)
background.target = simon
frontground.target = simon
bigground.target = simon
#for i in range (3):
global enemy
enemy = Enemy()
gfw.world.add(gfw.layer.enemy, enemy)
def _create_fleet(self):
# make enemy to do the following calculations
enemy = Enemy(self)
# find number of enemies per row, spacing btw enemies is one enemy unit
# find the enemy height to for y axis columns
enemy_width, enemy_height = enemy.rect.size
# available_space_x is the space on either side of the row until the screen borders
available_space_x = self.settings.screen_width - (2 * enemy_width)
# space btw enemies = available_space floor divided by twice the width of an enemy
number_enemies_x = available_space_x // (2 * enemy_width)
# determine the # of rows of enemies to fit on screen
ship_height = self.ship.rect.height
# calculate the available vertical space above ship
available_space_y = (self.settings.screen_height -
(3 * enemy_height) - ship_height)
# calc the number of rows from available_height
number_rows = available_space_y // (2 * enemy_height)
# create the full fleet of enemies
for row_number in range(number_rows):
for enemy_number in range(number_enemies_x):
self._create_enemy(enemy_number, row_number)
def carinit(self):
initx = 20
inity = 30
for i in range(11):
for j in range(13):
tmp = self.board[i][j]
if tmp is levelfactory.Part["HARDBLOCK"]:
self.temp[i][j] = Hardblock(initx, inity, self.screen)
elif tmp is levelfactory.Part["SOFTBLOCK"]:
self.temp[i][j] = Softblock(initx, inity, self.screen)
elif tmp is levelfactory.Part["PLAYER"]:
self.temp[i][j] = Protagonist(initx, inity, self.screen,
self.coll_rect, self.board,
self.bombs)
self.player = self.temp[i][j]
elif tmp is levelfactory.Part["ENEMY"]:
self.temp[i][j] = Enemy(initx, inity, self.screen,
self.coll_rect, self.board)
initx += 60
inity += 60
initx = 20
self.player.setClassBoard(self.temp)
def run_game():
# initialize all the pygame stuff
pygame.init()
# create a settings object
game_settings = Settings()
# create a tuple for the screen size
# screen_size = (game_settings.screen_size);
# create a screen for our game to use
screen = pygame.display.set_mode(game_settings.screen_size)
# this sets the title of the window
pygame.display.set_caption("a heroic pygame shooter")
# make the main game loop that will permanently run_game
# create a hero object from our hero class
the_hero = Hero('images/hero.png', screen)
# make a group for the bullets to live in
bullets = Group()
enemies = Group()
game_start_time = time.time()
print game_start_time
while 1:
screen.fill(game_settings.bg_color)
game_settings.timer = (time.time() - game_start_time)
print int(game_settings.timer)
if (int(game_settings.timer) % 5
== 0) and game_settings.monster_count == 0:
enemies.add(Enemy(screen, game_settings))
game_settings.monster_count += 1
# pygame automatically creates an event queue like JS
# we want to be able to patch into certain events like click, keypress etc.
# create a tuple for the background color 256 max for rgb format
check_events(screen, the_hero, game_settings, bullets, enemies)
update_screen(screen, the_hero, game_settings, bullets, enemies)
def create_enemy(self, type="random", skin="random", current_hp=100):
"""
Creates a new enemy entity
"""
# current_hp is a percentage
# they have fixed positions
if len(self.enemies) == 0:
x = 1350
y = 525
elif len(self.enemies) == 1:
x = 1550
y = 275
elif len(self.enemies) == 2:
x = 1550
y = 775
new_enemy = Enemy(self.canvas,
type=type,
skin=skin,
x=x,
y=y,
scale_factor=self.scale_factor,
current_hp=current_hp)
self.enemies.append(new_enemy)
def enter():
global mario, map, enemy, object, fire_ball, chimney, mario_life
global mario_life2, mario_life3, mario_life4
mario = Mario()
map = Map()
enemy = Enemy()
object = Object()
fire_ball = Ball()
chimney = Chimney()
mario_life = Mario_Life()
mario_life2 = Mario_Life2()
mario_life3 = Mario_Life3()
mario_life4 = Mario_Life4()
game_world.add_object(map, 0)
game_world.add_object(object, 1)
game_world.add_object(mario, 0)
game_world.add_object(enemy, 1)
game_world.add_object(chimney, 0)
game_world.add_object(mario_life, 1)
game_world.add_object(mario_life2, 0)
game_world.add_object(mario_life3, 1)
game_world.add_object(mario_life4, 0)
pass
def setGrid(self, speed=16, health=1):
self.enemyGrid = []
self.enemyCount = 50
rNums = self.serverGridInfo["TYPES"]
for row in range(self.enemyRowCount):
self.enemyGrid.append([])
for column in range(self.enemyColumnCount):
rnum = rNums[row][column]
enemySprite = "Alien1SpriteSheet"
if rnum <= 45:
enemySprite = "Alien2SpriteSheet"
elif rnum >= 90 and rnum < 98:
enemySprite = "Alien3SpriteSheet"
elif rnum >= 98:
enemySprite = "Alien4SpriteSheet"
self.enemyGrid[row].append(
Enemy((32 + (column * 96),
(row * 64) - self.enemyRowCount * 64), 32, 32,
Animate(self.sprites.getSprite(enemySprite), 2, 2,
32, 32, 10), health, speed, row, column,
enemySprite))
def start(self):
#spawn initial GameObjects here like so:
self._game.instantiate(
Background(self._game, "Background", "background.png", 0, 0))
self._game.instantiate(
SoundManager(self._game, "SoundManager", "unknown.png", -1, -1))
self._game.instantiate(
UIManager(self._game, "UIManager", "unknown.png", -1, -1))
self.soundManager = self._game.getGameObjectByName("SoundManager")
self.uiManager = self._game.getGameObjectByName("UIManager")
#Music is here but I've disabled it for now
#self.soundManager.play_music("background.wav")
self._game.instantiate(
Player(self._game, "Player", "player.png", 100, 500))
self.player = self._game.getGameObjectByName("Player")
for i in range(0, 9):
self._game.instantiate(
Enemy(self._game, "Enemy", "enemy.png", 80 * i, 50))
self.scoreFont = pygame.font.Font('freesansbold.ttf', 16)
self.gameOverFont = pygame.font.Font('freesansbold.ttf', 64)
def process_events(self):
running = True
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
running = False
elif event.key == pygame.K_SPACE:
self.player.shoot(self.all_sprites, self.shoots)
elif event.type == pygame.QUIT:
running = False
# Add a new enemy?
elif event.type == ADDENEMY:
# Create the new enemy and add it to sprite groups
enemy = Enemy()
self.enemies.add(enemy)
self.all_sprites.add(enemy)
# Add a new cloud?
elif event.type == ADDCLOUD:
# Create the new cloud and add it to sprite groups
cloud = Cloud()
self.clouds.add(cloud)
self.all_sprites.add(cloud)
return running
def reset_map(self):
self.player = Player(375, 700, 50, 50, 'assets/player.png', 3)
speed = 5 + (self.level * 5)
if self.level >= 4.0:
self.enemies = [
Enemy(50, 600, 50, 50, 'assets/enemy.png', speed),
Enemy(750, 400, 50, 50, 'assets/enemy.png', speed),
Enemy(50, 200, 50, 50, 'assets/enemy.png', speed),
]
elif self.level >= 2.0:
self.enemies = [
Enemy(50, 600, 50, 50, 'assets/enemy.png', speed),
Enemy(750, 400, 50, 50, 'assets/enemy.png', speed),
]
else:
self.enemies = [
Enemy(50, 200, 50, 50, 'assets/enemy.png', speed),
]
def initialize(self):
self.image_cache.init_images()
player: Player = Player(self.image_cache.player_image)
player.set_position(x=370.0, y=480.0)
self.players.append(player)
x = random.randint(0, self.width - 64)
y = random.randint(50, 150)
print(str.format("world.x={}, world.y={}", x, y))
self.add_enemy(Enemy(image=self.image_cache.enemy_image_1), x, y)
self.add_enemy(Enemy(image=self.image_cache.enemy_image_1), x, y)
self.add_enemy(Enemy(image=self.image_cache.enemy_image_1), x, y)
y += 60
self.add_enemy(Enemy(image=self.image_cache.enemy_image_2), x, y)
self.add_enemy(Enemy(image=self.image_cache.enemy_image_2), x, y)
self.add_enemy(Enemy(image=self.image_cache.enemy_image_2), x, y)
def draw_enemys(self):
#k so now some recursive loops:
for enemycol in range(self.stage.get_stage()[0]):
#now for the rows
for enemyrow in range(self.stage.get_stage()[1]):
#make a new enemy object:
tempenemy = Enemy(self.list_enemys)
#this ones a long one, but it works:
tempenemy.set_pos(
globalvars.xmin + enemycol *
(globalvars.enemy_width + globalvars.enemy_spacing_x),
globalvars.ymin + enemyrow *
(globalvars.enemy_height + globalvars.enemy_spacing_y) -
150)
#this one is even worse, but works even better:
tempenemy.set_range(
globalvars.xmin + enemycol *
(globalvars.enemy_width + globalvars.enemy_spacing_x),
globalvars.xmax - (self.stage.get_stage()[0] - enemycol) *
(globalvars.enemy_height + globalvars.enemy_spacing_x))
#now add the temp enemy to the array and we're good to go
self.list_enemys.add(tempenemy)
def reset_map(self):
# Redraw character
self.player = Player(375, 700, 50, 50, 'assets/player.png', 10)
# Reset Speed
speed = 5 + (self.level * 5)
if self.level >= 4.0:
self.enemies = [
Enemy(0, 600, 50, 50, 'assets/enemy.png', speed),
Enemy(750, 400, 50, 50, 'assets/enemy.png', speed),
Enemy(0, 200, 50, 50, 'assets/enemy.png', speed),
]
elif self.level >= 2.0:
self.enemies = [
Enemy(0, 600, 50, 50, 'assets/enemy.png', speed),
Enemy(750, 400, 50, 50, 'assets/enemy.png', speed),
]
else:
self.enemies = [
Enemy(0, 600, 50, 50, 'assets/enemy.png', speed),
]
def run_game():
# Init all the pygame stuff
pygame.init()
# Set up tuple for screen size
screen_size = (1000, 800)
# Set up a tuple for the bg color
background_color = (82, 111, 53)
# Create a pygame screen to use
screen = pygame.display.set_mode(screen_size)
# Set a caption on the terminal
pygame.display.set_caption("A heroic third person shooter game")
the_player = Player(screen, "./images/Hero.png", 100, 100)
the_player_group = Group()
the_player_group.add(the_player)
bad_guy = Enemy(screen, "./images/2.png", 900, 400)
enemies = Group()
enemies.add(bad_guy)
# Main game loop. Run forever... (or until break)
while 1: # 1/True does exact same thing. 1 for simpler codes, True for more complex
screen.fill(background_color)
check_events(the_player)
# Draw player
for player in the_player_group:
the_player.draw_me()
# Draw Bad Guy
bad_guy.update_me(the_player)
bad_guy.draw_me()
# Check for collisions...
hero_died = groupcollide(the_player_group, enemies, True, False)
# Clear the screen for the next time through the loop
pygame.display.flip()
def __init__(self, level_id, music_status):
"""
Game Scene
"""
# Music
self.music_status = music_status
if music_status == "on":
self.music = Music(music_status)
self.music.play()
else:
self.music = Music("off")
# Pause
self.pause = False
# Font
font = pygame.font.Font(None, 24)
# Texts
pause_content = " (P)ause "
# Pygame Texts Elements
self.text = font.render(pause_content, 1, (COLORS["WHITE"]))
self.text_rect = (font.size(pause_content))[0]
# Level
self.level_id = level_id
self.final_level = 3
level_file = os.path.join(ASSETS_DIR, "gfx",
"level" + str(level_id) + ".tmx")
level = pytmx.load_pygame(level_file)
self.walls = []
self.items = []
wall_tiles = 0
item_tiles = 1
enemy_tiles = 2
player_tiles = 3
self.collide_enemy = False
for row in range(15):
for col in range(15):
# Walls in tmx file
wall = level.get_tile_image(row, col, wall_tiles)
if wall is not None:
self.wall = Wall((row, col))
self.walls.append(self.wall)
# Item in tmx file
item = level.get_tile_image(row, col, item_tiles)
if item is not None:
self.item = Item((row, col))
self.items.append(self.item)
# Enemy in tmx file
enemy = level.get_tile_image(row, col, enemy_tiles)
if enemy is not None:
self.enemy = Enemy((row, col))
# Player in tmx file
player = level.get_tile_image(row, col, player_tiles)
if player is not None:
self.player = Player((row, col))
# Items Counts
self.items_in_level = 0
for self.item in self.items:
self.items_in_level += 1
# Create a font
self.font = pygame.font.Font(None, 24)
# Sounds
self.sound_point = pygame.mixer.Sound(
os.path.join(ASSETS_DIR, "sfx/point.flac"))
self.sound_win = pygame.mixer.Sound(
os.path.join(ASSETS_DIR, "sfx/win.ogg"))
self.sound_fail = pygame.mixer.Sound(
os.path.join(ASSETS_DIR, "sfx/fail.wav"))
self.sound_rect_x, self.sound_rect_y = SCREEN_W - 35, SCREEN_H - 35
# Launching
self.run = True
self.status = 0
self.draw()
def test_enemy_take_damage_4(self):
enemy = Enemy(hit_points=500, lives=10)
enemy.take_damage(8000)
self.assertEqual(enemy.lives, 0)
self.assertEqual(enemy.hit_points, 0)
def test_enemy_take_damage_1(self):
enemy = Enemy(hit_points=30, lives=3)
enemy.take_damage(damage=24)
self.assertEqual(enemy.lives, 3)
self.assertEqual(enemy.hit_points, 6)
enemy.take_damage(damage=6)
self.assertEqual(enemy.lives, 2)
self.assertEqual(enemy.hit_points, 30)
enemy.take_damage(damage=30)
self.assertEqual(enemy.lives, 1)
self.assertEqual(enemy.hit_points, 30)
enemy.take_damage(damage=5)
self.assertEqual(enemy.lives, 1)
self.assertEqual(enemy.hit_points, 25)
enemy.take_damage(damage=7)
self.assertEqual(enemy.lives, 1)
self.assertEqual(enemy.hit_points, 18)
enemy.take_damage(damage=18)
self.assertEqual(enemy.lives, 0)
self.assertEqual(enemy.hit_points, 0)
enemy.take_damage(damage=1)
self.assertEqual(enemy.lives, 0)
self.assertEqual(enemy.hit_points, 0)
def update(self, time): newTime = time * 1000000 if math.floor(newTime % self.randomMovementMax) == 0: self.rush(self.game.player) Enemy.update(self, time)
def __init__(self, g, pos):
Enemy.__init__(self, g, pos, 'monster2')
hitSoundFile = os.path.join("effects", "critter4.wav")
self.birdhit = pygame.mixer.Sound(hitSoundFile)
self.health = 3
self.rect.height = 16
self.changedDirLastTick = 0
def spawn_monster(self, antal, pref=None, lila=None):
"""Spawnar vanliga mobs.
@param antal: Hur många mobs
@param pref: Vilken typ
"""
x = self.SCREEN_WIDTH
all_monsters = [os.path.join('images','dygaddaa.png'),
os.path.join('images','taggfisk.png'),
os.path.join('images','monsterfisk.png'),
os.path.join('images','taggfisk-blue.png'),
os.path.join('images','taggfisk-green.png')]
if pref:
img = all_monsters[pref]
elif lila:
img = os.path.join('images','taggfisk-lila.png')
else:
img = random.choice(all_monsters)
for i in range(antal):
random_y = random.randint(0,self.SCREEN_HEIGHT-100)
temp = Enemy(screen=self.screen,
img_filename=img,
init_position=(x, random_y)
)
temp.set_speed(random.randint(-7, -3))
self.enemy_grp.add(temp)
# Nästa fiende lite åt sidan
x += 60
class EnemyTests(unittest.TestCase):
def setUp(self):
self.enemy = Enemy()
def test_is_alive(self):
self.assertEqual(self.enemy.is_alive(), True)
def test_get_health(self):
self.assertEqual(self.enemy.get_health(), 100)
def test_get_mana(self):
self.assertEqual(self.enemy.get_mana(), 100)
def test_can_cast(self):
self.assertEqual(self.enemy.can_cast(), True)
def test_take_healing(self):
e = Enemy(80, 100, 20)
e.take_healing(15)
self.assertEqual(e.get_health(), 95)
def test_take_mana(self):
e = Enemy(100, 80, 20)
e.take_mana(15)
self.assertEqual(e.get_mana(), 95)
def __init__(self, g, pos):
Enemy.__init__(self, g, pos, 'drop')
self.frm1 = g.images['inventory'][0].subsurface((0 * 32, 8 * 32, 32, 32))
self.frm2 = g.images['inventory'][0].subsurface((1 * 32, 8 * 32, 32, 32))
self.frm3 = g.images['inventory'][0].subsurface((2 * 32, 8 * 32, 32, 32))
self.frm4 = g.images['inventory'][0].subsurface((3 * 32, 8 * 32, 32, 32))
self.timer = random.randint(0, 50)
def __init__(self, game, xStart = 0, yStart = 0, zStart = 0): models = MODELS_PATH + "SwarmCraft" anims = None Enemy.__init__(self, models, anims, "**/enemyCollisionSphere", game, xStart, yStart, zStart) self.maxSpeed = 5 self.randomMovementMax = random.randint(7 * 7, 10 * 7)
def create_enemy(game_settings, screen, enemies, enemy_number, row_number):
enemy = Enemy(game_settings, screen)
enemy_width = enemy.rect.width
enemy.x = enemy_width + 2 * enemy_width * enemy_number
enemy.rect.x = enemy.x
enemy.rect.y = enemy.rect.height + 2 * enemy.rect.height * row_number
enemies.add(enemy)
def after_move(self):
Enemy.after_move(self)
nextcell = self.level.get_neighbour(self.pos, self.move_dir)
if self.level.object_can_enter(
nextcell) and not self.level.get_solid_sprites_in(nextcell):
self.to_move = 1
def schedule_enemy(self, dt):
enemy = Enemy()
enemy.center = (self.width - 20, self.center_y)
self.add_widget(enemy)
(fx, fy) = self.x, random.randint(self.y, self.top)
enemy.animate(fx, fy, self)
self.enemies.append(enemy)
def test_distance(self):
e = Enemy(self.road, 100, "red", self.state)
e.posx = -20
e.posy = -20
x = 300
y = 400
self.assertEqual(gameState.distance(e, x, y), 500)
def testCleanup(self):
board = Board(5, 5)
player = Player()
enemy_one = Enemy()
enemy_one.destroyed = True
enemy_two = Enemy()
bullet_one = Bullet()
bullet_one.destroyed = True
bullet_two = Bullet()
bullet_two.destroyed = True
bullet_three = Bullet()
bonus_one = Bonus()
bonus_one.destroyed = True
bonus_two = Bonus()
board.rows[0][0] = player
board.rows[1][1] = enemy_one
board.rows[2][2] = enemy_two
board.rows[3][3] = bullet_one
board.rows[4][4] = bullet_two
board.rows[1][3] = bullet_three
board.rows[2][0] = bonus_one
board.rows[3][4] = bonus_two
board.cleanup()
self.assertEqual(board.rows[0][0], player)
self.assertEqual(board.rows[2][2], enemy_two)
self.assertEqual(board.rows[1][3], bullet_three)
self.assertEqual(board.rows[3][4], bonus_two)
self.assertIsNone(board.rows[1][1])
self.assertIsNone(board.rows[3][3])
self.assertIsNone(board.rows[4][4])
self.assertIsNone(board.rows[2][0])
