def __init__(self, game, name):
self.objects = []
self.topobjects = []
self.toptopobjects = []
self.ennemies = []
self.bonuses = []
self.platforms = []
self.blocks = []
self.camera = Camera(0, 0, game.width, game.height)
self.imageMario = None
self.imageAssets = None
self.imageCloud = None
self.imageBush = None
self.imageSprites = None
self.imageTiles = None
self.state = State()
self.running = True
self.fond = None
self.game = game
self.name = name
self.starttime = datetime.utcnow()
self.timelimit = 100
self.tilemap = []
self.sounds = {}
self.ytile = 0
self.bgcolor = (0, 0, 0)
self.lastkeys = None
self.mario = None
self.levelState = LevelState.RUNNING
self.timeevent = pygame.time.get_ticks()
self.opacityend = 0
def __init__(self, floor_data, parent_game):
self._scenario_ = TileMapLayer(floor_data, mask=get_color_mask())
self._camera_ = Camera(self._scenario_)
self._game_ = parent_game
self._game_objects_ = {}
self._decorations_ = {}
self.block = self._compute_walls_collisions_()
self._spawns_ = self._get_spawns_()
class Renderer:
camera = Camera()
asset_path = "."
def __init__(self,
window_name,
fps=60,
size=(800, 600),
favicon=None,
game_logic: GameLogic = None):
self.running = True
self.size = self.width, self.height = size
self.game_logic = game_logic
self.fps = fps
self.clock = pygame.time.Clock()
pygame.init()
if favicon is not None:
logo = pygame.image.load(favicon)
pygame.display.set_icon(logo)
pygame.display.set_caption(window_name)
self._screen = pygame.display.set_mode(
self.size, pygame.HWSURFACE | pygame.DOUBLEBUF)
@staticmethod
def set_asset_path(path):
Renderer.asset_path = path
print("Asset directory: " + Renderer.asset_path)
def update(self):
dt = self.clock.tick(self.fps) / 1000.0
for event in pygame.event.get():
self.running = self.game_logic.process_input(event, dt)
self.game_logic.process_movement(pygame.key.get_pressed(), self.camera,
dt)
if self.game_logic is not None:
self.game_logic.update(dt)
self.draw()
pygame.display.update()
@staticmethod
def cleanup():
pygame.quit()
def draw(self):
self._screen.fill((255, 255, 255))
for tile in self.game_logic.tiles:
tile.draw(self._screen)
for entity in tile.entities:
entity.draw(self._screen)
def __init__(self):
pg.init()
pg.mixer.init()
self.screen = pg.display.set_mode((WIDTH, HEIGHT))
pg.display.set_caption(TITLE)
self.clock = pg.time.Clock()
self.running = True
self.double_speed = False
self.number_of_levels = 4
self.navigator = Navigator(self)
self.drawer = Drawer(self.screen)
self.creator = Creator()
self.init_player()
self.init_sprite_lists()
self.camera = Camera(self.player, self.creator.shiftable,
self.creator.texts)
self.is_tutorial = False
self.current_level = 0
def __init__(self):
init()
font.init()
display.set_caption(TITLE)
key.set_repeat()
self.playing = False
self.screen = display.set_mode((WIDTH, HEIGHT))
self.clock = time.Clock()
self.dt = self.clock.tick(FPS) / 1000
self.labels = list()
self.infos = list()
self.all_sprites = Group()
self.adventure = Home(self)
self.camera = Camera(self.adventure.map.width, self.adventure.map.height)
self.score = Score("Renato")
self.game_over = False
def main():
game_config_path, evol_config_path, nn_config_path, do_train = args()
game_config = load_config(game_config_path)
evol_config = load_config(evol_config_path)
nn_config = load_config(nn_config_path)
player_position_generator = RandomPlayerPositionGenerator()
game = Game.from_config(game_config, player_position_generator)
example_model = FeedforwardModel.create("test", nn_config["layer_sizes"],
nn_config["activation"],
game_config["team_size"])
#Too lazy to do the math manually
chromosome_length = example_model.get_weights().size
initial_population = UniformFloatPopulationGenerator(
-1, 1, chromosome_length).generate(evol_config["population_size"])
models = create_initial_models(nn_config, initial_population,
game_config["team_size"])
size = (1400, 800)
pygame.init()
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Test")
camera = Camera([0, 0], 35, size)
genetic_alg = create_genetic_algorithm(
evol_config,
random_matches_fitness_generator(3, models, game, 1 / 30.0, screen,
camera))
population, fitness = genetic_alg.run(
initial_population, generation_count_stopping_criterion(10))
best_model = max(list(zip(population, fitness)), key=lambda p: p[1])[0]
best_model.save(f"{best_model.id}.h5")
def launch_game(self):
"""
Launch a new game | Create the map, the camera, the player
"""
# initialize the Flower class which is used for API
for key in var.flowers_dict:
name = var.flowers_dict[key]["name"]
image_path = var.flowers_dict[key]["image_path"]
var.flowers_objects.append(Flower(name, image_path))
# Load the Maps
Map.loader(self)
# Manage the sprites
# Create the sprites groups
self.walls = pygame.sprite.Group()
self.all_sprites = pygame.sprite.Group()
self.warpers = pygame.sprite.Group()
self.pnj = pygame.sprite.Group()
self.water_sources = pygame.sprite.Group()
# Generate the player / walls / warpers
self.maps["worldmap"]["map"].create_map_objects(
"worldmap", True, False)
#########
# DEBUG #
#########
# print(self.walls)
# print(self.all_sprites)
# print(self.warpers)
# for warper in self.warpers:
# print(warper.name)
# Create the camera
# NEEDS TO BE DELETED AND RECREATED AFTER EACH MAP to NEWMAP TELEPORT
self.camera = Camera(self.maps["worldmap"]["rect"].width,
self.maps["worldmap"]["rect"].height)
class Room:
'''Container for all in-game elements'''
def __init__(self, floor_data, parent_game):
self._scenario_ = TileMapLayer(floor_data, mask=get_color_mask())
self._camera_ = Camera(self._scenario_)
self._game_ = parent_game
self._game_objects_ = {}
self._decorations_ = {}
self.block = self._compute_walls_collisions_()
self._spawns_ = self._get_spawns_()
@property
def initial_objects(self):
'''List of all objects defined in the map initially'''
return self._scenario_.objects
@property
def game_objects(self):
'''Map of current-living objects'''
return self._game_objects_
def _compute_walls_collisions_(self):
block = []
for y in range(self._scenario_.map_height):
row = []
for x in range(self._scenario_.map_width):
row.append(self._scenario_.get_cell_at(x, y) in BLOCK_CELLS)
block.append(row)
return block
def _get_spawns_(self):
spawns = {}
for candidate in self._game_objects_.values():
if isinstance(candidate, Spawn):
spawns[candidate.spawn] = candidate.position
return spawns
@property
def camera(self):
'''Room camera'''
return self._camera_
def set_camera_target(self, game_object):
'''Change target of the camera'''
self._camera_.set_target(game_object)
@property
def tilemaps(self):
'''Map layers'''
return self._scenario_
def spawn(self, game_object):
'''Spawn new object at a spawn zone'''
spawn_zone = game_object.spawn if game_object.spawn in self._spawns_ else DEFAULT_SPAWN
self.spawn_at(game_object, self._spawns_[spawn_zone])
def spawn_at(self, game_object, position):
'''Spawn new object at a given position'''
self._game_objects_[game_object.identifier] = game_object
self._game_objects_[game_object.identifier].position = position
self._game_objects_[game_object.identifier].room = self
self._spawns_.update(self._get_spawns_())
def spawn_decoration(self, decoration_id, position):
'''Spawn decoration'''
decoration = game.decoration.new(decoration_id, position)
self._decorations_[decoration.identifier] = decoration
self._decorations_[decoration.identifier].room = self
def kill(self, game_object):
'''Kill an object'''
identifier = game_object if isinstance(game_object,
str) else game_object.identifier
if identifier == self._game_.identifier:
self._game_.player.attribute.update(
self._game_objects_[identifier].attribute)
if identifier in self._game_objects_:
self._game_objects_[identifier].room = None
del self._game_objects_[identifier]
elif identifier in self._decorations_:
self._decorations_[identifier].room = None
del self._decorations_[identifier]
if identifier == self._game_.identifier:
self._game_.end_current_room()
def open_door(self, door_identifier):
'''Open a existing door'''
door_position = self._search_door_(door_identifier)
if not door_position:
return
doors = self._adjacent_doors_(door_position)
for door in doors:
self.kill(door)
self.send_event(('kill_object', door))
def _search_door_(self, door_identifier):
if door_identifier not in self._game_objects_:
return None
y = 0
for row in self.block:
x = 0
for cell in row:
if cell == door_identifier:
return (x, y)
x += 1
y += 1
return None
def _adjacent_doors_(self, location, visited=None):
if not visited:
visited = []
x, y = location
if location in visited:
return []
visited.append((x, y))
if (y not in range(len(self.block))) or (x not in range(
len(self.block[0]))):
return []
identifier = self.block[y][x]
door = self._game_objects_[identifier]
if not isinstance(door, Door):
return []
doors = [door.identifier]
door_tile_id = door.attribute[TILE_ID]
for dir_x, dir_y in _DOOR_DIRECTION_[door_tile_id]:
doors += self._adjacent_doors_((x + dir_x, y + dir_y), visited)
return doors
def update(self):
'''A game loop iteration'''
for game_object in list(self._game_objects_.values()):
game_object.update()
if not game_object.acting:
self.kill(game_object)
if game_object.body:
self.check_collisions_with(game_object)
def render(self):
'''Draw a frame'''
self._camera_.update()
self._scenario_.render(*self._camera_.position)
for game_object in self._game_objects_.values():
game_object.render(*self._camera_.position)
for decoration in list(self._decorations_.values()):
decoration.render(*self._camera_.position)
def check_collisions_with(self, game_object):
'''Compute collisions for all game objects'''
if not game_object.body:
return
for other_game_object in list(self._game_objects_.values()):
if (other_game_object is
game_object) or (not other_game_object.body):
continue
if game_object.body.collides_with(other_game_object):
self.send_event(('collision', game_object.identifier,
other_game_object.identifier))
def send_event(self, event):
'''Send event to orchestrator'''
self._game_.send_event(event)
def main():
size = (1400, 800)
pygame.init()
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Test")
done = False
clock = pygame.time.Clock()
camera = Camera(CAMERA_POS, PIXELS_PER_METER, size)
# field = Field(FIELD_WIDTH, FIELD_LENGTH, GOAL_WIDTH, GOAL_DEPTH)
# outer_field = Field(OUTER_FIELD_WIDTH, OUTER_FIELD_LENGTH, 0, 0)
# ball = Ball(BALL_POS, BALL_RADIUS, BALL_WEIGHT)
# home_goal = Goal([-FIELD_LENGTH/2 - GOAL_DEPTH/2, 0], GOAL_WIDTH, GOAL_DEPTH)
# away_goal = Goal([FIELD_LENGTH/2 + GOAL_DEPTH/2, 0], GOAL_WIDTH, GOAL_DEPTH)
# home_team_players = []
# away_team_players = []
# # random.seed(42)
# for i in range(TEAM_SIZE):
# home_team_players.append(Player(
# [0, 0],
# PLAYER_RADIUS,
# PLAYER_WEIGHT,
# KICK_RADIUS,
# KICK_MAX_MOMENTUM,
# KICK_WAIT_TIME,
# PLAYER_MAX_VELOCITY))
# away_team_players.append(Player(
# [0, 0],
# PLAYER_RADIUS,
# PLAYER_WEIGHT,
# KICK_RADIUS,
# KICK_MAX_MOMENTUM,
# KICK_WAIT_TIME,
# PLAYER_MAX_VELOCITY))
# home_team = Team(home_team_players)
# away_team = Team(away_team_players)
# # ball.velocity = away_team_players[0].position
# game = Game(ball, home_team, away_team, home_goal, away_goal, field, 90, FRICTION)
if len(sys.argv) < 2:
config_path = "configs/game/default.json"
else:
config_path = sys.argv[1]
config = load_config(config_path)
game = Game.from_config(config, RandomPlayerPositionGenerator())
game.reset()
game.init_physics()
# ball.add_velocity(np.array([10, 8]))
while not done and not game.finished:
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
# Game logic should go here
game.update(1 / 30.0)
screen.fill(BLACK)
# Drawing code should go here
game.draw(screen, camera)
fps = int(clock.get_fps())
font = pygame.font.SysFont(pygame.font.get_default_font(), 24)
text_surface = font.render(f"FPS: {fps}", True, (255, 255, 255))
screen.blit(text_surface, (50, 5))
pygame.display.flip()
clock.tick()
pygame.quit()
def __init__(self):
pygame.init()
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.display.set_caption("Vania")
world_size = [4096, 4096]
self.camera = Camera((400, 300), (800, 600), world_size)
pygame.display.set_icon(pygame.image.load('images/icon.png'))
self.screen = pygame.display.set_mode(self.camera.dimensions, 0, 0)
self.fonts = {
"default_12":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 12),
"default_12_bold":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 12),
"default_14":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 14),
"default_14_bold":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 14),
"default_16":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 16),
"default_16_bold":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 16),
"default_32":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 32),
"default_64":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 64),
"julee_128":
pygame.font.Font(os.path.abspath("data/fonts/Julee-Regular.ttf"),
128),
"roboto_14_bold":
pygame.font.Font("data/fonts/Roboto-Bold.ttf", 14)
}
self.fonts["default_12_bold"].set_bold(True)
self.fonts["default_14_bold"].set_bold(True)
self.fonts["default_16_bold"].set_bold(True)
self.background = pygame.Surface(self.camera.dimensions)
self.background.fill(pygame.Color("#c4dbf3"))
grid_square_size = 64
world_filling_number_of_grid_squares = [
int(world_size[0] / grid_square_size),
int(world_size[1] / grid_square_size)
]
self.collision_grid = CollisionGrid(
world_filling_number_of_grid_squares, grid_square_size)
self.moving_sprites_group = pygame.sprite.Group()
self.ui_sprites_group = pygame.sprite.Group()
self.player = Player(self.moving_sprites_group, self.ui_sprites_group,
self.fonts, self.collision_grid, self.camera)
self.player_health_ui = UIPlayerHealthBar(
(20, self.camera.dimensions[1] - 30), self.fonts)
self.tiled_level = TiledLevel(self.collision_grid,
world_filling_number_of_grid_squares,
self.moving_sprites_group,
self.ui_sprites_group)
self.editor = MapEditor(self.tiled_level, self.fonts,
self.collision_grid, self.camera)
self.main_menu = MainMenu(self.fonts, self.camera)
self.is_main_menu = True
self.is_editor = False
self.start_game = False
self.gravity = 800.0
self.clock = pygame.time.Clock()
self.fps_counter = FPSCounter(self.fonts)
self.running = True
class VaniaGame:
"""
An attempt to make a 'Metroidvania' style platform game.
"""
def __init__(self):
pygame.init()
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.display.set_caption("Vania")
world_size = [4096, 4096]
self.camera = Camera((400, 300), (800, 600), world_size)
pygame.display.set_icon(pygame.image.load('images/icon.png'))
self.screen = pygame.display.set_mode(self.camera.dimensions, 0, 0)
self.fonts = {
"default_12":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 12),
"default_12_bold":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 12),
"default_14":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 14),
"default_14_bold":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 14),
"default_16":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 16),
"default_16_bold":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 16),
"default_32":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 32),
"default_64":
pygame.font.Font("data/fonts/Pavanam-Regular.ttf", 64),
"julee_128":
pygame.font.Font(os.path.abspath("data/fonts/Julee-Regular.ttf"),
128),
"roboto_14_bold":
pygame.font.Font("data/fonts/Roboto-Bold.ttf", 14)
}
self.fonts["default_12_bold"].set_bold(True)
self.fonts["default_14_bold"].set_bold(True)
self.fonts["default_16_bold"].set_bold(True)
self.background = pygame.Surface(self.camera.dimensions)
self.background.fill(pygame.Color("#c4dbf3"))
grid_square_size = 64
world_filling_number_of_grid_squares = [
int(world_size[0] / grid_square_size),
int(world_size[1] / grid_square_size)
]
self.collision_grid = CollisionGrid(
world_filling_number_of_grid_squares, grid_square_size)
self.moving_sprites_group = pygame.sprite.Group()
self.ui_sprites_group = pygame.sprite.Group()
self.player = Player(self.moving_sprites_group, self.ui_sprites_group,
self.fonts, self.collision_grid, self.camera)
self.player_health_ui = UIPlayerHealthBar(
(20, self.camera.dimensions[1] - 30), self.fonts)
self.tiled_level = TiledLevel(self.collision_grid,
world_filling_number_of_grid_squares,
self.moving_sprites_group,
self.ui_sprites_group)
self.editor = MapEditor(self.tiled_level, self.fonts,
self.collision_grid, self.camera)
self.main_menu = MainMenu(self.fonts, self.camera)
self.is_main_menu = True
self.is_editor = False
self.start_game = False
self.gravity = 800.0
self.clock = pygame.time.Clock()
self.fps_counter = FPSCounter(self.fonts)
self.running = True
def run(self):
while self.running:
frame_time = self.clock.tick(60)
time_delta = min(0.1, frame_time / 1000.0)
# TODO: make these three states into state classes and use a state machine dictionary to switch between them
if self.is_main_menu:
is_main_menu_and_index = self.main_menu.run(self.screen)
if is_main_menu_and_index[0] == 0:
self.is_main_menu = True
elif is_main_menu_and_index[0] == 1:
self.is_main_menu = False
self.start_game = True
self.camera.reset_camera_tracking()
self.camera.position[0] = 316.0
self.camera.position[1] = 596.0
self.player.respawn()
self.tiled_level.reset_entities()
elif is_main_menu_and_index[0] == 2:
self.is_main_menu = False
self.is_editor = True
elif is_main_menu_and_index[0] == 3:
self.running = False
elif self.is_editor:
self.is_editor = self.editor.run(self.screen, self.background,
time_delta)
if not self.is_editor:
self.is_main_menu = True
else:
for event in pygame.event.get():
if event.type == QUIT:
self.is_main_menu = True
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.is_main_menu = True
self.player.process_events(event)
if self.player.has_exited_level:
self.player.has_exited_level = False
self.is_main_menu = True
self.camera.set_target_position(self.player.world_position)
self.camera.update(time_delta)
self.tiled_level.update(time_delta, self.camera)
self.moving_sprites_group.update(time_delta, self.gravity,
self.camera)
self.collision_grid.update_shape_grid_positions()
self.collision_grid.check_collisions()
self.screen.blit(self.background, (0, 0))
self.tiled_level.draw_back_layers(self.screen)
self.moving_sprites_group.draw(self.screen)
self.tiled_level.draw_front_layers(self.screen)
# draw the collision shapes
# self.tiled_level.draw_collision_shapes(self.screen, self.camera)
# self.player.draw_collision_shapes(self.screen, self.camera)
# for sprite in self.moving_sprites_group:
# if sprite.type == "enemy":
# sprite.draw_debug_info(self.screen, self.camera)
self.player_health_ui.update(self.player)
self.player_health_ui.draw(self.screen)
self.ui_sprites_group.update()
self.ui_sprites_group.draw(self.screen)
self.fps_counter.update(time_delta)
self.fps_counter.draw(self.screen, self.camera)
pygame.display.flip()
class Level:
def __init__(self, game, name):
self.objects = []
self.topobjects = []
self.toptopobjects = []
self.ennemies = []
self.bonuses = []
self.platforms = []
self.blocks = []
self.camera = Camera(0, 0, game.width, game.height)
self.imageMario = None
self.imageAssets = None
self.imageCloud = None
self.imageBush = None
self.imageSprites = None
self.imageTiles = None
self.state = State()
self.running = True
self.fond = None
self.game = game
self.name = name
self.starttime = datetime.utcnow()
self.timelimit = 100
self.tilemap = []
self.sounds = {}
self.ytile = 0
self.bgcolor = (0, 0, 0)
self.lastkeys = None
self.mario = None
self.levelState = LevelState.RUNNING
self.timeevent = pygame.time.get_ticks()
self.opacityend = 0
def playsound(self, key):
self.sounds[key].play()
def initmap(self):
if self.name is not None:
with open('game\\assets\\levels\\{}.csv'.format(self.name),
'rb') as csvfile:
spamreader = csv.reader(csvfile, delimiter=',')
for row in spamreader:
line = []
for i in range(0, len(row)):
if len(row[i]) == 0:
row[i] = '0'
line.append(int(row[i]))
self.tilemap.append(line)
def istileground(self, value):
grounds = [1, 2, 3, 8, 9, 14, 15, 24, 25, 26, 27]
return value in grounds
def istileblock(self, value):
blocks = [8, 9, 10, 11, 14, 24, 25, 26]
return value in blocks
def istilebonus(self, value):
return -100 <= value < 0
def istileennemy(self, value):
return -1000 <= value < -100
def istileasset(self, value):
return value < -1000
def loadimage(self):
print "Loading Level"
self.imageSprites = pygame.image.load(
"game\\assets\\sprites\\sprites.bmp").convert_alpha()
self.imageSprites.set_alpha(120)
self.imageTiles = pygame.image.load(
"game\\assets\\sprites\\tiles.bmp").convert_alpha()
self.surfacetile = pygame.Surface((16, 16))
self.surfacetile.set_colorkey(Color(255, 0, 255, 255), RLEACCEL)
def reset(self):
self.mario.position.x = 32
self.mario.position.y = 300
self.mario.energy = 5
self.camera.rect.x = 0
self.camera.rect.y = 0
self.starttime = datetime.utcnow()
def unloadcontent(self):
print "unload"
del self.objects[:]
del self.topobjects[:]
del self.toptopobjects[:]
del self.ennemies[:]
del self.blocks[:]
del self.bonuses[:]
del self.platforms[:]
del self.tilemap[:]
self.sounds.clear()
def end(self):
self.running = False
self.unloadcontent()
def start(self, mario):
print "start"
self.mario = mario
self.mario.position.left = 32
self.mario.position.top = 300
self.initmap()
self.loadimage()
self.loadcontent()
self.starttime = datetime.utcnow()
self.running = True
def loadcontent(self):
print "Load"
self.loadtilemap()
self.sounds['yellowcoin'] = pygame.mixer.Sound(
"game\\assets\\sounds\\coin.wav")
self.sounds['dragoncoin'] = pygame.mixer.Sound(
"game\\assets\\sounds\\smw_dragon_coin.wav")
self.sounds['turtle'] = pygame.mixer.Sound(
"game\\assets\\sounds\\smw_stomp.wav")
self.sounds['mariojump'] = pygame.mixer.Sound(
"game\\assets\\sounds\\smw_jump.wav")
self.sounds['cough'] = pygame.mixer.Sound(
"game\\assets\\sounds\\cough.wav")
self.sounds['block'] = pygame.mixer.Sound(
"game\\assets\\sounds\\smw_block.wav")
self.sounds['mushroom'] = pygame.mixer.Sound(
"game\\assets\\sounds\\smw_mushroom.wav")
self.sounds['level-complete'] = pygame.mixer.Sound(
"game\\assets\\sounds\\level-complete.wav")
self.sounds['level-complete-low'] = pygame.mixer.Sound(
"game\\assets\\sounds\\level-complete-low.wav")
def loadtilemap(self):
f = Factory()
for row in range(len(self.tilemap)):
for column in range(len(self.tilemap[0])):
position = pygame.Rect(column * TILESIZE, row * TILESIZE,
TILESIZE, TILESIZE)
value = self.tilemap[row][column]
if self.istileground(value):
self.platforms.append(Plateform(position, value))
if self.istileblock(value):
self.blocks.append(position)
if self.istilebonus(value):
obj = f.buildobject(self.imageSprites, value, position.x,
position.y)
if obj is not None:
self.objects.append(obj)
self.bonuses.append(obj)
if self.istileennemy(value):
obj = f.buildobject(self.imageSprites, value, position.x,
position.y)
if obj is not None:
self.objects.append(obj)
self.ennemies.append(obj)
if self.istileasset(value):
obj = f.buildobject(self.imageSprites, value, position.x,
position.y)
if obj is not None:
self.objects.append(obj)
if value == -7:
obj = BlockCoin(self.imageSprites, position.x, position.y)
self.objects.append(obj)
self.platforms.append(Plateform(obj.position, 1))
self.bonuses.append(obj)
self.blocks.append(obj.position)
def update(self):
ticks = pygame.time.get_ticks()
if self.levelState == LevelState.TERMINATING:
self.mario.frame = 10
self.opacityend = min(255, self.opacityend + 6)
pygame.mixer.music.stop()
if (ticks - self.timeevent) > 2000:
return Message.TERMINATELEVEL
return
for localevent in event.get():
if localevent.type == pygame.QUIT:
self.running = False
keys = pygame.key.get_pressed()
if keys[K_RETURN] and not self.lastkeys[K_RETURN]:
self.game.showmenu(True)
if keys[K_ESCAPE]:
self.screen = pygame.display.set_mode(
(self.camera.rect.width, self.camera.rect.height))
if keys[K_LALT] and keys[K_RETURN]:
self.screen = pygame.display.set_mode(
(self.camera.rect.width, self.camera.rect.height), FULLSCREEN)
self.lastkeys = keys
for obj in self.objects:
if not obj.isalive and obj.inscreen(self):
obj.isalive = True
for obj in self.topobjects:
if not obj.isalive and obj.inscreen(self):
obj.isalive = True
for obj in self.objects:
if obj.isalive:
obj.update(self)
for obj in self.topobjects:
if obj.isalive:
obj.update(self)
for obj in self.toptopobjects:
if obj.isalive:
obj.update(self)
res = self.mario.update(self)
if res is Message.TERMINATELEVEL:
self.levelState = LevelState.TERMINATING
self.timeevent = pygame.time.get_ticks()
self.updatecamera()
def updatecamera(self):
y = self.mario.position.bottom + self.camera.rect.height / 2
if y < len(self.tilemap) * TILESIZE:
self.camera.setcentery(
max(self.camera.rect.height / 2, self.mario.position.bottom))
if self.mario.position.left >= self.camera.rect.width / 2 and self.mario.position.right < (
len(self.tilemap[0]) +
1) * TILESIZE - self.camera.rect.width / 2:
x = self.mario.position.left
self.camera.setcenterx(x)
def drawtilemap(self, game):
xcam = self.camera.rect.left
ycam = self.camera.rect.top
idxX = xcam / TILESIZE
idxY = ycam / TILESIZE
for row in range(idxY, idxY + self.camera.rect.height / TILESIZE + 1):
if 0 <= row < len(self.tilemap):
for column in range(
idxX, idxX + self.camera.rect.width / TILESIZE + 1):
if column < len(self.tilemap[row]):
value = self.tilemap[row][column]
if value > VOID:
position = pygame.Rect(column * TILESIZE,
row * TILESIZE, TILESIZE,
TILESIZE)
self.surfacetile.blit(
self.imageTiles, (0, 0),
((value - 1) * TILESIZE, self.ytile, TILESIZE,
TILESIZE))
game.screen.blit(self.surfacetile,
position.move(-xcam, -ycam))
def draw(self, game):
if self.running:
self.drawtilemap(game)
for obj in self.objects:
if obj.inscreen(self):
obj.draw(self)
self.mario.draw(self)
for obj in self.topobjects:
if obj.inscreen(self):
obj.draw(self)
self.state.draw(self)
if self.levelState == LevelState.TERMINATING:
rect = pygame.Surface((640, 480), pygame.SRCALPHA, 32)
rect.fill((0, 0, 0, self.opacityend))
screen = pygame.display.get_surface()
screen.blit(rect, (0, 0))
self.mario.draw(self)
for obj in self.toptopobjects:
print type(obj)
obj.draw(self)
pygame.display.flip()
def _update_camera(self):
self.camera = Camera(self.adventure.map.width, self.adventure.map.height)
class Game:
def __init__(self):
init()
font.init()
display.set_caption(TITLE)
key.set_repeat()
self.playing = False
self.screen = display.set_mode((WIDTH, HEIGHT))
self.clock = time.Clock()
self.dt = self.clock.tick(FPS) / 1000
self.labels = list()
self.infos = list()
self.all_sprites = Group()
self.adventure = Home(self)
self.camera = Camera(self.adventure.map.width, self.adventure.map.height)
self.score = Score("Renato")
self.game_over = False
def update_adventure(self, adventure):
self.show_ended_screen()
self.adventure.player.kill()
self.labels = list()
self.infos = list()
self.adventure = adventure
self._update_camera()
self.show_go_screen()
self.score.start_adventure(adventure.level.level_score)
def run(self):
self.playing = True
while self.playing:
self.events()
self.update()
self.draw()
if self.game_over:
break
if self.adventure.finish:
self.show_end_adventure_screen()
break
def update(self):
# update info
self.infos = list()
self.adventure.update()
self.all_sprites.update()
self.camera.update(self.adventure.player)
def draw(self):
if not self.adventure.has_menu:
self.screen.blit(self.adventure.map_image, self.camera.apply_rect(self.adventure.map_rect))
for sprite in self.all_sprites:
self.screen.blit(sprite.image, self.camera.apply(sprite))
for label in self.labels:
self.screen.blit(label.surface, self.camera.apply_rect(label.rect))
for info in self.infos:
self.screen.blit(info.surface, info.rect)
for zombie in self.adventure.zombies:
zombie.draw_health()
display.flip()
def events(self):
events = key_event.get()
if not self.adventure.has_menu:
for event in events:
if event.type == QUIT:
self.__quit__()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.__quit__()
self.adventure.events(events)
def show_start_screen(self):
pass
def show_go_screen(self):
self.update()
start_display = Surface((WIDTH, HEIGHT), SRCALPHA)
for alpha in range(255, 0, -1):
start_display.fill((0, 0, 0, alpha))
self.screen.blit(self.adventure.map_image, self.camera.apply_rect(self.adventure.map_rect))
self.screen.blit(start_display, (0, 0))
display.flip()
time.delay(10)
def show_ended_screen(self):
self.update()
start_display = Surface((WIDTH, HEIGHT), SRCALPHA)
for alpha in range(255):
start_display.fill((0, 0, 0, alpha))
self.screen.blit(self.adventure.map_image, self.camera.apply_rect(self.adventure.map_rect))
self.screen.blit(start_display, (0, 0))
display.flip()
time.delay(10)
def show_game_over_screen(self):
game_over_display = Surface((WIDTH, HEIGHT), SRCALPHA)
game_over_text = Label('Game Over', 'assets/fonts/blocks.ttf', 20, (HEIGHT / 2) - 100, font_size=72)
score_text = Label('For save the score you need finish adventure', 'assets/fonts/future_narrow.ttf', 20,
(HEIGHT / 2) - 120, font_size=24)
return_text = Label('You will return to home', 'assets/fonts/future_narrow.ttf', 20, (HEIGHT / 2) - 160,
font_size=24)
for alpha in range(255):
game_over_display.fill((0, 0, 0, alpha))
self.screen.blit(game_over_display, (0, 0))
self.screen.blit(game_over_text.surface, game_over_text.rect)
self.screen.blit(score_text.surface, score_text.rect)
self.screen.blit(return_text.surface, return_text.rect)
display.flip()
time.delay(10)
def show_end_adventure_screen(self):
end_surface = Surface((WIDTH, HEIGHT), SRCALPHA)
end_text = Label('Good Nice!', 'assets/fonts/blocks.ttf', 20, (HEIGHT / 2) - 100, font_size=72)
score_text = Label(f'Score: {self.score.calculate_score()}', 'assets/fonts/future_narrow.ttf', 20,
(HEIGHT / 2) - 120, font_size=24)
return_text = Label('You will return to home and see you score ranking', 'assets/fonts/future_narrow.ttf', 20,
(HEIGHT / 2) - 160,
font_size=24)
for alpha in range(255):
end_surface.fill((0, 0, 0, alpha))
self.screen.blit(end_surface, (0, 0))
self.screen.blit(end_text.surface, end_text.rect)
self.screen.blit(score_text.surface, score_text.rect)
self.screen.blit(return_text.surface, return_text.rect)
display.flip()
time.delay(10)
def _update_camera(self):
self.camera = Camera(self.adventure.map.width, self.adventure.map.height)
@staticmethod
def __quit__():
quit()
sys.exit()
class Game:
def __init__(self):
pg.init()
pg.mixer.init()
self.screen = pg.display.set_mode((WIDTH, HEIGHT))
pg.display.set_caption(TITLE)
self.clock = pg.time.Clock()
self.running = True
self.double_speed = False
self.number_of_levels = 4
self.navigator = Navigator(self)
self.drawer = Drawer(self.screen)
self.creator = Creator()
self.init_player()
self.init_sprite_lists()
self.camera = Camera(self.player, self.creator.shiftable,
self.creator.texts)
self.is_tutorial = False
self.current_level = 0
def init_sprite_lists(self):
self.all_sprites = self.creator.all_sprites
self.platform_list = self.creator.platforms
self.tile_list = self.creator.tiles
self.enemy_list = self.creator.enemies
self.coin_list = self.creator.coins
self.player.collide_list = self.creator.player_collide_list
self.bullet_list = self.creator.bullets
def init_player(self):
self.player = self.creator.player
self.player.weapon = Weapon(self.creator)
def stop(self):
self.playing = False
self.running = False
def new(self, level):
""" Calls level or final level building and playing loop """
self.current_level = level
if level == self.number_of_levels - 1:
self.creator.build_level_final(self.player)
self.run()
elif 0 <= level < self.number_of_levels - 1:
self.creator.build_level(self.player)
self.run()
else:
return
def run(self):
self.playing = True
while self.playing:
self.clock.tick(FPS)
self.events()
self.update()
if self.playing:
self.draw()
def update(self):
""" Handles screen updates """
if self.player.hp <= 0:
self.player.kill()
self.navigator.show_go_screen()
for coin in pg.sprite.spritecollide(self.player, self.coin_list,
False):
coin.kill()
self.player.money += 30
for enemy in pg.sprite.spritecollide(self.player, self.enemy_list,
False):
if abs(enemy.rect.x - self.player.rect.x) <= self.player.rect.width / 2 \
and self.player.rect.bottom == enemy.rect.bottom:
self.player.receive_damage(1)
if isinstance(enemy, AirEnemy) \
and abs(enemy.rect.x - self.player.rect.x) <= self.player.rect.width / 2 \
and abs(enemy.rect.y - self.player.rect.y) <= self.player.rect.height / 2:
if not self.is_tutorial:
self.player.receive_damage(1)
if isinstance(enemy, SlimeBlock) \
and abs(enemy.rect.x - self.player.rect.x) <= self.player.rect.width / 2 \
and abs(enemy.rect.y - self.player.rect.y) <= self.player.rect.height / 2:
if not self.is_tutorial:
self.player.receive_damage(1)
pg.sprite.groupcollide(self.bullet_list, self.platform_list, True,
False)
pg.sprite.groupcollide(self.bullet_list, self.tile_list, True, False)
collision_dict = pg.sprite.groupcollide(self.bullet_list,
self.enemy_list, True, False)
for bullet in collision_dict:
for enemy in collision_dict[bullet]:
enemy.hp -= bullet.damage
self.all_sprites.update()
self.camera.update()
def events(self):
""" Handles key events """
for event in pg.event.get():
if event.type == pg.QUIT:
pg.quit()
sys.exit()
if event.type == pg.KEYDOWN:
if event.key == pg.K_SPACE:
self.player.fire()
if event.key == pg.K_LEFT:
if self.double_speed:
self.player.go_left_fast()
else:
self.player.go_left()
if event.key == pg.K_RIGHT:
if self.double_speed:
self.player.go_right_fast()
else:
self.player.go_right()
if event.key == pg.K_LSHIFT:
if not self.double_speed:
self.double_speed = True
else:
self.double_speed = False
if event.key == pg.K_UP:
self.player.jump()
if event.type == pg.KEYUP:
if event.key == pg.K_LEFT and self.player.vel_x < 0:
self.player.stop()
if event.key == pg.K_RIGHT and self.player.vel_x > 0:
self.player.stop()
self.all_sprites.update()
if abs((self.creator.right_wall.rect.x -
self.creator.right_wall.rect.width / 2) -
(self.player.rect.x + self.player.rect.width / 2)) <= 25:
if self.is_tutorial:
self.navigator.show_tutorial_done_screen()
else:
if self.current_level < self.number_of_levels - 1:
self.navigator.go_to_store()
elif self.is_boss_level():
if not self.creator.boss.alive():
self.navigator.show_congrats_screen()
def draw_stats_bar(self):
self.drawer.draw_player_stats(self.player)
if self.is_boss_level():
self.drawer.draw_health_bar(
self.creator.boss, 700, 20, 5)
def draw(self):
self.screen.fill(RED)
self.draw_stats_bar()
self.all_sprites.draw(self.screen)
if self.is_tutorial:
self.blit_texts()
pg.display.flip()
def blit_texts(self):
for sf, rect in self.creator.texts:
self.screen.blit(sf, rect.midtop)
def reset(self):
self.player.hp = 15
self.player.money = 0
self.running = True
self.playing = True
pass
def tutorial(self):
self.is_tutorial = True
self.creator.build_tutorial_level(self.player, self.screen)
self.run()
def is_boss_level(self):
if self.is_tutorial:
return False
return self.current_level == self.number_of_levels - 1
def main():
pygame.init()
pygame.key.set_repeat()
x_screen_size = 1024
y_screen_size = 600
screen_data = ScreenData([x_screen_size, 0], [x_screen_size, 184],
[x_screen_size, y_screen_size])
camera = Camera((512, 300), (x_screen_size, y_screen_size),
(16 * 64, 128 * 64))
screen = pygame.display.set_mode(screen_data.screenSize)
pygame.display.set_caption('Maximum Gunishment')
background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill((95, 140, 95))
player_sprites = pygame.sprite.OrderedUpdates()
all_tile_sprites = pygame.sprite.Group()
all_monster_sprites = pygame.sprite.OrderedUpdates()
all_pick_up_sprites = pygame.sprite.Group()
all_explosion_sprites = pygame.sprite.Group()
all_projectile_sprites = pygame.sprite.Group()
fonts = {}
small_font = pygame.font.Font(None, 16)
font = pygame.font.Font("data/BOD_PSTC.TTF", 32)
large_font = pygame.font.Font("data/BOD_PSTC.TTF", 150)
fonts["default_14"] = pygame.font.Font(None, 14)
fonts["default_32"] = pygame.font.Font(None, 32)
fonts["default_16"] = small_font
fonts["bod_pstc_32"] = font
fonts["bod_pstc_150"] = large_font
fps_counter = FPSCounter(fonts)
explosions_sprite_sheet = pygame.image.load(
"images/explosions.png").convert_alpha()
players = []
monsters = []
pick_ups = []
projectiles = []
explosions = []
new_explosions = []
tiled_level = TiledLevel([16, 128], all_monster_sprites, monsters,
screen_data, explosions_sprite_sheet)
tiled_level.load_tiles()
tiled_level.reset_guards()
main_menu = MainMenu(fonts)
editor_hud_rect = pygame.Rect(
0, screen_data.screenSize[1] - screen_data.editorHudDimensions[1],
screen_data.editorHudDimensions[0], screen_data.editorHudDimensions[1])
editor = MapEditor(tiled_level, editor_hud_rect, fonts)
health_bar = HealthBar([50, 25], 100, 16)
pick_up_spawner = PickUpSpawner(pick_ups, all_pick_up_sprites)
player = None
clock = pygame.time.Clock()
time_multiplier = 1.0
running = True
is_main_menu = True
is_editor = False
is_game_over = False
restart_game = False
win_message = ""
spawn_monsters(monsters, all_monster_sprites, screen_data, tiled_level,
explosions_sprite_sheet)
while running:
frame_time = clock.tick(60)
time_delta = frame_time / 1000.0
if is_main_menu:
is_main_menu_and_index = main_menu.run(screen, fonts, screen_data)
if is_main_menu_and_index[0] == 0:
is_main_menu = True
elif is_main_menu_and_index[0] == 1:
is_main_menu = False
elif is_main_menu_and_index[0] == 2:
is_main_menu = False
is_editor = True
elif is_main_menu_and_index[0] == 3:
running = False
if not is_main_menu and not is_editor:
# spawn player
default_scheme = ControlScheme()
player = Player(tiled_level.find_player_start(), tiled_level,
default_scheme, explosions_sprite_sheet)
players.append(player)
elif is_editor:
screen_data.set_editor_active()
running = editor.run(screen, background, all_tile_sprites,
editor_hud_rect, time_delta)
else:
if restart_game:
restart_game = False
# clear all stuff
players[:] = []
monsters[:] = []
pick_ups[:] = []
projectiles[:] = []
explosions[:] = []
new_explosions[:] = []
all_monster_sprites.empty()
all_pick_up_sprites.empty()
is_game_over = False
tiled_level.reset_guards()
default_scheme = ControlScheme()
player = Player(tiled_level.find_player_start(), tiled_level,
default_scheme, explosions_sprite_sheet)
players.append(player)
spawn_monsters(monsters, all_monster_sprites, screen_data,
tiled_level, explosions_sprite_sheet)
elif is_game_over:
pass
else:
pass
if player is not None:
if player.health <= 0 or player.position[1] < 0 < player.health:
if player.health <= 0:
is_game_over = True
win_message = "You have been defeated!"
if player.position[1] < 0 < player.health:
is_game_over = True
win_message = "You are victorious!"
win_message_bg_text_render = large_font.render(
win_message.upper(), True, pygame.Color("#444444"))
win_message_text_render = large_font.render(
win_message.upper(), True, pygame.Color("#FFFFFF"))
win_message_text_render_rect = win_message_text_render.get_rect(
centerx=x_screen_size / 2,
centery=(y_screen_size / 2) - 128)
play_again_text_render = font.render(
"Play Again? Press 'Y' to restart".upper(), True,
pygame.Color("#FFFFFF"))
play_again_bg_text_render = font.render(
"Play Again? Press 'Y' to restart".upper(), True,
pygame.Color("#444444"))
play_again_text_render_rect = play_again_text_render.get_rect(
centerx=x_screen_size / 2, centery=(y_screen_size / 2))
all_projectile_sprites.empty()
all_explosion_sprites.empty()
player_sprites.empty()
# handle UI and inout events
for event in pygame.event.get():
if event.type == QUIT:
running = False
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
running = False
if is_game_over:
if event.key == K_y:
restart_game = True
for player in players:
player.process_event(event)
if player is not None:
health_bar.update(player.health, player.maxHealth)
offset_position = [player.position[0], player.position[1] - 268]
tiled_level.update_offset_position(offset_position,
all_tile_sprites)
for pick_up in pick_ups:
pick_up.update_movement_and_collision(player, time_delta,
tiled_level)
pick_ups[:] = [
pick_up for pick_up in pick_ups if not pick_up.shouldDie
]
for player in players:
player.update_movement_and_collision(time_delta, projectiles,
tiled_level,
new_explosions)
player_sprites = player.update_sprite(player_sprites,
time_delta)
time_multiplier = 1.0
players[:] = [player for player in players if not player.shouldDie]
for monster in monsters:
monster.update_movement_and_collision(time_delta,
time_multiplier, player,
new_explosions,
tiled_level, projectiles,
pick_up_spawner)
monster.update_sprite(time_delta, time_multiplier)
monsters[:] = [
monster for monster in monsters if not monster.shouldDie
]
new_explosions[:] = []
for projectile in projectiles:
projectile.update_movement_and_collision(
tiled_level, tiled_level.collidableTiles, players,
monsters, time_delta, new_explosions, explosions)
all_projectile_sprites = projectile.update_sprite(
all_projectile_sprites)
projectiles[:] = [
projectile for projectile in projectiles
if not projectile.shouldDie
]
for explosion in explosions:
all_explosion_sprites = explosion.update_sprite(
all_explosion_sprites, time_delta, time_multiplier,
tiled_level)
explosions[:] = [
explosion for explosion in explosions
if not explosion.shouldDie
]
screen.blit(background, (0, 0)) # draw the background
all_tile_sprites.draw(screen)
all_pick_up_sprites.draw(screen)
all_monster_sprites.draw(screen)
player_sprites.draw(screen)
all_explosion_sprites.draw(screen)
all_projectile_sprites.draw(screen)
health_bar.draw(screen, small_font)
fps_counter.update(time_delta)
fps_counter.draw(screen, camera)
if is_game_over:
center = (win_message_text_render_rect.centerx,
win_message_text_render_rect.centery)
screen.blit(
win_message_bg_text_render,
win_message_bg_text_render.get_rect(centerx=center[0] - 2,
centery=center[1]))
screen.blit(
win_message_bg_text_render,
win_message_bg_text_render.get_rect(centerx=center[0] + 2,
centery=center[1]))
screen.blit(
win_message_bg_text_render,
win_message_bg_text_render.get_rect(centerx=center[0],
centery=center[1] - 2))
screen.blit(
win_message_bg_text_render,
win_message_bg_text_render.get_rect(centerx=center[0],
centery=center[1] + 2))
screen.blit(win_message_text_render,
win_message_text_render_rect)
center = (play_again_text_render_rect.centerx,
play_again_text_render_rect.centery)
screen.blit(
play_again_bg_text_render,
play_again_bg_text_render.get_rect(centerx=center[0] - 2,
centery=center[1]))
screen.blit(
play_again_bg_text_render,
play_again_bg_text_render.get_rect(centerx=center[0] + 2,
centery=center[1]))
screen.blit(
play_again_bg_text_render,
play_again_bg_text_render.get_rect(centerx=center[0],
centery=center[1] - 2))
screen.blit(
play_again_bg_text_render,
play_again_bg_text_render.get_rect(centerx=center[0],
centery=center[1] + 2))
screen.blit(play_again_text_render,
play_again_text_render_rect)
pygame.display.flip() # flip all our drawn stuff onto the screen
pygame.quit() # exited game loop so quit pygame