def load(self):
with open("savefile", "rb") as f:
loaddata = pickle.load(f)
self.all_sprites = pg.sprite.LayeredUpdates()
self.walls = pg.sprite.Group()
self.mobs = pg.sprite.Group()
self.mobslist = []
self.ghostlist = []
self.bullets = pg.sprite.Group()
self.items = pg.sprite.Group()
self.itemslist = []
self.map = TiledMap(path.join(map_folder, 'Fase1.tmx'))
self.map_img = self.map.make_map()
self.map.rect = self.map_img.get_rect()
self.player = Player(self, loaddata[0][2][0], loaddata[0][2][1])
self.player.health = loaddata[0][0]
self.player.weapon = loaddata[0][1]
for zombie in loaddata[1]:
M = Mob(self, zombie[0], zombie[1])
self.mobslist.append(M)
for ghost in loaddata[3]:
G = Ghost(self, ghost[0], ghost[1])
self.ghostlist.append(G)
for item in loaddata[2]:
I = Item(self, item[0], item[1])
self.itemslist.append(I)
for tile_object in self.map.tmxdata.objects:
if tile_object.name == 'wall':
Obstacle(self, tile_object.x, tile_object.y, tile_object.width,
tile_object.height)
self.camera = Camera(self.map.width, self.map.height)
self.draw_debug = False
self.paused = False
def __init__(self, screen):
self.player = Player()
self.key_maps = {
pygame.K_a: self.player.move_left,
pygame.K_d: self.player.move_right,
pygame.K_SPACE: self.player.jump,
pygame.K_LSHIFT: self.fade,
pygame.K_ESCAPE: self._invert_pause,
pygame.K_q: self.player.swing,
pygame.K_e: self.player.shoot
}
self.tile_map = generate.generate_easy_over_world()
self.entities = [self.player] + populate(get_ground(self.tile_map),
(20, 80), 5, 0, 1)
self._teleporter = Teleporter(TILE_SIZE * 83, 0, 2, 3, 'CAVE')
self.window = Window(screen, WIDTH, HEIGHT)
self._cool_down_bar = CoolDownBar()
self._fade_vignette = pygame.image.load('assets/sprites/vignette.png')
self.player_alive = True
self.death_text = None
self._pause_menu = None
self._paused = False
self._gloom = False
self.fill_color = (119, 171, 255)
self.lights = []
self.boss_fight = False
self.won = False
am.stop_music()
am.play_music('overworld.mp3', volume=0.1, loop=True)
def __init__(self):
self.player = Player()
self.pressed = {}
self.window_resolution = (1280, 720)
self.back_color = (80, 90, 120)
self.red_color = (255, 0, 0)
self.black_color = (165, 42, 42)
pygame.init()
pygame.display.set_caption("PyBoi")
self.window_surface = pygame.display.set_mode(self.window_resolution)
#textures UI
self.ui = Ui(self.player, self.window_surface)
# mise en place des timers
self.clock = pygame.time.Clock()
pygame.time.set_timer(pygame.USEREVENT, 3)
self.stop = 0
self.i = 0
# mise en place font
self.arial_font = pygame.font.SysFont("arial", 30)
def __init__(self, entity: Player, view: 'InGameView'):
super().__init__(entity, view,
(InGameView.PLAYER_SIZE, InGameView.PLAYER_SIZE))
self.color = get_player_color(entity.get_color())
self.tracker = AnimTracker()
self.phase_shift = random.random() * math.pi
self.camera_x = entity.get_x()
self.state = self.STATE_UNINIT
def create_entities(self):
self.entities = [
Ghost((rnd.randint(-200,
0), rnd.randint(0, self.display.HEIGHT // 4))),
Pumpkin((rnd.randint(0, WIDTH), -100))
]
self.player = Player(
(self.display.WIDTH / 2, self.display.HEIGHT - 200),
'player_stand')
def game_turn(self, turns):
""" Plays game turns.
"""
sub_turn = 0
events_map = {
EventType.HIJACKERS_ASSAULT:
(self.game.make_hijackers_assault, 'hijackers_power'),
EventType.PARASITES_ASSAULT:
(self.game.make_parasites_assault, 'parasites_power'),
EventType.REFUGEES_ARRIVAL:
(self.game.make_refugees_arrival, 'refugees_number'),
}
for action in self.actions[self.current_action:]:
self.current_action += 1
code = action.code
message = action.message
player_idx = action.player_id
player = self.players.get(player_idx, None)
if code == Action.LOGIN:
player = Player(message['name'],
password=message.get('password', None))
player.idx = player_idx
self.players[player_idx] = player
self.game.add_player(player)
elif code == Action.MOVE:
self.game.move_train(player, message['train_idx'],
message['speed'], message['line_idx'])
elif code == Action.UPGRADE:
self.game.make_upgrade(player,
posts_idx=message.get('posts', []),
trains_idx=message.get('trains', []))
elif code == Action.TURN:
self.game.tick()
sub_turn += 1
self.current_turn += 1
elif code == Action.EVENT:
event, power_attr = events_map[message['type']]
event(message[power_attr])
elif code == Action.LOGOUT:
self.game.remove_player(player)
else:
log.error('Unknown action code: {}'.format(code))
if sub_turn >= turns:
break
def createCreatureFromParent(cls, parent: Creature, is_player: bool,
override_limit: bool) -> None:
"""Crée une nouvelle créature en fonction du parent pour le split
Args:
parent (Creature): créature parente
is_player (bool): joueur ou ennemi ?
override_limit (bool): si la limite de split doit être prise
en compte ou non
"""
if len(cls.creatures[
parent.creature_id]) < cls.MAX_SPLIT or override_limit:
parent.score //= 2
parent.inertia = 0.25
if is_player:
creature = Player(parent.pos.copy(), parent.name, parent.color,
parent.creature_id)
else:
creature = Enemy(parent.pos.copy(), parent.name, parent.color,
parent.creature_id)
creature.family.extend(parent.family)
parent.family = creature.family
creature.score = parent.score
creature.radius = 1
creature.img = parent.img
creature.speed = parent.speed.copy()
creature.split_speed = 2
cls.creatures[parent.creature_id].append(creature)
def __init__(self, game):
super().__init__(game, game.display.get_size())
self.game.events.register_listener('ENEMY_KILLED', self.increase_score)
self.game.events.register_listener('SWARM_DESTROYED',
self.on_swarm_destroyed)
self.game.events.register_listener('PLAYER_HEALTH_UPDATE',
self.write_health)
self.game.events.register_listener('PLAYER_DESTROYED',
self.on_player_destroyed)
self.background = Stars(self, 250)
self.player = Player(self)
self.player.rect.move_ip(
self.game.display.get_size()[0] / 2 - self.player.rect.width / 2,
self.game.display.get_size()[1] - self.player.rect.height - 20)
self.enemies = Group()
self.projectiles = Group()
self.enemy_projectiles = Group()
self.score = 0
self.game_over = False
self.show_overlay = False
self.font = Font(get_asset_path('dpcomic.ttf'), 32)
self.write_score()
self.write_health()
self.laser_sound = load_sound('laser.ogg')
self.laser_sound.set_volume(0.2)
self.waves = [
Swarm(self, 'waves/1.png'),
Swarm(self, 'waves/2.png'),
Swarm(self, 'waves/3.png'),
Swarm(self, 'waves/4.png'),
Swarm(self, 'waves/5.png'),
Swarm(self, 'waves/6.png'),
Swarm(self, 'waves/7.png'),
]
self.spawn_timer = Timer()
self.current_wave_id = 1
self.current_wave = self.waves.pop(0)
self.current_wave_active = False
self.spawn_swarm(self.current_wave)
self.overlay, _ = load_image('overlay.png',
width=self.game.get_width(),
height=self.game.get_height())
class Game:
def __init__(self):
self.player = Player()
self.gui = GUI()
event = GameEvent.PreInit(self.player, self.gui)
post(event)
self.player, self.gui = event.player, event.GUI
Hamlet = Location('Hamlet')
self.player.init(self.gui, Hamlet)
self.gui.init(self.player)
event = GameEvent.PostInit(self)
post(event)
def reset(cls) -> None:
"""Réinitialise la map"""
cls.start_time = time.time()
cls.game_finished = False
cls.player_infos = {}
cls.all_cells = []
cls.ref_time = -1 * cls.DELTA_T_NEW_CELL
cls.grid = [[[] for y in range(cls.grid_size.y)]
for x in range(cls.grid_size.x)]
cls.creatures = {}
cls.player_id = cls.generateId()
cls.focused_creature_id = cls.player_id
player = Player(Vect2d(cls.size.x / 2, cls.size.y / 2), "Player",
Color.randomColor(), cls.player_id)
cls.creatures[cls.player_id] = [player]
# Création du joueur
cls.bushes = []
for i in range(config.NB_BUSHES):
cls.createBush()
def on_login(self, data: dict):
if self.game is not None or self.player is not None:
raise errors.BadCommand('You are already logged in')
self.check_keys(data, ['name'])
player_name = data['name']
password = data.get('password', None)
player = Player.get(player_name, password=password)
if not player.check_password(password):
raise errors.AccessDenied('Password mismatch')
game_name = data.get('game', 'Game of {}'.format(player_name))
num_players = data.get('num_players', CONFIG.DEFAULT_NUM_PLAYERS)
num_turns = data.get('num_turns', CONFIG.DEFAULT_NUM_TURNS)
game = Game.get(game_name,
num_players=num_players,
num_turns=num_turns)
game.check_state(GameState.INIT, GameState.RUN)
player = game.add_player(player)
self.game = game
self.game_idx = game.game_idx
self.player = player
log.info('Player successfully logged in: {}'.format(player),
game=self.game)
message = self.player.to_json_str()
return Result.OKEY, message
async def test_combat(ctx: Context):
player = Player(227947694797094922, 10, 5, 5, 10, 1, 0)
enemy = Enemy(5, 2, 2, 0, 1, 10, 1, 1)
while enemy.hp > 0 and player.hp > 0:
player.hp -= enemy.strength
await ctx.send(
build_string(
f"Enemy attacks player for {enemy.strength} damage",
f"Enemy HP: {enemy.hp} | Your HP: {player.hp}",
))
reply = await get_response(ctx)
if reply == commands[1]:
break
elif reply == commands[0]:
enemy.hp -= player.strength
await ctx.send(
build_string(
f"Player attacks enemy for {player.strength} damage",
f"Enemy HP: {enemy.hp} | Your HP: {player.hp}",
))
if enemy.hp <= 0 and player.hp > 0:
player.xp += enemy.xp
await ctx.send(
build_string(
"Player wins!",
f"Player gains {enemy.xp} XP, they now have {player.xp}"))
elif enemy.hp > 0 and player.hp <= 0:
await ctx.send(build_string("Player loses!", "):"))
def handle_accept(self):
(sock, addr) = self.accept()
# self.connections.append(sock)
print('Connection by ', addr)
player = Player(str(addr))
self.board.addPlayer(player)
self.HANDLER(sock, player, self.board)
def turn(self, player: Player):
""" Makes next turn.
"""
with self._tick_done_condition:
with self._lock:
player.turn_called = True
all_ready_for_turn = all(
[p.turn_called for p in self.players.values()])
if all_ready_for_turn:
self._start_tick_event.set()
if not self._tick_done_condition.wait(CONFIG.TURN_TIMEOUT):
raise errors.Timeout('Game tick did not happen')
def __init__(self, coins: int, num_of_players: int) -> None:
if not 2 <= num_of_players <= 4:
raise ValueError(
"Number of player should be greater than 1 and less than 4")
self._remaining_coins = coins
self._red_coin_on_board = True
self._num_of_players = num_of_players
self._players_turn: int = 0
self._players: List[Player] = [
Player(name=f'Player {i + 1}') for i in range(num_of_players)
]
def new(self):
# Criando grupos de sprites
self.all_sprites = pg.sprite.Group()
self.walls = pg.sprite.Group()
self.mobs = pg.sprite.Group()
self.mobslist = []
self.ghostlist = []
self.bullets = pg.sprite.Group()
self.items = pg.sprite.Group()
self.itemslist = []
# Usando a biblioteca Pytween para criar um mapa em tiles, usando o editor de mapas
self.map = TiledMap(
path.join(path.join(path.dirname(__file__), 'maps'), 'fase1.tmx'))
self.map_img = self.map.make_map()
self.map.rect = self.map_img.get_rect()
# loop que lê os objetos posicionados no editor de mapas e cria eles
for tile_object in self.map.tmxdata.objects:
obj_center = vec(tile_object.x + tile_object.width / 2,
tile_object.y + tile_object.height / 2)
if tile_object.name == 'player':
self.player = Player(self, obj_center.x, obj_center.y)
if tile_object.name == 'zombie':
M = Mob(self, obj_center.x, obj_center.y)
self.mobslist.append(M)
if tile_object.name == 'ghost':
G = Ghost(self, obj_center.x, obj_center.y)
self.ghostlist.append(G)
if tile_object.name == 'wall':
Obstacle(self, tile_object.x, tile_object.y, tile_object.width,
tile_object.height)
if tile_object.name in ['health', 'shotgun', 'staff']:
I = Item(self, obj_center, tile_object.name)
self.itemslist.append(I)
self.camera = Camera(self.map.width, self.map.height)
self.paused = False
def net_update(data):
if data["op"] == common.OP_ENTITY_MOVE:
if not is_host:
ent = entity.entity_from_id(data["eid"])
if ent is None:
print("added net player 0")
entity.add_net_entity(data["eid"], Player("arnold", (data["x"], data["y"])))
else:
print("updated player")
ent.rect.topleft = data["x"], data["y"]
elif data["op"] == common.OP_ENTITY_VEL:
if not is_host:
entity.entity_from_id(data["eid"]).velocity = util.Vector(data["vx"], data["vy"])
def reset_game(self):
""" Resets the game to initial state.
"""
self._game = Game(self._game_name,
self._map_name,
num_players=self.num_players,
observed=True)
for action in self._actions:
if action['code'] == Action.LOGIN:
data = json.loads(action['message'])
self._game.add_player(Player.create(data['name']))
self._current_turn = 0
self._current_action = 0
def add_player(self, player: Player):
""" Adds player to the game.
"""
# If player is returning to the game:
if player.idx in self.players:
player = self.players[player.idx]
player.in_game = True
return player
# Add new player to the game:
with self._lock:
# Check players count:
if len(self.players) == self.num_players:
raise errors.AccessDenied(
'The maximum number of players reached')
else:
self.players[player.idx] = player
player.in_game = True
# Pick first available Town on the map as player's Town:
player_town = [t for t in self.map.towns
if t.player_idx is None][0]
player_home_point = self.map.points[player_town.point_idx]
player.set_home(player_home_point, player_town)
# Create trains for the player:
start_train_idx = len(self.trains) + 1
for i in range(CONFIG.TRAINS_COUNT):
# Create Train:
train = Train(idx=start_train_idx + i)
# Add Train:
player.add_train(train)
self.map.add_train(train)
self.trains[train.idx] = train
# Put the Train into Town:
self.put_train_into_town(train, with_cooldown=False)
# Start thread with game loop:
if self.num_players == len(
self.players) and self.state == GameState.INIT:
self.start()
# Set player's rating:
self.map.ratings[player.idx] = {
'rating': player.rating,
'name': player.name,
'town': player_town.name,
'idx': player.idx,
}
log.info(
'New player has been connected to the game, player: {}'.format(
player),
game=self)
return player
def setup(self): os.environ['SDL_VIDEO_CENTERED'] = '1' # should make the window pop up centered pygame.init() self.display = pygame.display.set_mode( self.size ) # imports (since they require pygame.init()) from graphics.screen import Screen from input.keyboard import Keyboard from level.level import RandomLevel from entity.player import Player pygame.display.set_caption( self.SCREEN_CAPTION ) self.clock = pygame.time.Clock() self.screen = Screen(self.SCREEN_WIDTH, self.SCREEN_HEIGHT) self.keyboard = Keyboard() self.level = RandomLevel(64, 64) self.player = Player(self.keyboard) self.running = True
"""Set and run simulation"""
from core.constants import PlayerForm
from core.quest import Quest
from entity.player import Player, Team, PlayerConf
from action.skill import Skill, SkillCtx
if __name__ == "__main__":
quest = Quest()
team = Team(quest)
conf = PlayerConf(
adventurer=10230101,
dragon=0,
weapon=0,
wyrmprints=(0, 0, 0, 0, 0, 0, 0),
)
player = Player(quest, team, conf)
# s1 = Skill(107301011, player, level=4, form=PlayerForm.ADV, index=1, context=SkillCtx.OWN)
# player.sp.charge(1, key=PlayerForm.ADV, percent=True)
# s1.cast()
player.tap()
quest.timeline.run(5)
if key == KeyEvent.KEY_UP:
commands.append((JumpCommand(), "execute"))
elif key == KeyEvent.KEY_DOWN:
commands.append((JumpCommand(), "undo"))
return commands
if __name__ == '__main__':
# EventSimulator模拟所有的事件
from event.event_simulator import EventSimulator
from entity.player import Player
event_simulator = EventSimulator()
event_simulator.start_simulate()
key_event = event_simulator.get_key_event()
player = Player()
input_handler = InputHandler()
import time
while True:
key_list = key_event.get_key_list()
print "key_list:", key_list
time.sleep(2)
commands = input_handler.handler_input(key_list)
for command, func in commands:
getattr(command, func)(player)
print player.get_position()
class Game:
def __init__(self):
pg.mixer.pre_init(
44100, -16, 4,
2048) # pre init seta os padrões quando mixer.init for chamado
pg.init() # inicializa o pygame
self.screen = pg.display.set_mode((WIDTH, HEIGHT)) # inicializa a tela
pg.display.set_caption(TITLE) # coloca o titulo na janela inicializada
self.cursor = pg.image.load(path.join(
img_folder, mouse)).convert_alpha() # carrega a imagem do cursor
self.clock = pg.time.Clock() # clock do jogo
self.load_data(
) # função onde carregamos o necessário para o jogo rodar (especialmente sons e tela)
# as três funções draw carregam a interface enquanto o jogo roda
def draw_text(self, text, font_name, size, color, x, y, align="topleft"):
font = pg.font.Font(font_name, size)
text_surface = font.render(text, True, color)
text_rect = text_surface.get_rect(**{align: (x, y)})
self.screen.blit(text_surface, text_rect)
def draw_player_health(self, pct):
if pct < 0:
pct = 0
elif pct == 1:
health = pg.image.load(path.join(img_folder,
'HEARTFULL.png')).convert_alpha()
elif pct == 0.75:
health = pg.image.load(path.join(img_folder,
'HEART3.png')).convert_alpha()
elif pct == 0.50:
health = pg.image.load(path.join(img_folder,
'HEART2.png')).convert_alpha()
elif pct <= 0.25:
health = pg.image.load(path.join(img_folder,
'HEART1.png')).convert_alpha()
self.screen.blit(health, (10, 10))
def draw_gun(self):
weapon = pg.image.load(path.join(
img_folder, self.player.weapon.sprite)).convert_alpha()
self.screen.blit(weapon, (832, 640))
# essa função foi feita para o jogador rodar junto com o mouse e fazer o mouse acompanhar o scroll da tela
def mousepos_worldpos(self, mouse_pos):
cam_pos = self.camera.camera.topleft
return (mouse_pos[0] - cam_pos[0], mouse_pos[1] - cam_pos[1])
def load_data(self):
# carregando a tela
pg.Surface(self.screen.get_size()).convert_alpha().fill(
(0, 0, 0, 180)) # preenche a tela com cor solida
# Carregando os sons
self.volume = 0.1
pg.mixer.music.load(path.join(music_folder, BG_MUSIC))
pg.mixer.music.set_volume(self.volume)
self.effects_sounds = {}
for type in EFFECTS_SOUNDS:
s = pg.mixer.Sound(path.join(snd_folder, EFFECTS_SOUNDS[type]))
s.set_volume(self.volume)
self.effects_sounds[type] = s
self.weapon_sounds = {}
for weapon in WEAPON_SOUNDS:
self.weapon_sounds[weapon] = []
for snd in WEAPON_SOUNDS[weapon]:
s = pg.mixer.Sound(path.join(snd_folder, snd))
s.set_volume(self.volume)
self.weapon_sounds[weapon].append(s)
self.zombie_moan_sounds = []
for snd in ZOMBIE_MOAN_SOUNDS:
s = pg.mixer.Sound(path.join(snd_folder, snd))
s.set_volume(self.volume)
self.zombie_moan_sounds.append(s)
self.player_hit_sounds = []
for snd in PLAYER_HIT_SOUNDS:
s = pg.mixer.Sound(path.join(snd_folder, snd))
s.set_volume(self.volume)
self.player_hit_sounds.append(s)
self.zombie_hit_sounds = []
for snd in ZOMBIE_HIT_SOUNDS:
s = pg.mixer.Sound(path.join(snd_folder, snd))
s.set_volume(self.volume)
self.zombie_hit_sounds.append(s)
# Setup para um novo jogo
def new(self):
# Criando grupos de sprites
self.all_sprites = pg.sprite.Group()
self.walls = pg.sprite.Group()
self.mobs = pg.sprite.Group()
self.mobslist = []
self.ghostlist = []
self.bullets = pg.sprite.Group()
self.items = pg.sprite.Group()
self.itemslist = []
# Usando a biblioteca Pytween para criar um mapa em tiles, usando o editor de mapas
self.map = TiledMap(
path.join(path.join(path.dirname(__file__), 'maps'), 'fase1.tmx'))
self.map_img = self.map.make_map()
self.map.rect = self.map_img.get_rect()
# loop que lê os objetos posicionados no editor de mapas e cria eles
for tile_object in self.map.tmxdata.objects:
obj_center = vec(tile_object.x + tile_object.width / 2,
tile_object.y + tile_object.height / 2)
if tile_object.name == 'player':
self.player = Player(self, obj_center.x, obj_center.y)
if tile_object.name == 'zombie':
M = Mob(self, obj_center.x, obj_center.y)
self.mobslist.append(M)
if tile_object.name == 'ghost':
G = Ghost(self, obj_center.x, obj_center.y)
self.ghostlist.append(G)
if tile_object.name == 'wall':
Obstacle(self, tile_object.x, tile_object.y, tile_object.width,
tile_object.height)
if tile_object.name in ['health', 'shotgun', 'staff']:
I = Item(self, obj_center, tile_object.name)
self.itemslist.append(I)
self.camera = Camera(self.map.width, self.map.height)
self.paused = False
def run(self):
# loop do jogo
self.playing = True
pg.mixer.music.play(loops=-1)
while True:
self.dt = self.clock.tick(
FPS) / 1000 # controla a velocidade do movimento das coisas
self.events()
if not self.paused:
self.update()
self.draw()
if not self.playing:
if len(self.mobs) == 0:
self.show_victoryscreen()
else:
self.show_go_screen()
def quit(self):
pg.quit()
sys.exit()
def update(self):
# update loop
self.all_sprites.update()
self.camera.update(self.player) # centra a câmera no jogador
# checa se é game over
if len(self.mobs) == 0:
self.playing = False
# player colide com um item (o false diz que não é pra fazer o jogador desaparecer)
hits = pg.sprite.spritecollide(
self.player, self.items,
False) # retorna uma lista de items que colidem
for hit in hits:
if hit.type == 'health' and self.player.health < PLAYER_HEALTH:
self.itemslist.remove(hit)
hit.kill()
self.effects_sounds['health_up'].play()
self.player.add_health(HEALTH_PACK_AMOUNT)
if hit.type == 'shotgun':
self.itemslist.remove(hit)
hit.kill()
self.effects_sounds['gun_pickup'].play()
self.player.weapon = Shotgun()
if hit.type == 'staff':
self.itemslist.remove(hit)
hit.kill()
self.effects_sounds['gun_pickup'].play()
self.player.weapon = 'staff'
# mob colide com player. collide_hit_rect é uma função que checa isso, caso contrário deve passar o rect
hits = pg.sprite.spritecollide(self.player, self.mobs, False,
collide_hit_rect)
for hit in hits:
if random() < 0.7:
choice(self.player_hit_sounds).play()
self.player.health -= MOB_DAMAGE
hit.vel = vec(0, 0)
if self.player.health <= 0:
self.playing = False
if hits:
self.player.hit(
) # função que dá invincibility frames após levar um hit
self.player.pos += vec(MOB_KNOCKBACK, 0).rotate(
-hits[0].rot) # essa linha é onde ocorre o knockback
# bala colide com mob
hits = pg.sprite.groupcollide(self.mobs, self.bullets, False, True)
for mob in hits:
for bullet in hits[mob]:
mob.health -= bullet.damage
if mob.health <= 0 and mob in self.mobslist:
self.mobslist.remove(mob)
if mob.health <= 0 and mob in self.ghostlist:
self.ghostlist.remove(mob)
mob.vel = vec(0, 0)
# função que é chamada quando um novo jogo começa
def draw(self):
# titulo da janela
pg.display.set_caption("GUNDALF THE WIZARD {:.2f}".format(
self.clock.get_fps()))
# impede que o mouse use a imagem de cursor fora da tela de jogo rodando
pg.mouse.set_visible(False)
self.screen.blit(self.map_img, self.camera.apply(
self.map)) # alinha a camera no canto correto
self.screen.blit(self.cursor, (pg.mouse.get_pos())) # desenha o cursor
# desenha a barra de vida dos mobs
for sprite in self.all_sprites:
if isinstance(sprite, Mob):
sprite.draw_health()
self.screen.blit(sprite.image, self.camera.apply(sprite))
# interface, usa as funções draw
self.draw_text('Enemies: {}'.format(len(self.mobs)),
path.join(path.join(path.dirname(__file__), 'img'),
'PressStart2P.ttf'),
30,
WHITE,
WIDTH - 10,
10,
align="topright")
self.draw_gun()
self.draw_player_health(self.player.health / PLAYER_HEALTH)
pg.display.flip()
# muda todos os volumes para o valor atual de self.volume
def change_volume(self):
for sound_type in self.weapon_sounds:
self.weapon_sounds[sound_type][0].set_volume(self.volume)
for sound_type in self.effects_sounds:
self.effects_sounds[sound_type].set_volume(self.volume)
for sound_type in self.zombie_moan_sounds:
sound_type.set_volume(self.volume)
for sound_type in self.player_hit_sounds:
sound_type.set_volume(self.volume)
for sound_type in self.zombie_hit_sounds:
sound_type.set_volume(self.volume)
pg.mixer.music.set_volume(self.volume)
# desenha o volume na tela de opções
def draw_volume(self):
if self.volume == 1:
volume = pg.image.load(path.join(img_folder,
'NUMBER100.png')).convert_alpha()
elif 1 > self.volume >= 0.9:
volume = pg.image.load(path.join(img_folder,
'NUMBER90.png')).convert_alpha()
elif 0.9 > self.volume >= 0.8:
volume = pg.image.load(path.join(img_folder,
'NUMBER80.png')).convert_alpha()
elif 0.8 > self.volume >= 0.7:
volume = pg.image.load(path.join(img_folder,
'NUMBER70.png')).convert_alpha()
elif 0.7 > self.volume >= 0.6:
volume = pg.image.load(path.join(img_folder,
'NUMBER60.png')).convert_alpha()
elif 0.6 > self.volume >= 0.5:
volume = pg.image.load(path.join(img_folder,
'NUMBER50.png')).convert_alpha()
elif 0.5 > self.volume >= 0.4:
volume = pg.image.load(path.join(img_folder,
'NUMBER40.png')).convert_alpha()
elif 0.4 > self.volume >= 0.3:
volume = pg.image.load(path.join(img_folder,
'NUMBER30.png')).convert_alpha()
elif 0.3 > self.volume >= 0.2:
volume = pg.image.load(path.join(img_folder,
'NUMBER20.png')).convert_alpha()
elif 0.2 > self.volume >= 0.1:
volume = pg.image.load(path.join(img_folder,
'NUMBER10.png')).convert_alpha()
else:
volume = pg.image.load(path.join(img_folder,
'NUMBER0.png')).convert_alpha()
self.screen.blit(volume, (140, 140))
pg.display.flip()
# loop de eventos dentro do jogo
def events(self):
# eventos
for event in pg.event.get():
# fechar a janela
if event.type == pg.QUIT:
self.quit()
if event.type == pg.KEYDOWN:
# apertar ESC para pausar
if event.key == pg.K_ESCAPE:
self.show_pause_screen()
# aumentar e diminuir o volume dentro de jogo
if event.key == pg.K_EQUALS:
if self.volume >= 1:
self.volume = 1
else:
self.volume += 0.1
self.change_volume()
if event.key == pg.K_MINUS:
if self.volume <= 0:
self.volume = 0
else:
self.volume -= 0.1
self.change_volume()
def save(self):
self.mobspos = []
self.ghostpos = []
self.itemspos = []
for i in range(len(self.mobslist)):
if isinstance(self.mobslist[i], Mob):
self.mobspos.append(self.mobslist[i].pos)
for i in range(len(self.ghostlist)):
if isinstance(self.ghostlist[i], Ghost):
self.ghostpos.append(self.ghostlist[i].pos)
for item in self.itemslist:
self.itemspos.append([item.pos, item.type])
with open("savefile", "wb") as f:
data = [[
self.player.health, self.player.weapon, self.player.rect.center
], self.mobspos, self.itemspos, self.ghostpos]
pickle.dump(data, f)
def load(self):
with open("savefile", "rb") as f:
loaddata = pickle.load(f)
self.all_sprites = pg.sprite.LayeredUpdates()
self.walls = pg.sprite.Group()
self.mobs = pg.sprite.Group()
self.mobslist = []
self.ghostlist = []
self.bullets = pg.sprite.Group()
self.items = pg.sprite.Group()
self.itemslist = []
self.map = TiledMap(path.join(map_folder, 'Fase1.tmx'))
self.map_img = self.map.make_map()
self.map.rect = self.map_img.get_rect()
self.player = Player(self, loaddata[0][2][0], loaddata[0][2][1])
self.player.health = loaddata[0][0]
self.player.weapon = loaddata[0][1]
for zombie in loaddata[1]:
M = Mob(self, zombie[0], zombie[1])
self.mobslist.append(M)
for ghost in loaddata[3]:
G = Ghost(self, ghost[0], ghost[1])
self.ghostlist.append(G)
for item in loaddata[2]:
I = Item(self, item[0], item[1])
self.itemslist.append(I)
for tile_object in self.map.tmxdata.objects:
if tile_object.name == 'wall':
Obstacle(self, tile_object.x, tile_object.y, tile_object.width,
tile_object.height)
self.camera = Camera(self.map.width, self.map.height)
self.draw_debug = False
self.paused = False
def show_pause_screen(self):
self.paused = True
pg.mouse.set_visible(True)
self.current_screen = "Pause"
self.screen.blit(
pg.image.load(path.join(img_folder,
settings.pausescreen)).convert_alpha(),
(0, 0))
self.button_pause_back = pg.Rect(416, 323, 192, 28)
self.button_pause_save = pg.Rect(448, 436, 128, 28)
self.button_pause_quit = pg.Rect(448, 565, 128, 28)
pg.draw.rect(self.screen, (255, 0, 0), self.button_pause_back, -1)
pg.draw.rect(self.screen, (255, 0, 0), self.button_pause_save, -1)
pg.draw.rect(self.screen, (255, 0, 0), self.button_pause_quit, -1)
pg.display.flip()
self.wait_for_key()
def show_start_screen(self):
pg.mouse.set_visible(True)
self.current_screen = "Start Screen"
self.screen.blit(
pg.image.load(path.join(img_folder,
settings.mainscreen)).convert_alpha(),
(0, 0))
self.button_start_start = pg.Rect(68, 204, 220, 30)
self.button_start_option = pg.Rect(64, 340, 190, 35)
self.button_start_load = pg.Rect(68, 465, 125, 30)
self.button_start_quit = pg.Rect(63, 596, 130, 30)
pg.draw.rect(self.screen, (0, 0, 0), self.button_start_start, -1)
pg.draw.rect(self.screen, (0, 0, 0), self.button_start_load, -1)
pg.draw.rect(self.screen, (0, 0, 0), self.button_start_option, -1)
pg.draw.rect(self.screen, (0, 0, 0), self.button_start_quit, -1)
pg.display.flip()
pg.mixer.music.pause()
self.wait_for_key()
def show_victoryscreen(self):
pg.mouse.set_visible(True)
self.current_screen = "victoryscreen"
self.screen.blit(
pg.image.load(path.join(img_folder,
settings.victoryscreen)).convert_alpha(),
(0, 0))
self.button_go_restart = pg.Rect(100, 703, 288, 33)
self.button_go_quit = pg.Rect(640, 706, 192, 28)
pg.draw.rect(self.screen, (255, 0, 0), self.button_go_restart, -1)
pg.draw.rect(self.screen, (255, 0, 0), self.button_go_quit, -1)
pg.display.flip()
self.wait_for_key()
def show_go_screen(self):
pg.mouse.set_visible(True)
self.current_screen = "Game Over Screen"
self.screen.blit(
pg.image.load(path.join(img_folder,
settings.gameoverscreen)).convert_alpha(),
(0, 0))
self.button_go_restart = pg.Rect(156, 666, 289, 32)
self.button_go_quit = pg.Rect(694, 666, 192, 29)
pg.draw.rect(self.screen, (255, 0, 0), self.button_go_restart, -1)
pg.draw.rect(self.screen, (255, 0, 0), self.button_go_quit, -1)
pg.display.flip()
self.wait_for_key()
def options(self):
pg.mouse.set_visible(True)
self.current_screen = "Options Screen"
self.screen.blit(
pg.image.load(path.join(img_folder,
settings.optionscreen)).convert_alpha(),
(0, 0))
self.button_options_return = pg.Rect(336, 480, 385, 57)
self.button_options_volumeup = pg.Rect(744, 80, 40, 72)
self.button_options_volumedown = pg.Rect(272, 80, 40, 72)
pg.draw.rect(self.screen, (0, 0, 0), self.button_options_return, -1)
pg.draw.rect(self.screen, (255, 0, 0), self.button_options_volumeup,
-1)
pg.draw.rect(self.screen, (255, 0, 0), self.button_options_volumedown,
-1)
self.draw_volume()
pg.display.flip()
self.wait_for_key()
def wait_for_key(self):
pg.event.wait()
waiting = True
self.click_test = False
while waiting:
self.clock.tick(FPS)
for event in pg.event.get():
if event.type == pg.QUIT:
waiting = False
self.quit()
if event.type == pg.KEYDOWN:
if event.key == pg.K_ESCAPE and self.current_screen == "Pause":
self.paused = False
self.current_screen = ''
waiting = False
pg.mouse.set_visible(True)
if event.type == pg.MOUSEBUTTONDOWN:
if event.button == 1:
self.click_test = True
mx, my = pg.mouse.get_pos()
if self.click_test:
if self.current_screen == "Pause":
if self.button_pause_back.collidepoint((mx, my)):
self.paused = False
self.current_screen = ''
waiting = False
elif self.button_pause_save.collidepoint((mx, my)):
g.save()
elif self.button_pause_quit.collidepoint((mx, my)):
g.show_start_screen()
elif self.current_screen == "victoryscreen":
if self.button_go_restart.collidepoint((mx, my)):
g.new()
g.run()
elif self.button_go_quit.collidepoint((mx, my)):
g.show_start_screen()
elif self.current_screen == "Game Over Screen":
if self.button_go_restart.collidepoint((mx, my)):
g.new()
g.run()
elif self.button_go_quit.collidepoint((mx, my)):
g.show_start_screen()
elif self.current_screen == "Start Screen":
if self.button_start_start.collidepoint((mx, my)):
g.new()
g.run()
elif self.button_start_option.collidepoint((mx, my)):
g.options()
elif self.button_start_load.collidepoint((mx, my)):
g.load()
g.run()
elif self.button_start_quit.collidepoint((mx, my)):
self.quit()
elif self.current_screen == "Options Screen":
if self.button_options_return.collidepoint((mx, my)):
g.show_start_screen()
elif self.button_options_volumeup.collidepoint((mx, my)):
if self.volume >= 1:
self.volume = 1
else:
self.volume += 0.1
self.change_volume()
self.screen.blit(
pg.image.load(
path.join(
img_folder,
settings.optionscreen)).convert_alpha(),
(0, 0))
self.draw_volume()
elif self.button_options_volumedown.collidepoint((mx, my)):
if self.volume <= 0:
self.volume = 0
else:
self.volume -= 0.1
self.change_volume()
self.screen.blit(
pg.image.load(
path.join(
img_folder,
settings.optionscreen)).convert_alpha(),
(0, 0))
self.draw_volume()
self.click_test = False
def add_player(self, player:Player):
player.x, player.y = self.entrance
self.player = player
self.player.fov = 10
self.add_entity(player)
# Title -- The Old Mansion
# Author -- Austin Rosenbaum
# Started -- July 5, 2018
# Modified -- July 29, 2019
# Finished -- ??/??/????
################################
# Imports
# pygame?
import time, random
# Custom imports
from entity.player import Player
from map.spot import Spot
# Create map
# create a default spot to test
default_spot = Spot(0, 0)
# Create player object
name = input("What is your name? ")
player = Player(name, default_spot)
print(f"Welcome to The Old Mansion {player.name}!")
print(f"You are currently at ({player.location.x}, {player.location.y})")
# Create enemies
# Create items
class Game:
def __init__(self):
pg.init()
self.display = Display(pg.image.load('assets/background.jpg'))
self.player = None
self.entities = []
self.create_entities()
self.clock = pg.time.Clock()
self.running = True
self.NEW_GHOST = pg.USEREVENT
self.NEW_PUMPKIN = pg.USEREVENT + 1
self.NEW_HEART = pg.USEREVENT + 2
pg.time.set_timer(self.NEW_GHOST, 5000)
pg.time.set_timer(self.NEW_PUMPKIN, 3000)
pg.time.set_timer(self.NEW_HEART, 10000)
self.difficulty = Difficulty.EASY
self.kills_count = 0
self.player_movement = None
self.font = pg.font.Font('assets/Montserrat-Medium.ttf', 30)
def create_entities(self):
self.entities = [
Ghost((rnd.randint(-200,
0), rnd.randint(0, self.display.HEIGHT // 4))),
Pumpkin((rnd.randint(0, WIDTH), -100))
]
self.player = Player(
(self.display.WIDTH / 2, self.display.HEIGHT - 200),
'player_stand')
def check_collision(self):
for e in self.entities:
if not e.check_collision(self.player):
continue
if isinstance(e, Ghost):
self.player.damage(1)
if isinstance(e, Pumpkin):
self.player.damage(10)
self.entities.remove(e)
if isinstance(e, Heart):
self.player.heal(20)
self.entities.remove(e)
def run_events(self):
for event in pg.event.get():
if event.type == self.NEW_GHOST:
self.create_new_enemies_wave(Ghost)
if event.type == self.NEW_PUMPKIN:
self.create_new_enemies_wave(Pumpkin)
if event.type == self.NEW_HEART:
self.drop_heart()
if event.type == pg.QUIT:
self.running = False
pg.quit()
exit()
if event.type == pg.MOUSEBUTTONUP:
clicked_enemy = self.get_enemy_under_cursor(pg.mouse.get_pos())
if clicked_enemy is not None:
self.process_damage(clicked_enemy, 1)
if event.type == pg.KEYUP:
self.player.sprite = self.player.sprites['player_stand']
keys = pg.key.get_pressed()
if keys[pg.K_RIGHT]:
self.player_movement = ((1, 0), 5)
if keys[pg.K_LEFT]:
self.player_movement = ((-1, 0), 5)
def drop_heart(self):
x = rnd.randint(0, WIDTH - 100)
self.entities.append(Heart((x, -100)))
def update(self):
if self.player_movement is not None:
self.player.update(offset=self.player_movement,
sprite=self.player.sprites['player_run'])
self.player_movement = None
for entity in self.entities:
if isinstance(entity, Ghost):
entity.update(dest=(self.player.rect.center, 2))
if isinstance(entity, Pumpkin):
entity.update(offset=((0, 1), 7))
if entity.rect.centery >= HEIGHT - 100:
self.entities.remove(entity)
if isinstance(entity, Heart):
entity.update(offset=((0, 1), 2))
def create_new_enemies_wave(self, enemy):
if enemy is Ghost:
for i in range(rnd.randint(1, self.difficulty.value[0])):
pos = (-100 if rnd.randint(0, 100) % 2 == 0 else WIDTH + 100,
rnd.randint(0, HEIGHT))
self.entities.append(Ghost(pos))
if enemy is Pumpkin:
pos = (self.player.rect.centerx, -50)
self.entities.append(Pumpkin(pos))
def get_enemy_under_cursor(self, pos):
for e in self.entities:
if e.rect.collidepoint(pos):
return e
def process_damage(self, enemy, damage):
enemy.damage(damage)
if not enemy.alive:
self.kills_count += 1
self.entities.remove(enemy)
def game_over(self):
pg.display.set_caption('Game Over')
self.running = True
self.create_entities()
self.run()
def next_level(self):
if self.difficulty == Difficulty.EASY:
self.difficulty = Difficulty.MEDIUM
elif self.difficulty == Difficulty.MEDIUM:
self.difficulty = Difficulty.HARD
elif self.difficulty == Difficulty.HARD:
self.difficulty = Difficulty.UNREAL
def run(self):
while self.running:
self.run_events()
if self.kills_count >= self.difficulty.value[1]:
self.next_level()
self.update()
self.check_collision()
text = self.font.render(f'Kills: {self.kills_count}', True, WHITE)
self.display.draw(text, (20, 20), self.player, *self.entities)
pg.display.set_caption(
f'Level {self.difficulty.name} | FPS: {self.clock.get_fps()}')
if not self.player.alive:
self.running = False
self.clock.tick(FPS)
self.game_over()
class Game():
def __init__(self):
self.player = Player()
self.pressed = {}
self.window_resolution = (1280, 720)
self.back_color = (80, 90, 120)
self.red_color = (255, 0, 0)
self.black_color = (165, 42, 42)
pygame.init()
pygame.display.set_caption("PyBoi")
self.window_surface = pygame.display.set_mode(self.window_resolution)
#textures UI
self.ui = Ui(self.player, self.window_surface)
# mise en place des timers
self.clock = pygame.time.Clock()
pygame.time.set_timer(pygame.USEREVENT, 3)
self.stop = 0
self.i = 0
# mise en place font
self.arial_font = pygame.font.SysFont("arial", 30)
def showui(self):
self.ui.show_health()
self.ui.show_bombs_key_coin()
def start_game(self):
launched = True
text_timer = self.arial_font.render("", True, self.red_color)
while launched:
for event in pygame.event.get():
if event.type == pygame.QUIT:
launched = False
elif event.type == pygame.USEREVENT:
self.window_surface.fill(self.back_color)
self.window_surface.blit(
self.player.image,
(self.player.hitbox.x, self.player.hitbox.y))
self.player.all_projectiles.draw(self.window_surface)
# infos vélo
text_velo = self.arial_font.render(
str(int(self.player.velocity[0])) + "," +
str(int(self.player.velocity[1])), True,
self.red_color)
self.window_surface.blit(text_velo, [1000, 50])
# info timer
timer_list = []
if self.stop != 0:
text_timer = self.arial_font.render(
str(stop) + " ticks", True, self.red_color)
timer_list.append(text_timer)
stop = 0
self.window_surface.blit(text_timer, [1000, 150])
# infos FPS
text = self.arial_font.render(
str(int(self.clock.get_fps())) + " FPS", True,
self.red_color)
self.window_surface.blit(text, [1000, 100])
pygame.draw.line(
self.window_surface, self.red_color,
(self.player.hitbox.x + 50, self.player.hitbox.y + 60),
(self.player.hitbox.x + 50 +
20 * self.player.velocity[0], self.player.hitbox.y +
60 + 20 * self.player.velocity[1]), 5)
self.showui()
pygame.display.flip()
elif event.type == pygame.KEYDOWN:
stop = 0
start = pygame.time.get_ticks()
self.pressed[event.key] = True
elif event.type == pygame.KEYUP:
stop = pygame.time.get_ticks() - start
self.pressed[event.key] = False
if self.pressed.get(pygame.K_d):
self.player.move_down(True)
else:
self.player.move_down(False)
if self.pressed.get(pygame.K_e):
self.player.move_up(True)
else:
self.player.move_up(False)
if self.pressed.get(pygame.K_s):
self.player.move_left(True)
else:
self.player.move_left(False)
if self.pressed.get(pygame.K_f):
self.player.move_right(True)
else:
self.player.move_right(False)
if self.pressed.get(pygame.K_DOWN):
self.player.shoot(3)
if self.pressed.get(pygame.K_UP):
self.player.shoot(1)
if self.pressed.get(pygame.K_RIGHT):
self.player.shoot(0)
if self.pressed.get(pygame.K_LEFT):
self.player.shoot(2)
self.player.position()
for tears in self.player.all_projectiles:
tears.move()
self.clock.tick(60)
class MainState:
def __init__(self, screen):
self.player = Player()
self.key_maps = {
pygame.K_a: self.player.move_left,
pygame.K_d: self.player.move_right,
pygame.K_SPACE: self.player.jump,
pygame.K_LSHIFT: self.fade,
pygame.K_ESCAPE: self._invert_pause,
pygame.K_q: self.player.swing,
pygame.K_e: self.player.shoot
}
self.tile_map = generate.generate_easy_over_world()
self.entities = [self.player] + populate(get_ground(self.tile_map),
(20, 80), 5, 0, 1)
self._teleporter = Teleporter(TILE_SIZE * 83, 0, 2, 3, 'CAVE')
self.window = Window(screen, WIDTH, HEIGHT)
self._cool_down_bar = CoolDownBar()
self._fade_vignette = pygame.image.load('assets/sprites/vignette.png')
self.player_alive = True
self.death_text = None
self._pause_menu = None
self._paused = False
self._gloom = False
self.fill_color = (119, 171, 255)
self.lights = []
self.boss_fight = False
self.won = False
am.stop_music()
am.play_music('overworld.mp3', volume=0.1, loop=True)
def update(self):
if self._paused:
self._update_paused()
return True
self.window.clear(self.fill_color)
if not self.death_text and not self._paused:
keys = pygame.key.get_pressed()
for key, fn in self.key_maps.items():
if keys[key]:
fn()
objects = self.window.clip_objects(self.entities, self.tile_map)
for obj in objects:
if isinstance(obj, Entity):
others = self.tile_map + [x for x in self.entities if x != obj]
obj.x_range, obj.y_range = calculate_x_range(
obj, others), calculate_y_range(obj, others)
if isinstance(obj, FinalBoss):
obj.update(self.player.position, others)
elif obj.enemy:
obj.update(self.player.position)
else:
obj.update()
if isinstance(obj, FinalBoss):
if obj.health == 0:
self.won = True
return False
# add animation
obj.animate()
# allow entities to deal damage
if not isinstance(obj, Player) and obj.damage > 0:
if isinstance(obj, Arrow):
for other in others:
if colliding(obj, other) and isinstance(
other, Entity) and other.enemy:
other.hurt(obj.damage)
elif obj.should_damage and colliding(obj, self.player):
self.player.hurt(obj.damage)
obj.should_damage = False
obj.set_timer('reset-damage', 20, obj.reset_damage)
# check for damage
if colliding(self.player,
obj) and self.player.swinging and obj.enemy:
obj.hurt(self.player.damage)
# check for projectiles
if isinstance(obj, Projectile):
for other in others:
if colliding(obj, other) and obj.parent != other:
if other.collidable or (
isinstance(other, Entity)
and not isinstance(other, Projectile)):
obj.hurt(obj.max_health)
break
if hasattr(obj, 'healing'):
if colliding(self.player, obj):
self.player.heal(obj.healing)
obj.health -= 1
# check spawned children
if len(obj.children) > 0:
self.entities.extend(obj.children)
obj.children = []
self.window.draw_entity(obj)
# assume tile
else:
if obj.damage > 0 and colliding(self.player, obj):
self.player.hurt(obj.damage)
self.window.draw_tile(obj)
if self._gloom:
self.window = render_lights(self.window, self.lights,
self.window.offset)
self.window.draw_gui_element(self._cool_down_bar)
if self.player.health == 0:
am.stop_music()
self._play_death_animation()
elif self.player.fading:
self.window.draw_overlay(self._fade_vignette)
self.window.draw_overlay((237, 193, 255))
elif self._teleporter.check_collision(self.player.position):
self._teleport(self._teleporter.destination)
self._cool_down_bar.update(self.player)
if not self.boss_fight:
x_shift = 0
if self.player.swinging and not self.player.flip_horizontal:
x_shift = 25
self.window.set_window_offset(
-(self.player.position.x - WIDTH / 2) - x_shift,
(self.player.position.y - PLAYER_SPAWN))
# trim dead entities
self.entities = [
x for x in self.entities if x.health > 0 or isinstance(x, Player)
]
return self.player_alive
def fade(self):
if not self.player.fading:
self.player.fade()
def _invert_pause(self):
self._paused = not self._paused
def _update_paused(self):
self.window.draw_overlay((125, 125, 125), 50)
if not self._pause_menu:
self._pause_menu = PauseMenu()
x, y = pygame.mouse.get_pos()
self._pause_menu.update(Point2D(x, y),
pygame.mouse.get_pressed()[0] == 1)
self.window.draw_menu(self._pause_menu)
if self._pause_menu.state >= 1:
self._paused = False
if self._pause_menu.state == 2:
self.player_alive = False
self._pause_menu.state = 0
def _play_death_animation(self):
self.window.draw_overlay((125, 125, 125), 5)
self.window.draw_overlay(self._fade_vignette)
if not self.death_text:
self.death_text = DeathText()
self.death_text.update()
self.window.draw_gui_element(self.death_text)
if self.death_text.animation_over:
self.player_alive = False
def _teleport(self, destination):
pygame.font.init()
self.window.draw_overlay((0, 0, 0))
text = pygame.font.SysFont('arial.ttf',
50).render('Loading...', True,
(255, 255, 255))
self.window.blit(text, (WIDTH // 2 - text.get_width() // 2,
HEIGHT // 2 - text.get_height() // 2))
pygame.display.update()
if destination == 'CAVE':
am.stop_music()
am.play_music('cave.mp3', volume=0.3, loop=True)
self.player.position.x, self.player.position.y = 2 * TILE_SIZE, 7 * TILE_SIZE
self.tile_map, self.lights = generate.generate_cave()
self.entities = self.entities[:1] + populate(
get_ground(self.tile_map), (10, 40), 6, 2, 2)
self._gloom = True
self.fill_color = (50, 50, 60)
self._teleporter = Teleporter(51 * TILE_SIZE,
self.tile_map[-1].position.y, 4, 4,
'LAVA_CAVE')
elif destination == 'LAVA_CAVE':
self.player.position.x, self.player.position.y = 0, 9 * TILE_SIZE
self.tile_map, self.lights = generate.generate_lava_cave()
self.entities = self.entities[:1] + populate(
get_ground(self.tile_map), (10, 60), 3, 3, 3)
self._teleporter = Teleporter(83 * TILE_SIZE, 8 * TILE_SIZE, 4, 4,
'ICE_CAVE')
elif destination == 'ICE_CAVE':
am.stop_music()
am.play_music('ice_cave.mp3', volume=0.3, loop=True)
self.player.position.x, self.player.position.y = 2 * TILE_SIZE, 9 * TILE_SIZE
self.tile_map, self.lights = generate.generate_ice_cave()
self.entities = self.entities[:1] + populate(
get_ground(self.tile_map), (10, 70), 4, 4, 4)
self._teleporter = Teleporter(84 * TILE_SIZE, 8 * TILE_SIZE, 4, 4,
'BOSS_ROOM')
elif destination == 'BOSS_ROOM':
am.stop_music()
self.player.position.x, self.player.position.y = 2 * TILE_SIZE, 3 * TILE_SIZE
self.tile_map, self.lights = generate.generate_boss_room(), []
self.entities = self.entities[:1]
self._gloom = False
self.fill_color = (0, 0, 0)
self._teleporter = Teleporter(40 * TILE_SIZE, 3 * TILE_SIZE, 4, 4,
'FINAL_BOSS_FIGHT')
elif destination == 'FINAL_BOSS_FIGHT':
am.play_music('final_boss.mp3', volume=0.2, loop=True)
self.boss_fight = True
self.tile_map = generate.generate_final_boss_floor()
self.entities = self.entities[:1]
self.entities.append(FinalBoss(WIDTH // 2 - 72, HEIGHT // 2 - 54))
self.player.position.x, self.player.position.y = WIDTH // 2, TILE_SIZE
self.window.set_window_offset(0, 0)
def process_input(self, input_str: str, player: Player, entities=None):
self.data = input_str
player.set_name(self.data)
def remove_player(self, player: Player):
""" Removes player from the game.
"""
player.in_game = False
self.delete_if_no_players()
class Game(object): SCREEN_WIDTH = 300 SCREEN_HEIGHT = SCREEN_WIDTH / 16 * 9 SCALE = 3 SCREEN_CAPTION = 'Rain' FRAMERATE = 60.0 def __init__(self): self.running = False self.display = None self.size = self.SCREEN_WIDTH * self.SCALE, self.SCREEN_HEIGHT * self.SCALE self.clock = None self.screen = None self.keyboard = None self.level = None self.player = None def setup(self): os.environ['SDL_VIDEO_CENTERED'] = '1' # should make the window pop up centered pygame.init() self.display = pygame.display.set_mode( self.size ) # imports (since they require pygame.init()) from graphics.screen import Screen from input.keyboard import Keyboard from level.level import RandomLevel from entity.player import Player pygame.display.set_caption( self.SCREEN_CAPTION ) self.clock = pygame.time.Clock() self.screen = Screen(self.SCREEN_WIDTH, self.SCREEN_HEIGHT) self.keyboard = Keyboard() self.level = RandomLevel(64, 64) self.player = Player(self.keyboard) self.running = True def stop(self): pygame.quit() sys.exit(0) def run(self): self.setup() delta = 0 frames = 0 updates = 0 timer = 0 while self.running: dt = self.clock.tick() # dt = time since last tick() in ms delta += dt / 1000.0 * self.FRAMERATE # delta = % of time till next frame timer += dt # timer = accumulated ms while delta >= 1: self.update() updates += 1 delta -= 1 self.render() frames += 1 if timer > 1000: print '%d ups, %d fps' % (updates, frames) pygame.display.set_caption( '%s | %d ups, %d fps | X: %d, Y: %d' % ( self.SCREEN_CAPTION, updates, frames, self.player.x, self.player.y ) ) updates = frames = 0 timer -= 1000 self.stop() def update(self): self.keyboard.update() if self.keyboard.quit: self.stop() self.player.update() for event in pygame.event.get(): if event.type == QUIT: self.stop() def render(self): self.screen.clear() x_scroll = self.player.x - self.screen.width / 2 y_scroll = self.player.y - self.screen.height / 2 self.level.render(x_scroll, y_scroll, self.screen) self.player.render(self.screen) scaled = pygame.transform.scale( self.screen.surface, self.size ) self.display.blit( scaled, (0,0) ) pygame.display.update()
def __init__(self):
pass
def on_notify(self, entity, event):
print "entity:{0}, event:{1}".format(entity, event)
class Achievement(Observer):
def __init__(self):
super(Achievement, self).__init__()
def on_notify(self, entity, event):
print "Achievement,entity:{0}, event:{1}".format(entity, event)
class Physics(Subject):
def __init__(self, entity):
super(Physics, self).__init__()
self.entity = entity
def update_entity(self):
self.notify(self.entity, 1)
if __name__ == '__main__':
from entity.player import Player
player = Player()
physics = Physics(player)
physics.add_observer(Achievement())
physics.update_entity()
def main(debug=False):
screen_width = 80
screen_height = 80
map_width = 60
map_height = 60
menu_width = 20
menu_height = 80
action_width = 60
action_height = 20
cur_level_idx = 0
cur_level = levels[cur_level_idx]
player = Player()
cur_level.add_player(player)
tutorial_map = cur_level.get_map()
player.add_map(tutorial_map)
ui_manager = UIManager(player, screen_width, screen_height)
cur_level.add_ui_manager(ui_manager)
tcod.console_set_custom_font(
'tileset/cp437_10x10.png',
tcod.FONT_TYPE_GRAYSCALE | tcod.FONT_LAYOUT_ASCII_INROW
)
root_console = tcod.console_init_root(
screen_width, screen_height, 'Crypt Hero', False,
tcod.RENDERER_SDL2, order='F', vsync=True)
renderer = Renderer(root_console, ui_manager, debug=debug)
cur_level.add_renderer(renderer)
recompute = True
while True:
if recompute and cur_level.recalculate_fov:
recompute = False
tutorial_map.compute_fov(player.x, player.y, player.fov, True, 0)
renderer.render_level(player, cur_level.entities, tutorial_map, colors=cur_level.show_colors)
actions = handle_events()
move = actions.get('move')
pass_time = actions.get('pass_time')
exit = actions.get('exit')
act = actions.get('act')
restart = actions.get('restart')
fullscreen = actions.get('fullscreen')
god_mod = actions.get('god_mod')
if god_mod and debug:
player.activate_god_mod()
if move and player.can_move and not ui_manager.popup:
recompute = True
player.move(*move)
cur_level.pass_turn(move)
if pass_time:
cur_level.pass_turn((0, 0))
if exit:
if ui_manager.popup:
ui_manager.remove_popup()
else:
return True
if player.dead or cur_level.ended:
return True
if act:
handle_action(act, renderer, cur_level, ui_manager)
if restart and (player.dead or cur_level.ended):
reset_levels()
player = Player(char=ord(' '))
ui_manager = UIManager(player, screen_width, screen_height)
renderer = Renderer(root_console, ui_manager)
cur_level_idx = 0
cur_level = levels[cur_level_idx]
cur_level.add_player(player)
tutorial_map = cur_level.get_map()
player.add_map(tutorial_map)
cur_level.add_ui_manager(ui_manager)
cur_level.add_renderer(renderer)
recompute = True
if fullscreen:
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
if player.is_on_exit():
cur_level_idx += 1
cur_level = levels[cur_level_idx]
cur_level.add_player(player)
tutorial_map = cur_level.get_map()
player.add_map(tutorial_map)
cur_level.add_ui_manager(ui_manager)
cur_level.add_renderer(renderer)
recompute = True
if player.dead:
ui_manager.show_popup('You are dead', 'This world falls into crumbles.\nMay you be more lucky next time.', 'Press r to reset or ESC to quit')
class GameScene(Scene):
def __init__(self, game):
super().__init__(game, game.display.get_size())
self.game.events.register_listener('ENEMY_KILLED', self.increase_score)
self.game.events.register_listener('SWARM_DESTROYED',
self.on_swarm_destroyed)
self.game.events.register_listener('PLAYER_HEALTH_UPDATE',
self.write_health)
self.game.events.register_listener('PLAYER_DESTROYED',
self.on_player_destroyed)
self.background = Stars(self, 250)
self.player = Player(self)
self.player.rect.move_ip(
self.game.display.get_size()[0] / 2 - self.player.rect.width / 2,
self.game.display.get_size()[1] - self.player.rect.height - 20)
self.enemies = Group()
self.projectiles = Group()
self.enemy_projectiles = Group()
self.score = 0
self.game_over = False
self.show_overlay = False
self.font = Font(get_asset_path('dpcomic.ttf'), 32)
self.write_score()
self.write_health()
self.laser_sound = load_sound('laser.ogg')
self.laser_sound.set_volume(0.2)
self.waves = [
Swarm(self, 'waves/1.png'),
Swarm(self, 'waves/2.png'),
Swarm(self, 'waves/3.png'),
Swarm(self, 'waves/4.png'),
Swarm(self, 'waves/5.png'),
Swarm(self, 'waves/6.png'),
Swarm(self, 'waves/7.png'),
]
self.spawn_timer = Timer()
self.current_wave_id = 1
self.current_wave = self.waves.pop(0)
self.current_wave_active = False
self.spawn_swarm(self.current_wave)
self.overlay, _ = load_image('overlay.png',
width=self.game.get_width(),
height=self.game.get_height())
def spawn_swarm(self, swarm):
swarm.ships.clear()
swarm.spawn()
self.enemies.add(self.current_wave.ships)
self.spawn_timer.restart()
self.write_overlay('Wave {}'.format(self.current_wave_id))
def spawn_projectile(self, group, projectile):
group.add(projectile)
self.laser_sound.play()
def write_score(self):
self.text_score = self.font.render('Score: {}'.format(self.score),
False, (255, 255, 255))
self.text_score_shadow = self.font.render(
'Score: {}'.format(self.score), False, (7, 5, 23))
def write_score_to_file(self):
time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
write_to_file('scores.txt', "{} = {}".format(time, self.score))
def write_health(self, event=None):
self.text_health = self.font.render(
'Health: {}'.format(self.player.health), False, (255, 255, 255))
self.text_health_shadow = self.font.render(
'Health: {}'.format(self.player.health), False, (7, 5, 23))
def write_overlay(self, text):
self.show_overlay = True
self.text_gameover = self.font.render(text, False, (255, 255, 255))
self.text_gameover_shadow = self.font.render(text, False, (7, 5, 23))
def increase_score(self, event):
self.score += event.points
self.write_score()
def on_swarm_destroyed(self, event):
self.current_wave_active = False
if len(self.waves) == 0:
self.write_overlay('Victory!')
self.write_score_to_file()
self.game_over = True
else:
self.current_wave_id += 1
self.current_wave = self.waves.pop(0)
self.spawn_swarm(self.current_wave)
def on_player_destroyed(self, event):
if self.game_over:
return
self.game_over = True
self.write_overlay('Game Over!')
self.write_score_to_file()
self.player.kill()
def handle_collisions(self):
hit = groupcollide(self.projectiles, self.enemies, True, False)
for _, enemies in hit.items():
for enemy in enemies:
if enemy.hit(self.player.weapon_power):
self.current_wave.on_ship_destroyed(enemy)
player_hit = spritecollide(self.player, self.enemy_projectiles, True)
if len(player_hit) > 0:
self.game.events.broadcast('PLAYER_HIT',
{'damage': player_hit[0].power})
def handle_projectiles(self):
for projectile in chain(self.projectiles, self.enemy_projectiles):
if projectile.rect.top + projectile.rect.height < 0 or projectile.rect.top > self.game.get_height(
):
projectile.kill()
def update(self):
if self.spawn_timer.has_passed_once(1500):
self.current_wave_active = True
self.show_overlay = False
self.background.update()
if self.current_wave_active:
self.projectiles.update()
self.enemy_projectiles.update()
self.enemies.update()
if not self.game_over:
self.player.update()
self.handle_projectiles()
self.handle_collisions()
self.current_wave.update()
if self.current_wave.rect.top + self.current_wave.rect.height >= self.player.rect.top + 10:
self.game.events.broadcast('PLAYER_DESTROYED', {})
def render_text_with_outline(self, text, text_shadow, x, y, outline=3):
self.blit(text_shadow, (x - outline, y))
self.blit(text_shadow, (x + outline, y))
self.blit(text_shadow, (x, y - outline))
self.blit(text_shadow, (x, y + outline))
self.blit(text, (x, y))
def render(self):
self.fill((19, 15, 64))
self.background.render()
self.render_group(self.projectiles)
if self.current_wave_active:
self.render_group(self.enemy_projectiles)
self.render_group(self.enemies)
if not self.game_over:
self.player.render(self)
if self.show_overlay:
self.blit(self.overlay, (0, 0))
self.render_text_with_outline(
self.text_gameover, self.text_gameover_shadow,
self.game.get_width() / 2 -
self.text_gameover.get_rect().width / 2,
self.game.get_height() / 2 -
self.text_gameover.get_rect().height / 2)
self.render_text_with_outline(
self.text_score, self.text_score_shadow,
self.game.get_width() - self.text_score.get_rect().width - 16,
self.game.get_height() - self.text_score.get_rect().height - 16)
self.render_text_with_outline(
self.text_health, self.text_health_shadow, 16,
self.game.get_height() - self.text_health.get_rect().height - 16)