def fight(self, Hero, Enemy, who, a_power, d_power):
hero_attack = Hero.hattack() *a_power
print("Herro Attac", hero_attack)
hero_defense = Hero.hdefense() * d_power
print("Her Def", hero_defense)
enemy_attack = Enemy.eattack() * a_power
print("Enem Atta" , enemy_attack)
enemy_defense = Enemy.edefense() * d_power
print("enemy defd", enemy_defense)
crit = random.randint(0, 5)
if crit == 4:
x = 1.5
print("CRIT")
else:
x = 1
if who % 2 != 0:
hp = enemy_defense - x*hero_attack
Enemy.lost_health(hp)
self.label2.text = '[size=25]' + "Hero hit for " + str(abs(hp))
else:
ep = hero_defense - x*enemy_attack
Hero.lost_health(ep)
self.label3.text = '[size=25]' + "Enemy hit for " + str(abs(ep))
def generate_enemies(self):
newenemy = Enemy(self, "none")
initial_y = randint(0, 240)
initial_y -= 120
newenemy.move_pos(y = initial_y)
self.enemy_list.append(newenemy)
self.sprite_list.add(newenemy)
class EnemyTests(unittest.TestCase):
def setUp(self):
self.enemy = Enemy()
def test_name(self):
self.assertEqual(True, len(self.enemy.name) > 3)
def test_hp_is_above_9(self):
self.assertEqual(True, self.enemy.hp_count() > 9)
def test_has_type(self):
self.assertEqual(True, len(self.enemy.type) > 5)
def test_random(self):
self.assertEqual(True, self.enemy.random_for_type < 3)
def test_attack_damage(self):
self.assertEqual(
True,
self.enemy.deal_damage_to_player() >=
3 & self.enemy.deal_damage_to_player() < 26)
def test_armour_level_above_1(self):
self.assertEqual(True, self.enemy.armour > 1)
def test_can_receive_damage(self):
current_health = self.enemy.hp_count()
self.enemy.receive_damage(10)
self.assertEqual(current_health - 10 + self.enemy.armour,
self.enemy.hp_count())
def test_can_die(self):
self.enemy.receive_damage(100)
self.assertEqual(False, self.enemy.is_alive)
def test_normal_fight_lowers_health(self):
w = Weapon('The Axe of Destiny', 10)
h = Hero("Bron", "Dragonslayer", 100, 100, 1)
h.equip(w)
e = Enemy(100, 10)
f = Fight(h, e, [], 3, 3)
f.fight()
test_passes = False
if e.is_alive() is not True or h.is_alive() is not True:
test_passes = True
self.assertEqual(test_passes, True)
def generateRooms(self):
rooms = []
for i in range(self.number_of_rooms):
room = Room(i)
for j in range(room.number_of_enemies):
rand = random.randint(0, 1)
if rand == 0:
room.enemies.append(Enemy.Bat())
else:
room.enemies.append(Enemy.Zombie())
rooms.append(room)
return rooms
def createEnemies():
Enemy1 = Enemy(4, 3, 'E', 0, 3, Board.x-6, Board.y, 2, 1)
lists.Enemies.append(Enemy1)
Enemy2 = Enemy(2, 2, 'E', 0, 2, int(Board.x/2), Board.y, 1, 0)
lists.Enemies.append(Enemy2)
Enemy2 = Enemy(3, 2, 'E', 0, 2, Board.x, Board.y, 1, 1)
lists.Enemies.append(Enemy2)
Enemy2 = Enemy(3, 2, 'E', 0, 2, 2*Board.length +
int(Board.x/2)+2, Board.y, 1, 1)
lists.Enemies.append(Enemy2)
Enemy2 = Enemy(3, 2, 'E', 0, 2, 2*Board.length +
int(Board.x/2), Board.y, 1, 1)
lists.Enemies.append(Enemy2)
def create_enemies(self):
"""生成敌机"""
if len(self.enemies1) >= 5: return
if self.enemy_fre % 50 == 0:
enemy1 = Enemy()
if enemy1.type == 2:
if self.boss_alive:
while enemy1.type == 2:
enemy1 = Enemy()
else:
self.boss_alive = True
self.enemies1.add(enemy1)
self.enemy_fre += 1
if self.enemy_fre >= 100:
self.enemy_fre = 0
def create_enemy_matrix(self):
random.seed()
#enemy_types = [EnemyType.Enemy_one, EnemyType.Enemy_two, EnemyType.Enemy_tree]
x, y = 0, self.y_space
self.enemy_parent = []
for i in range(self.en_lines):
line = []
e_type = random.choice(list(self.enemy_types.keys()))
for j in range(self.en_columns):
en = Enemy(self.game, x, y, e_type, self.enemy_types[e_type],
30, 100, 400)
line.append(en)
self.game_images_running.append(en.game_image)
x += self.x_space
#print("x: %d,y: %d"%(x, y))
self.enemy_parent.append(line)
x = 0
y += self.y_space
self.max_y = y + self.y_space
self.en_columns += 1
if self.en_columns > self.max_columns:
self.en_columns = 3
self.en_lines = min(self.en_lines + 1, self.max_lines)
self.max_enemy_timer = self.default_en_timer
self.default_en_timer *= 0.95
return
def enemyGenerator(enemyList, maxEnemies, points):
x = random.randint(0, 100)
tmp = points
if points < 75:
tmp = 75
if x < (3 * (tmp / 75)) and len(
enemyList) < maxEnemies: # chance enemy will be generated
x = random.randint(0, 1)
if x == 1:
right = True
else:
right = False
speed = random.randint(1, 4)
speed += random.randint(0, 4)
speed += random.randint(0, 4)
if random.randint(0, 100) < 50: # 50% chance enemy will be flying
e = Enemyflying(right, speed)
#if random.randint(0,10) < 3 * math.ceil(points/100):
if random.randint(0, 10) < 1:
e.boss = True
e.speed = 8
else:
e.boss = False
enemyList.append(e)
#enemyList.append(Enemyflying(right, speed))
else:
enemyList.append(Enemy(right, speed))
def __init__(self):
pyxel.init(WINDOW_W, WINDOW_H, caption="Boss")
pyxel.load("assets/Boss.pyxres")
self.player_x = 100
self.player_y = 100
self.player_dx = 0
self.player_dy = 0
self.player_hp = 1000
self.enemy_hp = 100
self.pc_before_direction = 3
self.is_jump = False
self.is_OP = True
self.is_game_over = False
self.is_game_clear = False
# make instance
self.pc = pc.pc()
self.Balls = []
self.Enemies = []
self.enemy_particles = []
self.player_particles = []
self.Items = []
self.enemy_core = enemy.Enemy()
self.enemy_move = enemymov.EnemyMove()
self.for_move_point = ENEMY_CORE_NORMAL_Y
self.origin_time = 0
self.orioir = 0
self.oni = 0
self.on = 0
pyxel.run(self.update, self.draw)
def setup(self):
""" Set up the game and initialize the variables. """
# Set up the player
if self.game_start:
self.player_sprite = Player()
self.player_sprite.center_x = 100
self.player_sprite.center_y = 100
self.player_list = arcade.SpriteList()
self.player_list.append(self.player_sprite)
self.bullet_list = arcade.SpriteList()
self.explosions_list = arcade.SpriteList()
self.itemone = False
self.itemtwo = False
self.itemthree = False
# List of Enemy
self.enemy_list = Enemy.create()
# Our list of rooms
self.rooms = Rooms.create()
# Our starting room number
self.current_room = 0
# Create a physics engine for this room
self.physics_engine = arcade.PhysicsEngineSimple(
self.player_sprite, self.rooms[self.current_room].wall_list)
def crearOrda(ls_enemigos,ls_todos,num,vel):
for i in range(num):
enemigo = Enemy('Images/enemy'+str(random.randrange(1,4))+'.png',vel)
enemigo.rect.x=random.randrange(WIDTH-64)
enemigo.rect.y=random.randrange(HIGH-200)
ls_enemigos.add(enemigo)
ls_todos.add(enemigo)
def load_enemy(self):
for i in range(0, len(self.map)):
for j in range(0, len(self.map[0])):
if self.map[i][j] == 'E':
self.mediator.all_game_entities.append(
Enemy(self.screen, j * self.tile_size,
i * self.tile_size, 'enemy', self.player))
def __init__(self, screen):
self.screen = screen
# init UI
self.UI = ui.UI(screen)
# Calls UI loadingScreen to display loading screen while the game finishes __init__
self.UI.loadingScreen()
# init all classes building game
self.groundTiles = ground.groundTiles(screen)
self.trees = tree.TreeNodesList(screen)
self.antTrail = trail.AntTrail(screen, self.trees.list)
self.popoutLoader = popout.PopoutBox(screen)
self.enemy = enemy.EnemyList(screen, self.antTrail.grid, self.UI)
# Background Music
pygame.mixer.music.load("background_music.mp3")
# Variables set up for use in the AntTrail and Leaf Collection Logic
self.isTrailSelected = False
self.trailTree = None
# Mouse Cursor setup
self.mouseCursor = pygame.image.load(
"mouse_cursor.png").convert_alpha()
# Calls Start Screen loop after all assests are loaded
self.UI.startScreen()
pygame.mixer.music.set_volume(.3)
def play_game(self):
""" main play function of the game"""
play = True
background = [
os.path.join('Images', 'environment_forestbackground.png'),
os.path.join('Images', 'environment_forestbackground1-1.png'),
os.path.join('Images', 'environment_forest_evening.png')
]
while play:
# current fps
milliseconds = self.clock.tick(self.FPS)
# gets user play time
self.play_time += milliseconds / 1000.0
# creates new enemy
self.enemy = Enemy.Enemy(self.player)
# initializes background
self.print_frames()
self.screen.fill([255, 255, 255])
self.back = image.Image(background[random.randint(0, 2)], [0, 0])
self.screen.blit(self.back.image, self.back.rect)
# asks user to fight
text_surface = self.font.render('Press space to fight!!', False,
(0, 0, 0))
self.screen.blit(text_surface, (240, 300))
# begins battle
play = self.battle()
def check_new_tile(self, tile_grid):
battle = None
# Checks new location of hero to see if it is a combat area
boolean = tile_grid.check_combat_area((self.x_loc, self.y_loc),
self.width, self.height)
if boolean is True:
number = random.randint(0, 99)
if number < self.combat_chance:
battle = Battle.Battle(self,
Enemy.Wolf(100, 100, 100, 1, 1, 1))
self.combat_chance = 0
else:
self.combat_chance += 1
# Checks new location of hero to see if it is a load point
boolean, tile = tile_grid.check_load_points((self.x_loc, self.y_loc),
self.width, self.height)
# Returns hero sprite, hero_loc, and map_name / None
if boolean is True:
self.x_loc = tile.new_loc_x * tile_grid.tile_size
self.y_loc = (tile.new_loc_y * tile_grid.tile_size) - (
self.height - self.width) # Extra hero height
return tile.new_map, battle
else:
return None, battle
def update_spawns(self):
if len(self.environmentList) < (4 + self.num_obstacles):
while len(self.environmentList) < (4 + self.num_obstacles): # spawn random obstacles
x_pos_tl = random.randint(100, 400) # top left coords
y_pos_tl = random.randint(100, 400)
tl = Point.Point(x_pos_tl, y_pos_tl)
x_len = random.randint(100, 200)
y_len = random.randint(100, 200)
x_pos_br = random.randint(x_pos_tl, x_pos_tl + x_len)
y_pos_br = random.randint(y_pos_tl, y_pos_tl + y_len)
br = Point.Point(x_pos_br, y_pos_br)
obs = Wall.Wall(tl, br)
if self.__world_overlap(self, obs):
self.spawnWall(obs)
# spawn more creatures randomly if there are fewer than a certain number of creatures
if len(self.enemy_list) == 0:
while len(self.enemy_list) < self.num_enemies: # spawn random enemies
x_pos = random.randint(30, self.xPixels - 80)
y_pos = random.randint(30, self.yPixels - 80)
size = random.randint(25, 45)
speed = random.randint(3, 5)
health = random.randint(30, 80)
en = Enemy.Enemy(Point.Point(x_pos, y_pos), (Point.Point(x_pos + size, y_pos + size)), speed, health)
if self.__world_overlap(self, en):
self.spawn_enemy(en)
def addEnemy(lvl, name=None):
"""
Add an enemy to the level
@param lvl: Dictionnary containing all information about one \"Level\" object
@type lvl: dict
@param name: enemy's name to add
@type name: str
@return: -
@rtype: void
"""
assert type(name) is str or name == None
assertLevel(lvl)
if (name == None):
#if no name specified, random choice
listNames = os.listdir("./Enemys/")
enemyName = listNames[randint(0, len(listNames) - 1)]
if (enemyName in lvl["availableEnemys"]):
lvl["enemyList"].append(Enemy.Enemy(enemyName))
return
def spawn_enemies(self):
num = ((wave_num * 1.5) + 1) % 1
for i in range(num):
x = random.randint(1, 0)
if x == 1:
x = 800
Enemy.Enemy(image, width, height, x)
def runBattle(self, enemyNames, background, canFlee=True):
combatants = list(self.partyManager.team)
enemyElements = self.enemiesFile.getElementsByTagName("enemy")
for name in enemyNames:
found = filter(lambda e: str(e.getAttribute("name")) == name,
enemyElements)
if len(found):
combatants += [Enemy.Enemy(found[0])]
else:
self.logManager.error("No enemy called " + name +
" found in " + self.enemiesLocation +
".")
# Choose a nice battle music.
playingMusic = self.audioManager.getPlayingMusic()
self.audioManager.playMusic("music/battle" +
str(self.mathManager.randInt(1, 4)) +
".ogg")
battle = Battle.Battle(combatants, background, canFlee)
self.battleIntro()
battle.run()
self.audioManager.playMusic(playingMusic)
return battle.won
def create_level(n):
global level
for i in range(n):
enemy = Enemy()
actors.append(enemy)
enemies.append(enemy)
level += 1
def buildBodies(self):
self.center = Friend.FriendSprite(width=self.params['width'],
height=self.params['height'],
x= self.params['x'],
y= self.params['y'],
static="true",friction=20).setName('inner_circ'+self.params['name'])
self.bodies += self.center.render()[0]
self.joints += self.center.render()[1]
self.contacts += self.center.render()[2]
self.hub = Friend.FriendSprite(width=self.params['enemy_size']-3,
height=self.params['enemy_size']-3,
y= self.params['y'] + self.params['height']/2 + self.params['enemy_size']/2,
x= self.params['x'],
static="false",density=100).setName('axel'+self.params['name'])
self.bodies += self.hub.render()[0]
self.joints += self.hub.render()[1]
self.contacts += self.hub.render()[2]
self.outer = Enemy.EnemySprite(width=self.params['enemy_size'],
height=self.params['enemy_size'],
x= self.params['x'],
y= self.params['y'] + self.params['height']/2 + self.params['enemy_size']/2 -2,
static="false",density=100,friction=20).setName("rotor_enemy"+self.params['name'])
self.bodies += self.outer.render()[0]
self.joints += self.outer.render()[1]
self.contacts += self.outer.render()[2]
def update(self):
self.copies.update()
if self.wave == 2:
self.alive = True
self.game.player.setPos(self.spawn2[0], self.spawn2[1])
self.boss = Boss(self, self.bossSpawn[0], self.bossSpawn[1])
self.sound.playMusic(1, 1)
self.wave = 0
elif len(self.copies.sprites()) == 0 and len(self.game.enemies.sprites(
)) == 0 and not self.changedPos and not self.alive:
self.game.player.setPos(self.spawn1[0], self.spawn1[1])
self.changedPos = True
self.wave += 1
if self.wave != 2:
for i in self.enemies:
Enemy(self.game, i[0], i[1], 16, 16)
elif len(self.game.enemies.sprites()
) == 0 and self.changedPos and not self.alive:
self.game.player.setPos(self.spawn[0], self.spawn[1])
self.spawnCopies()
if self.wave == 1:
self.spawnAfterEnemies()
self.changedPos = False
if len(self.bossGroup.sprites()) > 0:
self.boss.update()
def loadLevel(self, levelFile, levelNumber):
f = open("Resources/Levels/" + levelFile)
lines = f.readlines()
f.close()
newlines = []
for line in lines:
newline = ""
for c in line:
if c != '\n':
newline += c
newlines += [newline]
lines = newlines
startIndex = lines.index(str(levelNumber)) + 1
endIndex = startIndex + 10
newlines = []
for line in range(startIndex, endIndex):
#print lines[line]
newlines += [lines[line]]
lines = newlines
for line in lines:
print line
for y, line in enumerate(lines):
for x, c in enumerate(line):
if c in "1234567890": #levels of dirt
self.dirts += [
Dirt(c, [
x * self.tileSize + self.tileSize / 2,
y * self.tileSize + self.tileSize / 2
], self.tileSize)
]
if c in "x": #Pew
self.enemies += [
Enemy(2, [
x * self.tileSize + self.tileSize / 2,
y * self.tileSize + self.tileSize / 2
], self.tileSize)
]
if c in "y": #Beatbox
self.enemies += [
ShootingEnemy(1, [
x * self.tileSize + self.tileSize / 2,
y * self.tileSize + self.tileSize / 2
], self.tileSize)
]
if c in "z": #Shade
self.enemies += [
Shade(4, [
x * self.tileSize + self.tileSize / 2,
y * self.tileSize + self.tileSize / 2
], self.tileSize)
]
def main():
pygame.font.init()
pygame.init()
screen = pygame.display.set_mode((1000, 700))
pygame.display.set_caption('Spaceships')
img = pygame.image.load("images\Background.jpg")
BackGround = pygame.transform.scale(img, (1000, 700))
backdropbox = BackGround.get_rect()
Player1 = Player()
score = 0
# enemy = Enemy("images\enemy.png")
pygame.display.flip()
screen.blit(BackGround, backdropbox)
clock = pygame.time.Clock()
all_sprites = pygame.sprite.Group()
bullets_group = pygame.sprite.Group()
mobs_group = pygame.sprite.Group()
all_sprites.add(Player1)
start = pygame.time.get_ticks()
now = pygame.time.get_ticks()
hits = pygame.sprite.groupcollide(mobs_group, bullets_group, True, True)
while True:
hits = pygame.sprite.groupcollide(mobs_group, bullets_group, True,
True)
for hit in hits.items():
score += 1
now = pygame.time.get_ticks()
screen.blit(BackGround, backdropbox)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit(0)
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
if bullets_group.__len__() < 1:
bullet = Bullet("images\Bullet.png", Player1.rect.x,
Player1.rect.y, bullets_group)
if now - start > 1000:
start = now
mob = Enemy("images\enemy.png", all_sprites)
mobs_group.add(mob)
all_sprites.update()
bullets_group.update()
bullets_group.draw(screen)
all_sprites.draw(screen)
text(screen, score)
Player1.show_lifes(screen)
# screen.blit(Player1.image, (Player1.rectx, Player1.recty))
pygame.display.flip()
clock.tick(60)
def add_big_plane(group1, group2, num):
for i in range(num):
enemy = Enemy.EnemyNum3(bg_size)
while pygame.sprite.spritecollide(enemy, group2, False,
pygame.sprite.collide_mask):
enemy.reset()
group1.add(enemy)
group2.add(enemy)
def setPlayer(self, app, toLoad=True, toSet=False):
#ako je vec setovan u online modu ne setuje se opet
if toSet == False: return
app.playerHealth = app.playerStartHealth = PEStrategy3.maxHealth
app.playerEnergy = app.playerStartEnergy = PEStrategy3.maxEnergy
app.players[0] = Enemy(app.playerStartHealth, 12,
app.playerStartEnergy, self.tag,
self.explorationFactor)
def __init__(self,code_good):
self.win_width = win_width
self.win_height = win_height
self.code_good = code_good
self.mPreset_enemies = []
num = len(TheEnd_dict)
print(num)
for i in range(NUM_ENEMIES):
spwn_x = randint(0, win_width)
chance = randint(0,5)
if num > 0:
print(num)
if chance == 0:
key = choice(list(TheEnd_dict.keys()))
letter = TheEnd_dict[key]
print(key, letter, "key, letter")
self.mPreset_enemies.append(Enemy(spwn_x, -50, str(letter)))
del TheEnd_dict[key]
num -= 1
else:
self.mPreset_enemies.append(Enemy(spwn_x, -50))
print(num, "num before while loop")
while num > 0:
spwn_x = randint(0, win_width)
key = choice(list(TheEnd_dict.keys()))
letter = TheEnd_dict[key]
print(key, letter, "key, letter")
self.mPreset_enemies.append(Enemy(spwn_x, -50, str(letter)))
del TheEnd_dict[key]
num -= 1
self.mEnemies = [deepcopy(self.mPreset_enemies[0])]
self.Enemy_delay = 0.5
self.Enemy_index = 1
self.mNum_enemies = len(self.mPreset_enemies)
self.bullet_list = []
self.mDel_enemies = False
self.mBoss_phase = False
self.mAdd_phase = True
self.hp_bar = pygame.image.load("Sprites/hp_gradient.png")
self.mFont = pygame.font.SysFont("Times New Roman", 50)
self.mEnemy_bullets = []
self.mEnemy_bullet_timer = 1.5
#player thing
self.Player = Player((800, 600), code_good, SHIP)
def cantina_level():
Background(backGround_sprite, 'Dune Sea level1.png', (1080, 720))
enemy = 10
t = 0
enemy_event = 30
pygame.time.set_timer(enemy_event, 2500)
FirstPlay(firstPlay_sprite)
Enemy(whiteStormTroopers_sprite, 150, 50, 350, 450)
DrawMouse(mouse_sprite)
x, y = 500, 320
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit(0)
if event.type == pygame.MOUSEBUTTONDOWN:
fire_sound.set_volume(0.6)
fire_sound.play()
firstPlay_sprite.update(pygame.mouse.get_focused(), True)
whiteStormTroopers_sprite.update(True, event.pos)
if event.type == pygame.MOUSEMOTION:
x, y = event.pos
if event.type == enemy_event and enemy != 0:
Enemy(whiteStormTroopers_sprite, 150, 50, 900, 450)
enemy -= 1
if Variables.hp <= 0:
t = 1
running = False
elif enemy == 0:
t = 2
Variables.hp = 20
running = False
backGround_sprite.draw(screen)
firstPlay_sprite.update(pygame.mouse.get_focused(), False)
whiteStormTroopers_sprite.update()
whiteStormTroopers_sprite.draw(screen)
mouse_sprite.update(x, y, pygame.mouse.get_focused())
firstPlay_sprite.draw(screen)
mouse_sprite.draw(screen)
healthpo(screen)
clock.tick(FPS)
pygame.display.update()
if t == 1:
Screens.total_shit()
elif t == 2:
Screens.complev()
def __init__(self):
self.player = Player.Player()
self.map_ = Map_.Map_(10)
self.enemy = Enemy.Enemy()
self.__game_end_event = Event()
self.player.position = self.map_.get_free_cell()
self.enemy.position = self.map_.get_free_cell()
def mn3():
Background(backGround_sprite, 'darlevel.jpg', (1080, 730))
enemy = 10
enemy_event = 30
t = 0
pygame.time.set_timer(enemy_event, 2500)
FirstPlay(firstPlay_sprite)
Enemy(whiteStormTroopers_sprite, 150, 50, 350, 450)
DrawMouse(mouse_sprite)
x, y = 500, 320
running = True
Sounds.Music('data1/Sounds/maintheme.ogg')
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit(0)
if event.type == pygame.MOUSEBUTTONDOWN:
fire_sound.set_volume(0.6)
fire_sound.play()
firstPlay_sprite.update(pygame.mouse.get_focused(), True)
whiteStormTroopers_sprite.update(True, event.pos)
if event.type == pygame.MOUSEMOTION:
x, y = event.pos
if event.type == enemy_event and enemy != 0:
Enemy(whiteStormTroopers_sprite, 150, 50, 900, 450)
enemy -= 1
if Variables.hp <= 0:
t = 1
running = False
elif enemy == 0:
t = 2
Variables.hp = 20
running = False
backGround_sprite.draw(screen)
firstPlay_sprite.update(pygame.mouse.get_focused(), False)
whiteStormTroopers_sprite.update()
whiteStormTroopers_sprite.draw(screen)
mouse_sprite.update(x, y, pygame.mouse.get_focused())
firstPlay_sprite.draw(screen)
mouse_sprite.draw(screen)
healthpo(screen)
clock.tick(FPS)
pygame.display.update()
if t == 1:
return 1
def setUpEnemy(self, screen):
self.enemyList = []
enemy = Enemy("Zombie.gif", screen.get_width() - 100, screen.get_height() - 100, 288, 288, 4, 4, self.enemyAI)
self.enemyList.append(enemy)
if self.level > 2:
enemy = Enemy("Zombie.gif", screen.get_width() - 100, screen.get_height() - 700, 288, 288, 4, 4, True)
self.enemyList.append(enemy)
if self.level > 4:
enemy = Enemy("Zombie.gif", screen.get_width() / 2, screen.get_height() / 2, 288, 288, 4, 4, True)
self.enemyList.append(enemy)
for enemy in self.enemyList:
enemy.set_animation_delay(100)
enemy.play(True)
def __init__(self):
super(Game, self).__init__()
self.map = Map(data)
self.pathfinding = AStar(self.map)
pyglet.clock.schedule_interval(self.update, 1/120.0)
self.pause = False
self.message = Message(["Well hello there, you sexy beast. This is long text...", "You bastard"]);
self.player = Player(self, self.map.grid[2,1], 0, 0)
self.npc = NPC(self, self.map.grid[2,1], self.map.get_tile(7,5))
self.player.create_animations()
self.npc.create_animations()
self.enemy = Enemy(self, self.map.grid[2,1], self.map.get_tile(1,5))
self.enemy.create_animations()
#little hack to get the viewport centered and then to follow the player
temp_size = self.get_size()
self.viewport_x = temp_size[0]/2
self.viewport_y = 0
self.offset_x = 0
self.offset_y = 0
self.update_viewport(temp_size[0]/2, 0)
self.viewport_y = temp_size[1]/2
def encounter_bard():
Enemy.create_bard()
encounter()
def encounter_thief():
Enemy.create_thief()
encounter()
def encounter_archer():
Enemy.create_archer()
encounter()
def encounter_mage():
Enemy.create_mage()
encounter()
def encounter_warrior():
Enemy.create_warrior()
encounter()
def initEnemyData(self):
cnt = 0
# get root node
root = parse("Enemy.xml").getroot()
for tag in root.getiterator("enemy"):
# get name especially
name = tag.find("name").text
stamp = Enemy(0, 0, name)
# get data
stamp.eid = cnt
stamp.lv = int(tag.find("lv").text)
stamp.sort = tag.find("sort").text # species(machine, ghost, animal, ...)
#stamp.type
stamp.boss = bool(int(tag.find("boss").text))
stamp.move = int(tag.find("move").text)
stamp.maxHP = stamp.HP = int(tag.find("hp").text)
stamp.maxMP = stamp.MP = int(tag.find("mp").text)
stamp.ATK = int(tag.find("atk").text)
stamp.DEF = int(tag.find("def").text)
stamp.MATK = int(tag.find("matk").text)
stamp.MDEF = int(tag.find("mdef").text)
stamp.SPD = int(tag.find("speed").text)
stamp.JMP = int(tag.find("jump").text)
stamp.KB = int(tag.find("kb").text)
stamp.EXP = int(tag.find("exp").text)
stamp.GOLD = int(tag.find("gold").text)
#stamp.drop
stamp.imgFrame = int(tag.find("imgframe").text)
stamp.rect.size = (int(tag.find("width").text), int(tag.find("height").text))
#stamp.skill
# append to list and dict
self.enemyStamp.append(stamp)
self.enemyId[name] = cnt
cnt += 1
def attackTurn(p,e):
hit = p.attackRoll()
e.takeDamage(hit)
def healingSpell(h,p):
p.health += h.castSpell(2)
def damageSpell(p,e):
e.takeDamage(p.castSpell(2))
for he in range(5,21):
for hp in range(8,14):
human = Player(hp,0,0,0)
baddie = Enemy(he,0,0,0)
battles = 0
humanWins = 0
baddieWin = 0
def fightSequence():
#print("Human: HP = ",human.health,"\n")'''
#print("Baddie: HP = ",baddie.health,"\n")'
global hp
global he
baddie.rollInit()
human.rollInit()
spellcasts = 0
'''if(human.initiative > baddie.initiative):
print("human will attack first\n")
else:
print("baddie will attack first\n")'''
class Game(pyglet.window.Window):
def __init__(self):
super(Game, self).__init__()
self.map = Map(data)
self.pathfinding = AStar(self.map)
pyglet.clock.schedule_interval(self.update, 1/120.0)
self.pause = False
self.message = Message(["Well hello there, you sexy beast. This is long text...", "You bastard"]);
self.player = Player(self, self.map.grid[2,1], 0, 0)
self.npc = NPC(self, self.map.grid[2,1], self.map.get_tile(7,5))
self.player.create_animations()
self.npc.create_animations()
self.enemy = Enemy(self, self.map.grid[2,1], self.map.get_tile(1,5))
self.enemy.create_animations()
#little hack to get the viewport centered and then to follow the player
temp_size = self.get_size()
self.viewport_x = temp_size[0]/2
self.viewport_y = 0
self.offset_x = 0
self.offset_y = 0
self.update_viewport(temp_size[0]/2, 0)
self.viewport_y = temp_size[1]/2
def update(self, dt):
self.clear()
self.map.draw()
self.player.draw()
self.enemy.draw()
self.npc.draw()
self.player.inventory.update(self.offset_x, self.offset_y)
if not self.message.finished:
self.pause = True
self.message.show()
else:
self.pause = False
if self.pause:
return
self.player.update(dt)
if self.enemy.is_alive():
if not self.enemy.tasks.has_tasks():
self.enemy.calculate_next_move()
if self.enemy.next_move != self.enemy.tile:
self.enemy.tasks.add_task(self.enemy.next_move, TASK_WALK)
self.enemy.update(dt)
def update_viewport(self, x = -1, y = -1):
x_pos, y_pos = x, y
if x == -1:
x_pos = -self.player.x + self.viewport_x
if y == -1:
y_pos = -self.player.y + self.viewport_y
self.offset_x = x_pos
self.offset_y = y_pos
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
glTranslatef(x_pos, y_pos, 1.0)
glPushMatrix()
glPopMatrix()
def on_mouse_press(self, x, y, button, modifiers):
x_pos = x - self.offset_x
y_pos = y - self.offset_y
if button == LEFT_CLICK:
if self.message:
self.message.next()
if self.pause:
return
if button == RIGHT_CLICK:
for tile in self.map.tiles:
if(tile.contains(tile.image, x_pos, y_pos) == True):
if tile.is_passable():
move_loc = tile.get_move_loc()
tasks = self.pathfinding.calcShortest(self.map.get_tile(self.player.grid_x, self.player.grid_y), self.map.get_tile(move_loc[0], move_loc[1]))
if tasks:
if len(tasks) > 1:
self.player.tasks.clear_tasks()
tasks.reverse()
tasks.pop(0)
index = len(tasks) - 1
for task in tasks:
self.player.tasks.add_task(task, TASK_WALK)
if type(tasks[index].person) == NPC:
action = self.player.tasks.add_task(tasks[index].person, TASK_SPEAK)
if type(tasks[index].person) == Enemy:
tasks[index].person.under_attack = True
self.player.tasks = TaskQueue()
self.player.tasks.add_task(tasks[index].person, TASK_GOTO)
print "Task Attack"
self.player.tasks.add_task(tasks[index].person, TASK_ATTACK)
else:
print "No path!"
break;
for item in self.map.items:
if item.is_chest_item():
if item.image.frames:
if item.contains(item.image.frames[0].image, x_pos, y_pos):
self.player.tasks.add_task(item, TASK_ACTION)
else:
if item.contains(item.image, x_pos, y_pos):
self.player.tasks.add_task(item, TASK_ACTION)
for item in self.player.inventory.items:
if item.contains(item.image, x_pos, y_pos):
item.action(self.player)
self.player.inventory.items.remove(item)
if self.enemy.contains(self.enemy.image.frames[0].image, x_pos, y_pos):
self.enemy.under_attack = True
self.player.tasks = TaskQueue()
self.player.tasks.add_task(self.enemy, TASK_GOTO)
print "Enemy click Task Attack"
self.player.tasks.add_task(self.enemy, TASK_ATTACK)
def __init__(self):
yaml_path = 'config/airplane_1_alpha.yaml'
self.rooms = {}
self.abilities = []
self.ability_dict = {}
self.enemies = {}
room_data = yaml.load_all( open(yaml_path, 'r') )
### Load map data
print "Loading map file..."
for d in room_data:
newroom = Room()
newroom.setDescription(d['description'])
directional_descs = [d['look_north'], d['look_south'], d['look_east'], d['look_west']]
newroom.setDirectionalDescriptions(directional_descs)
## Check for alt descriptions
if 'look_alt_north' in d.keys():
newroom.setAltDesc('north', d['look_alt_north'])
newroom.setAltDescBool('north', False)
if 'look_alt_south' in d.keys():
newroom.setAltDesc('south', d['look_alt_south'])
newroom.setAltDescBool('south', False)
if 'look_alt_east' in d.keys():
newroom.setAltDesc('east', d['look_alt_east'])
newroom.setAltDescBool('east', False)
if 'look_alt_west' in d.keys():
newroom.setAltDesc('west', d['look_alt_west'])
newroom.setAltDescBool('west', False)
moves = [d['north'], d['south'], d['east'], d['west']]
newroom.setDirectionalMoves(moves)
self.rooms[(d['x'],d['y'])] = newroom
room_items = []
for item in d['items']:
new_obj = InteractiveObject()
new_obj.setName(item['name'])
new_obj.setItems(item['item_list'])
new_obj.setUnlockItems(item['unlock_item'])
if len(new_obj.getUnlockItems()) > 0:
new_obj.setUnlockText(item['unlock_text'])
new_obj.setKeywords(item['keyword'])
new_obj.setDirectionToChange(item['map_side_to_change'])
new_obj.setExamineText(item['examine_text'])
new_obj.setEquippable(item['equippable'])
if new_obj.getEquippable():
new_obj.setStrength(item['strength'])
new_obj.setIntellect(item['intellect'])
# Alt text to change
if 'alt_text_dir' in item.keys():
new_obj.setAltDescDirection(item['alt_text_dir'])
## Droppable items, if any
d_items = []
for d_item in item['droppable_items']:
d_obj = InteractiveObject()
d_obj.setName(d_item['name'])
d_obj.setItems(d_item['item_list'])
d_obj.setUnlockItems(d_item['unlock_item'])
if len(d_obj.getUnlockItems()) > 0:
d_obj.setUnlockText(d_item['unlock_text'])
d_obj.setKeywords(d_item['keyword'])
d_obj.setDirectionToChange(d_item['map_side_to_change'])
d_obj.setExamineText(d_item['examine_text'])
d_obj.setEquippable(d_item['equippable'])
if d_obj.getEquippable():
d_obj.setStrength(d_item['strength'])
d_obj.setIntellect(d_item['intellect'])
d_items.append(d_obj)
new_obj.setDroppableItems(d_items)
room_items.append(new_obj)
newroom.setItems(room_items)
newroom.setEnemies(d['enemies'])
print "Map file loaded!"
### Load ability data
ability_yaml_path = 'config/ability_bank.yaml'
ability_data = yaml.load_all( open(ability_yaml_path, 'r') )
for a in ability_data:
new_a = Ability()
new_a.setName(a['name'])
new_a.setLevelReq(a['level_req'])
new_a.setDamage(a['damage'])
new_a.setForPlayer(a['for_player'])
self.ability_dict[a['id']] = new_a
#self.abilities.append(new_a)
### Load enemy data
enemy_yaml = 'config/enemies.yaml'
enemy_data = yaml.load_all( open(enemy_yaml, 'r') )
for e in enemy_data:
new_e = Enemy()
id = e['id']
#new_e.setPos((e['x'], e['y']))
new_e.setName(e['name'])
new_e.setHP(e['hp'])
new_e.setMP(e['mp'])
new_e.setXP(e['xp'])
for a_id in e['abilities']:
new_e.addAbility(self.ability_dict[a_id])
self.enemies[id] = new_e
def encounter_pawn():
Enemy.create_pawn()
encounter()
def drawEnemies(ALL_ENEMIES): for Enemy in ALL_ENEMIES: Enemy.draw(DISPLAYSURF)
#Declare globals GameSprite.BG = BG GameSprite.allSprites = allSprites GameSprite.screenSize = screenSize GameSprite.bullets = bulletgroup GameSprite.weapons = weapondisplaygroup #Initiate hero hero = Hero((screenSize[0]/2, screenSize[1]/2), screenPos) hero.enemies = enemygroup hero.takeWeapon(TestWeapon(hero, 0, 5)) hero.switchWeapon() #Test enemy enemy = Enemy((5, 5), screenPos) enemy.enemies = herogroup enemy.weapon = Pistol(enemy, 0, 1) enemy2 = Enemy((130, 5), screenPos) enemy2.enemies = herogroup enemy2.weapon = Pistol(enemy2, 0, 1) allSprites.add(enemy) enemygroup.add(enemy) allSprites.add(enemy2) enemygroup.add(enemy2) weapondisplaygroup.add(enemy2.weapon) weapondisplaygroup.add(enemy.weapon) #Test weapongroup weap1 = WeaponHolder((100, 400), screenPos, Pistol(hero, 0, 30)) weap2 = WeaponHolder ((100, 450), screenPos, Shotgun(hero, 0, 30))
def Animate(): for Player in PLAYER_LIST: Player.update_frame(pygame.time.get_ticks()) for Enemy in LIST_OF_ENEMIES: Enemy.update_frame(pygame.time.get_ticks())
def main():
#setup or define variables and initialize them
pygame.init()
Text_color = (0,0,200)
score = 0
sound = pygame.mixer.music.load("data/main.ogg")
frame = pygame.time.Clock()
screen = Display().createWindow(640, 640)
player_shoot = True
enemy_shoot = True
display_enemy = True
screen.fill((0,0,234))
size = pygame.display.get_surface().get_rect().size
P_pos = [size[0]/2, size[1]-100]
bullet_speed = 6 #bullet speed for player
P_image = load_image("player.png", True)
E_image = load_image("enemy.png", False)
E_shot = load_image("Enemyshot.png", False)
P_shot = load_image("Playershot.png", False)
back = load_image("background.png", True)
back = pygame.transform.scale(back,(650, 650))
back_rect = back.get_rect()
back_rect.topleft = 0, -10
player = Player(P_image, P_shot, P_pos, bullet_speed)
player.set_speed(50)
EnemyList = []
displayPlayer = True
EnemyAddCounter = 120
EnemyOneCounter = 60
pygame.mouse.set_visible(True)
bullets = [] #EnemyBullets list
shot_speed = 8 #bullet speed for enemy
Display().setTitle("Space Shooter")
life = 5
#open the score flat-file
file = open("data/score.pck", "r")
f = file.read()
p_score = int(f)
file.close()
if(p_score == 0 or p_score < 20):
file = open("data/score.pck", "w")
file.write(str(20))
p_score = 20
file.close()
pygame.mixer.music.play(-1, 0.0)
while True:
#the game-loop:
screen.fill((0,0,234))
EnemyAddCounter -= 1
EnemyOneCounter -= 1
if(EnemyAddCounter == 0):
EnemyAddCounter = 120
enemy = Enemy(E_image, E_shot, (random.randint(0, 315), -10), shot_speed)
enemy.set_speed(5)
EnemyList.append(enemy)
if(EnemyOneCounter ==0):
EnemyOneCounter = 60
enemy = Enemy(E_image, E_shot, (random.randint(320, 575), -10),shot_speed)
enemy.set_speed(5)
EnemyList.append(enemy)
screen.blit(back, back_rect)
createText("Score: " +str(score), 12, (255, 255, 255),10, 10,None )
createText("Top Score: "+str(p_score), 12, (255,255,255) ,10, 30, None)
createText("Life: "+str(life), 12, Text_color ,10, 50, None)
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
pygame.quit()
sys.exit()
if event.key == K_LEFT and (player.img_rect.left - 50) >= 0:
player.move("left")
if event.key == K_RIGHT and (player.img_rect.right + 50) <= 670:
player.move("right")
if event.key == K_UP and (player.img_rect.top - 30) >=0:
player.move("up")
if event.key == K_DOWN and (player.img_rect.bottom + 50) <= 640:
player.move("down")
if event.key == K_SPACE and player_shoot:
player.shoot()
for enemy in EnemyList:
if(random.randint(0, 50) == 2) and enemy_shoot == True:
enemy.shoot()
if display_enemy:
enemy.move_bullets()
enemy.move()
enemy.update()
for enemy in EnemyList:
if enemy.img_rect.y > 640:
EnemyList.remove(enemy)
else:
for bull in player.bullets:
if bull.colliderect(enemy.img_rect):
bullets = enemy.bullets
EnemyList.remove(enemy)
score+= 1
player.bullets.remove(bull)
for bull in enemy.bullets:
if(bull.colliderect(player.img_rect)):
enemy.bullets.remove(bull)
life -= 1
for rect in bullets:
if(rect.colliderect(player.img_rect)):
bullets.remove(rect)
life -= 1
if(rect.y > 640):
bullets.remove(rect)
else:
rect.move_ip(0, 8)
screen.blit(E_shot, rect)
if(life < 1):
for bullet in player.bullets:
player.bullets.remove(bullet)
for bullet in bullets:
bullets.remove(bullet)
for bullet in enemy.bullets:
enemy.bullets.remove(bullet)
EnemyList = []
displayPlayer = False
player_shoot = False
enemy_shoot = False
display_enemy = False
screen.blit(back, back_rect)
if(p_score < score):
file = open("data/score.pck", "w")
file.write(str(score))
file.close()
createText("CONGRATULATION, YOU MADE A NEW HIGH SCORE OF ",20, Text_color,50, 310, None)
p_score = score
else:
createText("GAME OVER, YOU FAILED TO MAKE A NEW HIGH SCORE ", 20, Text_color,50, 310, None)
createText("PRESS Q TO PLAY AGAIN!!!" , 20, Text_color ,50, 330, None)
pygame.display.update()
wait_forkey()
score = 0
life = 5
displayPlayer=True
display_enemy = True
enemy_shoot = True
player_shoot = True
player.move_bullets()
if(displayPlayer == True):
player.update()
pygame.display.update()
frame.tick(60)
COOLDOWN_TIME = 5
ENEMY_IMAGE = 'mutalisk.gif'
NUM_ENEMIES = 10
ENEMY_SPEED = -3
score = 0
clock = pygame.time.Clock()
font = pygame.font.Font(None, 28)
gameover = False
bc = Battlecruiser(screen, BC_IMAGE, SCREEN_WIDTH/2, SCREEN_HEIGHT - 150, 0, 0)
lasers = []
enemy = Enemy(screen, ENEMY_IMAGE, randint(1,SCREEN_WIDTH), randint(1, SCREEN_HEIGHT), randint(-3,3), ENEMY_SPEED, 0)
bgimage = load_image("ram_aras.png")
while gameover != True:
time_passed = clock.tick(FPS)
screen.fill(BACKGROUND_COLOR)
screen.blit(bgimage, (0,0))
score_display = font.render("Score: " + str(score), 1, (255, 255, 255))
screen.blit(score_display, (10, 10))
key = pygame.key.get_pressed()
bc.dx = 0
bc.dy = 0
bc.draw()
for laser in lasers:
def main():
play = True
pyg.init()
clock = pyg.time.Clock()
player = Player(540, 578)
enemy = Enemy()
left = right = up = boost = start = False
e_alive = pl_alive = True
everything = pyg.sprite.Group()
everything.add(player, enemy)
platforms = []
level = ["------------------------------------------------------------------------------------",
"- ",
"- ",
"- ",
"- ",
"- -----------------------------------------------------------",
"- --- -",
"- ----- -",
"- -",
"-- -",
"- -",
"- -",
"- -",
"- ---- -",
"- -",
"- -",
"- --- -",
"- -",
"- -",
"------------------------------"]
screen = pyg.display.set_mode(DISPLAY)
bg = Surface((WIN_W,WIN_H))
bg.fill(BG_COLOUR)
bl_x = bl_y = 0
for row in level:
for symbol in row:
if symbol == '-':
block = Blocks(bl_x,bl_y)
everything.add(block)
platforms.append(block)
bl_x += PLATFORM_W
bl_y += PLATFORM_H
bl_x = 0
total_lvl_w = len(level[0]) * PLATFORM_W # stage's width
total_lvl_h = len(level) * PLATFORM_H # stage's height
camera = Camera(cam_cfg, total_lvl_w, total_lvl_h)
while play:
pyg.display.set_caption('BroFormer: FPS = ' + str(int(clock.get_fps())))
for event in pyg.event.get():
if event.type == pyg.QUIT:
play = False
if event.type == KEYDOWN:
if event.key == K_LEFT: left = True
if event.key == K_RIGHT: right = True
if event.key == K_UP: up = True
if event.key == 304: boost = True
if event.type == KEYUP:
if event.key == K_LEFT: left = False
if event.key == K_RIGHT: right = False
if event.key == K_UP: up = False
if event.key == 304: boost = False
if not start:
if player.rect.x in ENEMY_START_BOX_X:
if player.rect.y in ENEMY_START_BOX_Y:
start = True
enemy.update(player.rect.x, player.rect.y, start, e_alive)
player.update(enemy.pl_alive, left, right, up, boost, platforms)
enemy.pl_alive = True
camera.update(player)
for something in everything:
screen.blit(something.image, camera.apply(something))
pyg.display.update()
screen.blit(bg, (0,0))
clock.tick(60)
pyg.quit()
def draw(self, screen, camera, time):
Enemy.draw(self, screen, camera, time)
white = (255,255,255)
red = (255, 0, 0)
blue = (0,0, 255)
green = (0,255,0)
pygame.init()
bullets = pygame.sprite.Group()
clock = pygame.time.Clock()
level1 = Level("level2")
level1.levelCreate(0,0)
player = level1.player
level1.all_sprite.add(player.health)
enemy = Enemy(400,0)
level1.enemy_sprite.add(enemy)
level1.all_sprite.add(enemy)
facing = ""
size = [700, 700]
screen = pygame.display.set_mode(size)
pygame.display.set_caption("GAME")
#screen.fill(white)
counter =0
done = False
#clock = pygame.time.Clock()
while done == False:
def update(self, camera, delta, platforms):
if(self.isWolf):
self.dmgFRAMES[0]=self.wolfFRAMES[1]
self.dmgFRAMES[1]=self.wolfFRAMES[5]
Enemy.update(self, camera, delta, platforms)
player = Priest(10,0,0,0)
elif x.lower() == "ranger":
player = Ranger(10,0,0,3)
elif x.lower() == "rogue":
player = Rogue(8,0,0,1)
elif x.lower() == "scribe":
player = Scribe(10,0,0,0)
elif x.lower() == "sorcerer":
player = Sorcerer(10,0,0,0)
choice(selection)
while player.alive:
#spawn enemy
randy = randint(4,9)
creature = Enemy(randy,0,0,0)
#display enemy stats
print("Creature HP: ",creature.health)
#increment encounter number
totalEncounters = totalEncounters + 1
#roll for initiative
player.rollInit()
creature.rollInit()
print("Your initiative roll: ",player.initiative)
print("The creature's initiative roll: ",creature.initiative)
input()
#sort the attackOrder List
#loop the attack phase until either the enemy or player is dead
def playGame(screen, character, currentInfoText):
screen_rect = screen.get_rect()
level = LevelTutorial("level/tutorial/tutorial.txt", character, currentInfoText)
world = level.world
crashman = level.crashman
pygame.mouse.set_visible(True)
camera = Camera(screen, crashman.rect, level)
all_sprite = level.all_sprite
clock = pygame.time.Clock()
up = down = left = right = False
x, y = 0, 0
#randomly selects an enemy port
enemy_list=[]
activePortIndex=random.randrange(len(level.enemy_ports))
activePort=level.enemy_ports[activePortIndex]
#untilNextSpawn=level.spawn_delay
untilNextSpawn=0
totalTime=0
enemyCount=0
hud=HUD()
#this is the while true loop
while crashman.alive :
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN and (event.key == K_ESCAPE or event.key==K_RETURN):
up=down=left=right=False
pauseScreen(screen,character)
#control crashman
keys = pygame.key.get_pressed() #checking pressed keys
if keys[pygame.K_UP] or keys[pygame.K_SPACE]:
up=True
else:
up=False
if keys[pygame.K_DOWN]:
down=True
else:
down=False
if keys[pygame.K_LEFT]:
left=True
else:
left=False
if keys[pygame.K_RIGHT]:
right=True
else:
right=False
#sequential spawn order
if untilNextSpawn<=0 and enemyCount<level.enemy_max:
print "ENEMY HERE NOW"
e=Enemy(activePort[0],activePort[1],activePort[2],level)
enemy_list.append(e)
level.all_sprite.add(e)
world.append(e)
activePortIndex+=1
if activePortIndex>=len(level.enemy_ports):
activePortIndex=0
activePort=level.enemy_ports[activePortIndex]
untilNextSpawn=level.spawn_delay
enemyCount+=1
#random spawn order
"""if untilNextSpawn<=0 and enemyCount<level.enemy_max:
print "ENEMY HERE NOW"
e=Enemy(activePort[0],activePort[1],activePort[2],level)
enemy_list.append(e)
level.all_sprite.add(e)
world.append(e)
activePortIndex=random.randrange(len(level.enemy_ports))
activePort=level.enemy_ports[activePortIndex]
untilNextSpawn=level.spawn_delay
enemyCount+=1"""
#removes dead enemies
for e in enemy_list:
if e.alive==False:
print "ded del thjo"
enemy_list.remove(e)
all_sprite.remove(e)
world.remove(e)
enemyCount-=1
if e.freshkick==True:
hud.enemies_defeated+=1
hud.update()
e.freshkick=False
#timer and spawn countdown
#updates hud time
tpt = tps(clock, FPS)
totalTime+=tpt
if hud.time!=math.floor(totalTime):
hud.time=math.floor(totalTime)
hud.update()
if enemyCount<level.enemy_max:
untilNextSpawn-=tpt
print str(enemyCount)+": "+str(untilNextSpawn)
#DRAW ORDER:
#bg, world, elemental, hud
#camera.draw_sprites(screen, all_sprite)
level.drawBG(screen)
camera.draw_sprites_prio(screen, all_sprite, crashman)
if level.elemental:
level.elementalOverlay.draw(screen)
hud.draw(screen)
level.drawInfo(screen)
#final updates
crashman.update(up, down, left, right)
for e in enemy_list:
e.update(tpt)
camera.update()
pygame.display.flip()
#################################
#game complete
#pygame.display.flip()
playGame(screen,character, level.currentInfoBlock.infoText)
