def generate_random_enemies(self):
if self.player.points < 100:
number_of_enemies = random.randint(0, 6)
position_Y = random.randint(0, self.height - 70)
while number_of_enemies > 0:
y = random.randint(0,self.height-50)
self.player.enemies.append(Enemy(self.weight - 50 * number_of_enemies, y, -1, 50, 50))
number_of_enemies -= 1
else:
self.player.points = 0
self.boss = True
if self.level == 1:
self.player.enemies.append(Enemy(self.weight - 100, self.height / 2, -1, 76, 77))
for enemy in self.player.enemies:
enemy.health = 15000
enemy.image = pygame.image.load("images/monster_lvl1.png")
elif self.level == 2:
self.player.enemies.append(Enemy(self.weight - 100, self.height / 2, -1, 69, 77))
for enemy in self.player.enemies:
enemy.image = pygame.image.load("images/monster_lvl2.png")
enemy.health = 20000
else:
self.player.enemies.append(Enemy(self.weight - 100, self.height / 2, -1, 51, 67))
for enemy in self.player.enemies:
enemy.image = pygame.image.load("images/monster_lvl3.png")
enemy.health = 50000
def respawn(self, enemies):
if len(enemies) < 2:
sx = 640
width = 400 - int(self.score / 10)
if width < 300:
width = 300
if len(enemies) == 1:
sx = enemies[0].x + width
if sx < 640:
sx = 640
rand = random.randint(1, 8)
if rand <= 4:
enemy = Enemy(random.randint(sx, sx + width), 290, 64, 192, pygame.image.load("image/obj2.png"))
enemy.set_speed(-10, 0)
enemy.set_attack_type(1)
enemies.append(enemy)
if 4 < rand <= 8:
enemy = Enemy(random.randint(sx, sx + width), 290, 64, 128, pygame.image.load("image/obj1.png"))
enemy.set_speed(-10, 0)
enemy.set_attack_type(2)
enemies.append(enemy)
if 8 < rand:
enemy = Enemy(random.randint(sx, sx + width), 290, 64, 192, pygame.image.load("image/obj3.png"))
enemy.set_speed(-10, 0)
enemy.set_attack_type(3)
enemies.append(enemy)
def spawn():
if wave%10 == 0:
enemy = Boss(10,10,height)
enemies.append(enemy)
elif wave%5 == 0:
picture = "Enemy.png"
columns = 7
for y in range(50, 500, 150):
for x in range(50, 850, 150):
enemy = Enemy(x,y,wave,picture,columns)
enemies.append(enemy )
elif wave%2 == 1:
picture = "curtn.png"
columns =3
for y in range(50, 500, 150):
for x in range(50, 850, 150):
enemy = Enemy(x,y,wave,picture,columns)
enemies.append(enemy)
elif wave%2 == 0:
picture = "sone.png"
columns = 4
for y in range(50, 500, 150):
for x in range(50, 850, 150):
enemy = Enemy(x,y,wave,picture,columns)
enemies.append(enemy)
def make_enemies(self):
laser = sprite.groupcollide(self.bullets, self.mysteryGroup, True,
True)
if laser:
for value in mysterydict.values():
for currentSprite in value:
currentSprite.mysteryEntered.stop()
self.sounds['mysterykilled'].play()
score = self.calculate_score(currentSprite.row)
explosion = Explosion(currentSprite.rect.x,
currentSprite.rect.y,
currentSprite.row, False, True,
score, self)
self.explosionsGroup.add(explosion)
self.allSprites.remove(currentSprite)
self.laserGroup.remove(currentSprite)
newShip = Highlaser(game, self.player.rect.x,
self.player.rect.x)
self.allSprites.add(newShip)
self.laserGroup.add(newShip)
break
print self.boss
if self.boss % 2 == 1:
self.mobs_shape = 'BOSS'
enemies = EnemiesGroup(10, 5, 'BOSS')
for row in range(5):
for column in range(10):
enemy = Enemy(row, column, self)
enemy.rect.x = 157 + (column * 1)
enemy.rect.y = self.enemyPosition + (row * 1)
enemies.add(enemy)
else:
mobs_grp_choice = randint(0, 1)
if mobs_grp_choice == 0:
self.mobs_shape = 'EXPLODED'
enemies = EnemiesGroup(10, 5, 'EXPLODED')
for row in range(5):
for column in range(10):
enemy = Enemy(row, column, self)
enemy.rect.x = randint(0, 750)
enemy.rect.y = randint(100, 400)
enemies.add(enemy)
else:
self.mobs_shape = 'GROUP'
enemies = EnemiesGroup(10, 5, 'GROUP')
for row in range(5):
for column in range(10):
enemy = Enemy(row, column, self)
enemy.rect.x = 157 + (column * 50)
enemy.rect.y = self.enemyPosition + (row * 45)
enemies.add(enemy)
self.enemies = enemies
self.allSprites = sprite.Group(self.player, self.enemies,
self.livesGroup, self.mysteryShip,
self.highlaser)
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 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 __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 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 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 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 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 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 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 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 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 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 SpawnEnemy(self):
choose = random.randint(self.enemySpawnRange[0],
self.enemySpawnRange[1])
newObject = Enemy(choose)
x = random.randint(20, 750)
newObject.SetPosition([x, -20])
self.enemyList.append(newObject)
def create_level(n):
global level
for i in range(n):
enemy = Enemy()
actors.append(enemy)
enemies.append(enemy)
level += 1
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 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 __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 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 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 use(self,target):
while True:
victim = Enemy(randomSpecies(target.level))
if victim.level < target.level:
print("You captivated a",victim.name)
key = input("Give your servant a name: ")
victim.name = key+" ("+victim.name+")"
break
target.servant[key] = victim
def MakeEnemies(self, file_path):
# Read JSON data
# Make enemy from each section of json data
# Add each enemy to self.Enemies
with open(file_path) as data_file:
data = json.load(data_file)
for enemy in data:
an_enemy = Enemy.Enemy(self, data, enemy)
self.enemies.append(an_enemy)
def __init__(self, file_name, image_name, screen_res):
""" Param: file_name is a string containing the name of
the Flare text file with the map data"""
parsed = loadMap(
file_name
) # returns map containing header data, tileset data, and layer data
self.header_data = parsed[
'header'] # keys: width , height, tilewidth, tileheight, background_color
self.tile_sets_data = parsed[
'tileset'] # fname,tile_width,tile_height,gap_x,gap_y
self.layer_data = parsed[
'layers'] # array of multidimensional arrays for layer data
self.currentScene = None # contains a list of active sprites
self.totalMapWidth = self.header_data['width'] * self.header_data[
'tilewidth']
self.totalMapHeight = self.header_data['height'] * self.header_data[
'tileheight']
self.sprite_sheet = pygame.image.load(image_name)
self.tiles_wide = self.sprite_sheet.get_width(
) // self.header_data['tilewidth']
self.tiles_high = self.sprite_sheet.get_height(
) // self.header_data['tileheight']
r, g, b, a = tuple(
self.header_data['background_color']
) if 'background_color' in self.header_data.keys() else (0, 0, 0, 255)
self.bg_color = pygame.Color(r, g, b, a)
self.boundary = pygame.Rect(0, 0, self.totalMapWidth,
self.totalMapHeight)
tilewidth = self.header_data['tilewidth']
tileheight = self.header_data['tileheight']
gap_x = self.tile_sets_data[3]
gap_y = self.tile_sets_data[4]
self.enemy_list = pygame.sprite.Group()
for i in range(len(self.layer_data)):
layer = self.layer_data[i]
for y in range(len(layer)):
col = layer[y]
for x in range(len(col)):
tilecode = col[x]
if tilecode in ENEMY_SPRITES:
source_x = (tilecode) % self.tiles_wide
source_y = (tilecode) // self.tiles_wide
top_x = (source_x * tilewidth + source_x * gap_x)
top_y = source_y * tileheight + source_y * gap_y
enemyImage = pygame.Surface((tilewidth, tileheight))
enemyImage.blit(
self.sprite_sheet, (0, 0),
pygame.Rect(top_x, top_y, tilewidth, tileheight))
enemyImage.set_colorkey(self.bg_color)
enemy = Enemy(enemyImage)
enemy.placeEnemy((x * tilewidth + enemy.rect.w / 2),
(y * tileheight + enemy.rect.h / 2))
self.layer_data[i][y][x] = 0
self.enemy_list.add(enemy)
def init_objects(self):
self.player1 = Player.Player(self._display_surf)
self.playerSprites = pg.sprite.RenderPlain(self.player1)
self.missile = Missile.Missile(self._display_surf)
self.missileSprites = pg.sprite.RenderPlain(self.missile)
self.enemy= Enemy.Enemy(self._display_surf)
self.enemySprites = pg.sprite.RenderPlain(self.enemy)
