def __init__(self, player):
self.player = player
self.rooms = {
'start room':
FirstRoom(entities.Enemy("Pickpocket", 14, 3), 'thief band'),
'thief band':
ThiefBand(entities.Enemy("Bandit Leader", 20, 4), 'dungeon'),
'dungeon':
Dungeon(entities.Enemy("Dragon", 30, 5), 'end'),
'death':
Death()
}
def start(self):
self.hud = loading.Loading(my.ENGINE.screen)
self.map = map.Map(self.width, self.height, self.seed)
self.map.generate()
self.hud.setStatus('Carregando entidades...', 80)
spawnX = randint(50, self.width - 50)
self.player = entities.Player(self, self.playerConfigurations[0],
tank.TankDefault(),
(spawnX, self.map.getMaxHeight(spawnX)))
self.entities = camera.CameraAwareLayeredUpdates(
self.player, pygame.Rect(0, 0, self.width, self.height))
self.entities.add(
self.map
) # Adicionando o mapa em entidades para poder ser scrollado
for i in range(0, self.enemiesCount):
x = randint(50, self.width - 50)
self.entities.add(
entities.Enemy(self, tank.TankDefault(),
(x, self.map.getMaxHeight(x))))
self.hud.setStatus('Carregando interface...', 99)
self.hud = hud.Hud(self, my.ENGINE.screen)
my.ENGINE.interface = self.hud
self.turncontroller = turn.TurnController(self)
self.turncontroller.start()
self.wind = wind.Wind(self)
self.running = True
def append_enemies(smart_enemies, trainable_enemy_exists):
trainable = False
if random.random() < 0.5 and len(smart_enemies) < max_enemies:
e = entities.Enemy((0, 0))
# first enemy is trainable or there is no trainable agent
if not trainable_enemy_exists:
trainable = True
# print("ADD NEW ENEMY trainable_enemy_exists= {}".format(trainable_enemy_exists))
smart_enemies.append(eBrain(e, trainable))
return trainable or trainable_enemy_exists
def load(self, mapa):
try:
for item in self.walls:
item.tile_.remove_node()
for item in self.doors:
item.tile_.remove_node()
for item in self.empty:
item.tile_.remove_node()
for item in self.enemies:
item.tile_.remove_node()
self.walls.clear()
self.doors.clear()
self.empty.clear()
self.enemies.clear()
self.start.tile_.remove_node()
self.end.remove_node()
self.player.tile_.remove_node()
self.start = None
self.end = None
self.player = None
except AttributeError:
pass
mapa = Level(mapa)
y = 0
for line in mapa.board:
x = 0
for _tile in line:
if _tile == "*":
tile_ = tiles.Wall(x, y)
self.walls.append(tile_)
if _tile == " ":
tile_ = tiles.Empty(x, y)
self.empty.append(tile_)
if _tile == "%":
tile_ = tiles.Door(x, y, 2)
self.doors.append(tile_)
if _tile == "X":
self.end = Entity(model='cube', color=color.green, position=(x, -y, 0), scale=(1,1,1))
if _tile == "P":
self.start = tiles.Start(x, y)
if _tile == "@":
enemy = entities.Enemy(x, y)
self.enemies.append(enemy)
tile_ = tiles.Empty(x, y)
self.empty.append(tile_)
x+=1
y+=1
self.player = entities.Player(self.start.x, self.start.y)
def create_entity_dict():
"""
create dictionary of entities
:return: dictionary of entities
"""
player = entities.Player()
enemies = []
x_cord = -200
y_cord = 200
for i in range(24):
enemies.append(entities.Enemy(x_cord, y_cord))
x_cord += 75
if x_cord > 200:
x_cord = -200
y_cord -= 50
return {'player': player, 'enemies': enemies}
def spawn_enemies(settings):
if not settings.enemy_sprites:
[entities.Enemy(settings) for i in range(0, random.randint(5, 15))]
if pygame.key.get_pressed()[32] == 1:
if p_reload == 0:
new_bullet = Ent.Projectile(screen, b_colour, gun_point, b_size, p_point, pygame.mouse.get_pos(),
b_speed, bullet_count_max)
bullet_list[new_bullet.count] = new_bullet
p_reload = b_rate
for ii in range(len(bullet_list)):
if bullet_list[ii] != []:
bullet_list[ii].draw_projectile()
bullet_list[ii].update_projectiles()
for ii in range(len(enemy_list)):
if enemy_list[ii] == [] and random.random() < 0.01:
new_enemy = Ent.Enemy(screen, ii)
enemy_list[ii] = new_enemy
for jj in range(len(bullet_list)):
if enemy_list[ii] != [] and bullet_list[jj] != []:
if Game.dist(bullet_list[jj].point, enemy_list[ii].point, b_size + e_size):
bullet_list[jj] = []
enemy_list[ii] = []
score += 1
if score % 10 == 9:
boss = True
if enemy_list[ii] != []:
if Game.dist(player.point, enemy_list[ii].point, p_size + e_size):
Game_Over = True
break
# Defines the entities variables
ship = entities.Ship(64, (WIDTH // 2), (HEIGHT - 120), 5)
bullets = []
score = 0
# Creates the enemies matrix
enemies = []
nRows, nColumns = 5, 8
enemiesX, enemiesY = 50, 50
enemySize = 40
for i in range(nRows):
row = []
for j in range(nColumns):
# Enemies on the first and second rows have 2 lives
if i <= 1:
row.append(entities.Enemy(64, enemiesX * 2 + (j * enemiesX * 1.5), enemiesY + (i * enemiesY), 1, 2))
# Enemies after the second row have only 1 life
else:
row.append(entities.Enemy(64, enemiesX * 2 + (j * enemiesX * 1.5), enemiesY + (i * enemiesY), 1, 1))
enemies.append(row)
goingRight = True
def gameOver():
# Brief time sleep before showing the game over screen
time.sleep(2)
# Making text 1 "GAME OVER"
font = pygame.font.Font('freesansbold.ttf', 72)
text = font.render('GAME OVER', True, (255, 255, 255))
textRect = text.get_rect()
textRect.center = (WIDTH/2, HEIGHT/2)
import physics
pg.init()
st = settings.Settings()
mc = entities.MainChar(st)
st.objs.append(mc)
platforms = [
entities.Platform(st.plt_image, st.plt_image.get_rect(), i)
for i in st.platforms_rect
]
for platform in platforms:
st.objs.append(platform)
enemy = entities.Enemy(st.en_image, st.en_rect, st.ens_map_rect, st.en_speed,
st.en_jump_speed)
st.objs.append(enemy)
ct = time.time()
tt = 0
while True:
pt = ct # Past Time
ct = time.time() # Current Time
dt = ct - pt # Delta Time
tt += dt # Total Time
events.keyboard_events(st, mc)
# Updating objects and background position/velocity
physics.velocity_restrictions([mc])
events.update_movement([mc, enemy])
# TODO: Handle Boundary and SafeZone surfaces. Patterns?
############
# Main #
############
if __name__ == '__main__':
pg.init()
width, height = 1920, 1080
screen = pg.display.set_mode((width, height))
# This code can be used to initialize a level
player = entities.Player(surf_player, 50, 50, 5)
enemy = entities.Enemy(
surf_enemy, [PatrolPoint(10, 10, 0, 1),
PatrolPoint(110, 10, 0, 1)])
coin = entities.Coin(surf_coin, 600, 100)
bounds = []
# Create boundaries around outer border of map
num_tiles_x = 1920 // 40
num_tiles_y = 1080 // 40
for i in range(num_tiles_x):
for j in range(num_tiles_y):
if i == 0 or i == num_tiles_x - 1 or j == 0 or j == num_tiles_y - 1:
bounds.append(entities.Boundary(surf_boundary, i * 40, j * 40))
group_player = pg.sprite.Group(player)
group_enemies = pg.sprite.Group(enemy)
group_coins = pg.sprite.Group(coin)
#keeps track of the previous room, so that if the player is in a room with enemies,
#but saves in that room, they will spawn in the previous room that has no enemies when entering the game again
previousroom = currentroom
#removes all enemy projectiles in the room
e.entities.clearprojectiles(e.entities)
#make the current room not greyed out on the map
if not currentroom in exploredlist:
exploredlist.append(currentroom)
#if the room has not already been completed, and no enemies have been spawned, spawn enemies
if not roomdict[currentroom].completed and not inencounter:
doorprogress = 0
inencounter = True
for enemy in roomdict[currentroom].enemies:
e.entities.add(e.Enemy(vector(enemy[1])*r.TILESIZE,enemy[0],(0,0),0,0,difficulty,3-len(stages)))
else:
inencounter = False
#if there are no enemies in the room, mark it as completed
if e.entities.enemylist == []:
if not roomdict[currentroom].completed:
roomdict[currentroom].completed = True
inencounter = False
#retract the doors
if not inencounter and dooranimtimer.update():
dooranimtimer.reset()
doorprogress -= 1
else:
if roomdict[currentroom].completed:
e.entities.clearenemies()
#The main game world
import rooms as tile
import entities
import items
#The main game world. All information about everything is stored here. Do not delete
weapon = items.Weapon("stabby", 5, 1)
steve = entities.Enemy("steve", 5, weapon, 2)
fangs = items.Weapon("fangs", 5, 3)
Wolf = entities.Enemy("Wolf", 3, fangs, 2)
baseball_bat = items.Weapon("baseball bat", 5, 2)
Swatter = entities.Enemy("Swatter", 4, baseball_bat, 2)
spiky_pom_poms = items.Weapon("spiky_pom_poms", 5, 3)
Cheerbleeder = entities.Enemy("Cheerbleeder", 4, spiky_pom_poms, 3)
spear = items.Weapon("spear", 5, 3)
Gladiator = entities.Enemy("Gladiator", 5, spear, 5)
broomstick = items.Weapon("broomstick", 5, 1)
Janitor = entities.Enemy("Janitor", 3, broomstick, 1)
beak = items.Weapon("beak", 0, 2)
Rabid_Penguin = entities.Enemy("Rabid Penguin", 2, beak, 5)
contorting_spear = items.Weapon("contorting spear", 8, 6)
Monstrous_Gladiator = entities.Enemy("Monstrous Gladiator", 8, spear, 7)
teeth = items.Weapon("teeth", 5, 3)
Tiger = entities.Enemy("Wolf", 5, teeth, 6)
appendage = items.Weapon("appendage", 100, 7)
Shoggoth = entities.Enemy("Shoggoth", 10, appendage, 8)
plastic_katana = items.Weapon("plastic katana", 1, 0)
Weaboo = entities.Enemy("Weaboo", 2, plastic_katana, 1)
world = [[tile.DoorRoom([]), tile.IceAgeRoom([])], [tile.HistoryRoom([])],
[tile.IceAgeRoom([])], [tile.OtherRoom([])], [tile.Corridor([])]]