def enter():
global slime
slime = Slime()
game_world.add_object(slime, 1)
global grass
grass = Grass()
game_world.add_object(grass, 0)
global blocks
blocks = [BLOCK() for i in range(100)]
for i in range(8):
blocks[i].pos(check[i])
game_world.add_objects(blocks, 1)
global g_blocks
g_blocks = [G_BLOCK() for i in range(100)]
for i in range(5):
g_blocks[i].pos(check2[i])
game_world.add_objects(g_blocks, 1)
global b_blocks
b_blocks = [B_BLOCK() for i in range(100)]
for i in range(5):
b_blocks[i].pos(check3[i])
game_world.add_objects(b_blocks, 1)
global background
background = Background()
game_world.add_object(background, 0)
def __init__(self, screen_height, screen_width):
super().__init__(screen_height, screen_width)
self.background = pygame.image.load('Images/bg.jpg')
self.platforms.empty()
self.enemys.empty()
self.level_limit = -700
self.dino_gun = True
half_screen_width = self.screen_width // 2
level_platforms = [
[
pygame.Rect(0, self.screen_height - 40,
half_screen_width - 200, 40), (0, 0, 0), 0, -0.099
], # 1st ground
[
pygame.Rect(0, self.screen_height - 300,
(self.screen_width // 2) - 200, 40), (0, 0, 0), 0,
-0.099
], # special area
[
pygame.Rect((self.screen_width // 2) + 200,
self.screen_height - 40, 1800, 40), (0, 0, 0), 0,
-0.099
], # ground 2
[
pygame.Rect(self.screen_width // 2 - 150,
self.screen_height // 2 + 150, 100, 30), (0, 0, 0),
0, -0.12
], # stair 1
[
pygame.Rect(self.screen_width // 2 - 60,
self.screen_height // 2 + 100, 100, 30), (0, 0, 0),
0, -0.12
], # stair 2
[
pygame.Rect(self.screen_width // 2 + 50,
self.screen_height // 2 + 50, 100, 30), (0, 0, 0),
0, -0.12
] # stair 3
]
for platform in level_platforms:
self.platforms.add(Platform.from_list(platform))
self.enemys.add(
Slime(700, 441, VEC(3, 0), pygame.Rect(600, 400, 200, 40)))
self.enemys.add(
Slime(20, 181, VEC(3, 0),
pygame.Rect(0, screen_height - 400, 200, 40)))
def loadEntities(self):
startingPoint = (100, 0, 10)
self.AIworld = AIWorld(render)
self.collision = Collision(Monster.monster)
#terrain, initialPos, slimeModelPath, floorPos, scale, lifePoint, volumicMass, movingSpeed, dt
self.slime = Slime(self.terrain, startingPoint, "assets/models/slime.egg", 10, 10, 100, 0.01, 5, self.dt, "slime", self.collision)
self.spawn = Spawn([self.slime]+Monster.monster, self.terrain, self.AIworld, self.collision)
self.spawn.spawn()
def stage_three(self) -> None:
"""
Sets up stage two
:return: none
"""
# transition
self.transition = arcade.load_texture("images/level_3_screen.png")
# setting up player
self.player = Player(50, 50)
# setting up enemies
self.enemies_engine = []
self.towers_engine = []
self.enemies = Sprites()
self.towers = Sprites()
self.obstacles = arcade.SpriteList()
self.enemies.append(Slime(750, 700))
self.enemies.append(Executioner(750, 700, 10))
self.enemies.append(Slime(750, 100))
self.enemies.append(Executioner(750, 100, 10))
self.enemies.append(Slime(80, 700))
self.enemies.append(Executioner(80, 700, 10))
self.enemies.append(Executioner(400, 400, 20))
for enemy in self.enemies:
self.enemies_engine.append(
CollisionDetection(enemy, self.obstacles))
# self.towers.append(WizardTower(400, 300, 48, 52))
# self.towers.append(WizardTower(400, 500, 48, 52))
self.towers.append(Mage(300, 400, 48, 52))
self.towers.append(Mage(500, 400, 48, 52))
for tower in self.towers:
self.towers_engine.append(
CollisionDetection(tower.fireball, self.rooms[self.world].wall_list))
self.enemies.append(tower.fireball)
for item in self.rooms[self.world].wall_list:
self.obstacles.append(item)
for item in self.rooms[self.world].traps_list:
self.obstacles.append(item)
# create engines
self.player_engine = CollisionDetection(self.player, self.rooms[self.world].wall_list,
self.rooms[self.world].traps_list)
def create_enemies(self) -> None:
"""
temporary testing function that creates enemies
:return:
"""
for x in range(10):
self.enemies.append(
Slime(self.WINDOW_WIDTH, self.WINDOW_HEIGHT,
random.randint(75, 150)))
for enemy in self.enemies:
self.character_list.append(enemy)
def run_game():
# Initialize pygame, settings and create screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Meandering Muck - Level " +
str(ai_settings.level))
# Make a Slime.
slime = Slime(ai_settings, screen)
# Start main loop for the game.
while True:
if ai_settings.gamedone:
ai_settings.gamedone = False
ai_settings.level += 1
pygame.display.set_caption("Meandering Muck - Level " +
str(ai_settings.level))
ai_settings.loadnewsettings()
slime = None
slime = Slime(ai_settings, screen)
gf.check_events(slime)
slime.update()
gf.update_screen(ai_settings, screen, slime)
# Make the most recently drawn screen visible.
pygame.display.flip()
def room_tutorial(self) -> None:
"""
loads room tutorial
:return: none
"""
# setting up player
self.player = Player(50, 50)
# setting up enemies
self.enemies_engine = []
self.towers_engine = []
self.enemies = Sprites()
self.towers = Sprites()
self.obstacles = arcade.SpriteList()
self.enemies.append(Slime(750, 750))
self.enemies.append(Slime(750, 50))
self.enemies.append(Slime(50, 750))
self.enemies.append(Executioner(750, 750, 3))
self.enemies.append(Executioner(750, 50, 3))
self.enemies.append(Executioner(50, 750, 3))
self.enemies.append(Slime(400, 400))
self.enemies.append(Executioner(400, 400, 3))
for enemy in self.enemies:
self.enemies_engine.append(
CollisionDetection(enemy, self.obstacles))
self.towers.append(Mage(400, 400, 48, 52))
for tower in self.towers:
self.towers_engine.append(
CollisionDetection(tower.fireball, self.rooms[self.world].wall_list))
self.enemies.append(tower.fireball)
for item in self.rooms[self.world].wall_list:
self.obstacles.append(item)
for item in self.rooms[self.world].traps_list:
self.obstacles.append(item)
# create engines
self.player_engine = CollisionDetection(self.player, self.rooms[self.world].wall_list,
self.rooms[self.world].traps_list)
def Faz_mapa(self,window,canvas):
self.window = window
self.canvas = canvas
self.map = TileMap(self.fase)
player.rect.x,player.rect.y = self.map.start_x,self.map.start_y
for pos in self.map.inimigos[0]:
self.enemy_Array.append(Slime(pos.x,pos.y))
for pos in self.map.inimigos[1]:
self.enemy_Array.append(mago(pos.x,pos.y))
pygame.mixer.init()
pygame.mixer.music.load(os.path.join('Assets','MusicaDungeon.ogg'))
pygame.mixer.music.play()
def _initialize_sprites(self, level_map):
"""A method which initializes the level, creates all objects necessary for the game to run
Args:
level_map: the layout of the level in a two dimensional list [y][x]
"""
height = len(level_map)
width = len(level_map[0])
for pos_y in range(height):
for pos_x in range(width):
cell = level_map[pos_y][pos_x]
normalized_x = pos_x * self.cell_size
normalized_y = pos_y * self.cell_size
if cell == 0:
self.floors.add(Floor(normalized_x, normalized_y))
elif cell == 1:
self.walls.add(Wall(normalized_x, normalized_y))
elif cell == 2:
self.player = Player(pos_x, pos_y, normalized_x,
normalized_y)
self.floors.add(Floor(normalized_x, normalized_y))
self.level_map[pos_y][pos_x] = self.player
elif cell == 3:
self.stairs = Stairs(normalized_x, normalized_y)
elif cell == 4:
enemy = Slime(pos_x, pos_y, normalized_x, normalized_y)
self.enemies.add(enemy)
self.floors.add(Floor(normalized_x, normalized_y))
self.level_map[pos_y][pos_x] = enemy
elif cell == 5:
enemy = Ranger(pos_x, pos_y, normalized_x, normalized_y)
self.enemies.add(enemy)
self.floors.add(Floor(normalized_x, normalized_y))
self.level_map[pos_y][pos_x] = enemy
elif cell == 6:
item = Item(pos_x, pos_y, normalized_x, normalized_y)
self.floors.add(Floor(normalized_x, normalized_y))
self.objects.add(item)
self.level_map[pos_y][pos_x] = item
self.all_sprites.add(self.walls, self.floors, self.stairs,
self.objects, self.enemies, self.player)
self.refresh_enemy_queue()
self.setup_camera()
elif configuration["auth_type"] == 'disabled':
return True
else:
return False
################################################################################
# Startup Here
################################################################################
with open('./pleasance.json') as configuration_file:
configuration = json.load(configuration_file)
if configuration["auth_type"] == "LDAP":
slime_session = Slime(
configuration["auth_options"]["ldap_url"],
configuration["auth_options"]["ldap_bind_dn_pattern"])
if configuration["storage_type"] == 'MongoDB':
pleasance = PleasanceMongo(configuration["storage_options"]["hostname"],
configuration["storage_options"]["port"])
elif configuration["storage_type"] == 'shelve':
pleasance = PleasanceShelf(
configuration["storage_options"]["package_path"],
configuration["storage_options"]["configuration_path"])
else:
raise Exception
if __name__ == "__main__":
app.run()
def __init__(
self, roomnumber, floorNumber
): #FIXME: les couleurs dans design niveaux ne sont pas homogenes.
self.floorNumber = floorNumber
if floorNumber == 1: #python doesn't have switch statements smh
floordesignPath = 'design niveaux/lvl1.png'
elif floorNumber == 2:
floordesignPath = 'design niveaux/lvl2.png'
elif floorNumber == 3:
floordesignPath = 'design niveaux/lvl3.png'
elif floorNumber == 4:
floordesignPath = 'design niveaux/lvl4.png'
elif floorNumber == 5:
floordesignPath = 'design niveaux/lvl5.png'
elif floorNumber == 6:
floordesignPath = 'design niveaux/salle du boss.png'
floordesign = pygame.image.load(floordesignPath)
self.roomnumber = roomnumber
self.roomBlocks = []
for y in range(9):
for x in range(16):
color = floordesign.get_at((x + (roomnumber * 16), y))
# print("x = " + str(x+ (roomnumber*16)) + "; y = " + str(y) + "; color = " + str(color))
if color == (0, 0, 0, 255): # wall
self.roomBlocks.append(Wall((x, y)))
elif color == (88, 88, 88, 255): # spike
if floordesign.get_at(
(x + (roomnumber * 16), y + 1)) == (0, 0, 0, 255):
self.roomBlocks.append(Spike((x, y)))
elif floordesign.get_at(
(x + (roomnumber * 16) + 1, y)) == (0, 0, 0, 255):
self.roomBlocks.append(Spike((x, y), 1))
elif floordesign.get_at(
(x + (roomnumber * 16) - 1, y)) == (0, 0, 0, 255):
self.roomBlocks.append(Spike((x, y), 3))
elif floordesign.get_at(
(x + (roomnumber * 16), y - 1)) == (0, 0, 0, 255):
self.roomBlocks.append(Spike((x, y), 2))
else:
self.roomBlocks.append(Spike((x, y)))
elif color == (18, 189, 99, 255):
self.roomBlocks.append(Coin((x, y)))
elif color == (189, 18, 18, 255):
#enemy
if floordesign.get_at(
(x + (roomnumber * 16), y + 1)) == (0, 0, 0, 255):
if floorNumber == 1:
self.roomBlocks.append(Slime((x, y)))
elif floorNumber == 2:
self.roomBlocks.append(Slime2((x, y)))
elif floorNumber == 3:
self.roomBlocks.append(Slime3((x, y)))
elif floorNumber == 4:
self.roomBlocks.append(Slime4((x, y)))
elif floorNumber == 5:
self.roomBlocks.append(Slime5((x, y)))
else:
# bat
if floorNumber == 1:
self.roomBlocks.append(Bat((x, y)))
elif floorNumber == 2:
self.roomBlocks.append(Bat2((x, y)))
elif floorNumber == 3:
self.roomBlocks.append(Bat3((x, y)))
elif floorNumber == 4:
self.roomBlocks.append(Bat4((x, y)))
elif floorNumber == 5:
self.roomBlocks.append(Bat5((x, y)))
elif color == (23, 18, 189, 255):
#spring
self.roomBlocks.append(Spring((x, y)))
elif color == (215, 223, 1, 255):
self.roomBlocks.append(SpawnPoint((x, y)))
elif color == (230, 89, 1, 255):
self.roomBlocks.append(Button((x, y)))
elif color == (168, 7, 125, 255):
self.roomBlocks.append(PNJ((x, y)))
elif color == (9, 199, 254):
self.roomBlocks.append(Table((x, y)))
elif color == (124, 48, 201):
self.roomBlocks.append(Boss((x, y)))