class game_scene(object):
def __init__(self, manager, engine, map_name, entrance_name):
self._manager = manager
self.finished = False
self._engine = engine
# Load images for UI
self._ui_spritesheet = spritesheet.spritesheet('ui.png')
self._ui_images = self._ui_spritesheet.load_all(
(0, 0, DEFAULT_SPRITE_WIDTH, DEFAULT_SPRITE_HEIGHT), ALPHA_COLOUR)
# Load the map
self.load_map(map_name, entrance_name, self._engine.screen.get_size())
def load_map(self, name, entrance_name, display_size):
filename = get_map(name)
# load data from pytmx
tmx_data = load_pygame(filename)
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(tmx_data)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data,
display_size,
clamp_camera=True,
tall_sprites=1)
self.map_layer.zoom = 2
# pyscroll supports layered rendering. our map has 3 'under' layers
# layers begin with 0, so the layers are 0, 1, and 2.
# since we want the sprite to be on top of layer 1, we set the default
# layer for sprites as 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=2)
# put the hero in tile with name matching entrance_name
player_start = tmx_data.get_object_by_name(entrance_name)
self._engine.hero.position = [player_start.x, player_start.y]
# add our hero to the group
self.group.add(self._engine.hero)
# setup level geometry with simple pygame rects, loaded from pytmx
self.walls = list()
self.npcs = list()
self.enemies = list()
self.triggers = list()
temp_npcs = list()
# Also a pathfinding grid
self.pathfinding_grid = pathfinding.weighted_grid(
tmx_data.width, tmx_data.height)
for object in tmx_data.objects:
if object.type == 'wall':
self.walls.append(
pygame.Rect(object.x, object.y, object.width,
object.height))
# Add walls to the pathfinding grid
grid_x = int(object.x / tmx_data.tilewidth)
grid_y = int(object.y / tmx_data.tileheight)
grid_width = int(object.width / tmx_data.tilewidth)
grid_height = int(object.height / tmx_data.tileheight)
for y in range(0, grid_height):
for x in range(0, grid_width):
self.pathfinding_grid.walls.append(
(grid_x + x, grid_y + y))
elif object.type == 'npc' or object.type == 'enemy':
# Process NPCs and enemies after walls are determined
temp_npcs.append(object)
elif object.type == 'trigger':
self.triggers.append(
trigger.trigger(object.x, object.y, object.width,
object.height, object.properties))
# Process NPCs and enemies
for object in temp_npcs:
target_grid_x = int(object.target_x)
target_grid_y = int(object.target_y)
target_x = target_grid_x * tmx_data.tilewidth
target_y = target_grid_y * tmx_data.tileheight
origin_grid_x = int(object.x / tmx_data.tilewidth)
origin_grid_y = int(object.y / tmx_data.tileheight)
# Pathfinding
came_from, cost_so_far = pathfinding.a_star_search(
self.pathfinding_grid, (origin_grid_x, origin_grid_y),
(target_grid_x, target_grid_y))
path = pathfinding.reconstruct_path(came_from,
(origin_grid_x, origin_grid_y),
(target_grid_x, target_grid_y))
path = [(t[0] * tmx_data.tilewidth, t[1] * tmx_data.tileheight)
for t in path]
# Load sprite from JSON
if object.type == 'npc':
npc = character.npc(object.name, path)
self.npcs.append(npc)
self.group.add(npc)
elif object.type == 'enemy':
enemy = character.enemy(object.name, path)
self.enemies.append(enemy)
self.group.add(enemy)
# Play background music
if 'background_music' in tmx_data.properties:
self._engine.play_music(tmx_data.properties['background_music'])
# Initialise map
self.update(0)
def display_text(self, text):
message_box = (0, 1 - DIALOG_HEIGHT, 1, DIALOG_HEIGHT)
self._manager.append(
text_scene.text_scene(self._manager, text, message_box))
def interaction(self):
index = self._engine.hero.interaction_rect.collidelist(self.npcs)
# NPC
if index > -1:
self.display_text(self.npcs[index].name + ': ' +
self.npcs[index].dialogue)
else:
# Events, objects
index = self._engine.hero.interaction_rect.collidelist(
self.triggers)
if index > -1:
trigger = self.triggers[index]
if not trigger.condition or eval(trigger.condition):
if trigger.on_interact == 'message':
self.display_text(trigger.message_text)
elif trigger.on_interact == 'load_map':
new_map = game_scene(self._manager, self._engine,
trigger.map_name,
trigger.entrance_name)
fade = fade_transition.fade_transition(
self._manager, FADE_TIME, FADE_COLOUR)
self._manager.change(new_map, fade)
elif trigger.on_interact == 'set':
exec_string = 'self.' + trigger.variable_name \
+ ' = ' + trigger.value
exec(exec_string)
self.display_text(trigger.message_text)
else:
self.display_text(trigger.error_text)
def pause(self):
pass
def resume(self):
pass
def end(self):
self.finished = True
def draw_ui(self, surface):
# Health
full_count = int(self._engine.hero.health / 2)
half_count = self._engine.hero.health % 2
empty_count = int(
(self._engine.hero.max_health - self._engine.hero.health) / 2)
for i in range(0, full_count):
#x = surface.get_width() - ((i / 2 + 1) * self._ui_images[0].get_width())
x = i * self._ui_images[2].get_width()
y = 0
surface.blit(self._ui_images[2], (x, y))
for i in range(0, half_count):
x = (i + full_count) * self._ui_images[1].get_width()
y = 0
surface.blit(self._ui_images[1], (x, y))
for i in range(0, empty_count):
x = (i + full_count + half_count) * self._ui_images[0].get_width()
y = 0
surface.blit(self._ui_images[0], (x, y))
def pause_menu(self):
pause_menu = menu_scene.menu_scene(self._manager, PAUSE_MENU_IMAGE,
PAUSE_MENU_RECT)
pause_menu.append("Resume Game", True, pause_menu.end)
pause_menu.append(
"Quit", True,
lambda: pygame.event.post(pygame.event.Event(pygame.QUIT)))
self._manager.append(pause_menu)
def game_over(self):
self.end()
message_box = (0, 1 - DIALOG_HEIGHT, 1, DIALOG_HEIGHT)
self._manager.append(
text_scene.text_scene(self._manager, ["GAME OVER", ":[ :[ :[ :["],
message_box))
def _button_attack(self):
self._engine.hero.attack()
def handle_input(self, events, pressed_keys):
for event in events:
if event.type == R_INPUT_EVENT:
if event.button == buttons.R_A:
self.interaction()
if event.button == buttons.R_B:
self._button_attack()
if event.button == buttons.R_START:
self.pause_menu()
# elif event.key == K_EQUALS:
# self.map_layer.zoom += .25
#
# elif event.key == K_MINUS:
# value = self.map_layer.zoom - .25
# if value > 0:
# self.map_layer.zoom = value
#
# # this will be handled if the window is resized
# elif event.type == VIDEORESIZE:
# scope.resize(event.w, event.h)
# self.map_layer.set_size((event.w, event.h))
#
# using get_pressed is slightly less accurate than testing for events
# but is much easier to use.
if pressed_keys[buttons.R_UP]:
self._engine.hero.move_up()
elif pressed_keys[buttons.R_DOWN]:
self._engine.hero.move_down()
else:
self._engine.hero.stop_moving_vertical()
if pressed_keys[buttons.R_LEFT]:
self._engine.hero.move_left()
elif pressed_keys[buttons.R_RIGHT]:
self._engine.hero.move_right()
else:
self._engine.hero.stop_moving_horizontal()
def update(self, dt):
""" Tasks that occur over time should be handled here
"""
self.group.update(dt)
# check if the sprite's feet are colliding with wall
# sprite must have a rect called feet, and move_back method,
# otherwise this will fail
for sprite in self.group.sprites():
if sprite.feet.collidelist(self.walls) > -1:
sprite.move_back(dt)
# Check if NPCs are colliding with the hero
for npc in self.npcs:
if npc.feet.colliderect(self._engine.hero.feet):
npc.move_back(dt)
self._engine.hero.move_back(dt)
for enemy in self.enemies:
if enemy.alive and enemy.rect.colliderect(
self._engine.hero.hitbox):
enemy.take_damage(
self._engine.hero.damage,
calculate_knockback(self._engine.hero.position,
enemy.position,
self._engine.hero.weapon.knockback))
if enemy.dead:
enemy.remove(self.group)
elif enemy.alive and enemy.feet.colliderect(
self._engine.hero.feet):
enemy.move_back(dt)
self._engine.hero.take_damage(
enemy.damage,
calculate_knockback(enemy.position,
self._engine.hero.position,
enemy.knockback))
enemy.threat_target = self._engine.hero.position
# If the player is dead, game over
if self._engine.hero.dead:
self.game_over()
def draw(self, surface):
# center the map/screen on our Hero
self.group.center(self._engine.hero.rect.center)
# draw the map and all sprites
self.group.draw(surface)
# Draw user interface
self.draw_ui(surface)
class QuestGame:
"""This class is a basic game.
This class will load data, create a pyscroll group, a hero object.
It also reads input and moves the Hero around the map.
Finally, it uses a pyscroll group to render the map and Hero.
"""
map_path = RESOURCES_DIR / "grasslands.tmx"
def __init__(self, screen: pygame.Surface) -> None:
self.screen = screen
# true while running
self.running = False
# load data from pytmx
tmx_data = load_pygame(self.map_path)
# setup level geometry with simple pygame rects, loaded from pytmx
self.walls = []
for obj in tmx_data.objects:
self.walls.append(pygame.Rect(obj.x, obj.y, obj.width, obj.height))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(tmx_data)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(
map_data, screen.get_size(), clamp_camera=False, tall_sprites=1
)
self.map_layer.zoom = 2
# pyscroll supports layered rendering. our map has 3 'under' layers
# layers begin with 0, so the layers are 0, 1, and 2.
# since we want the sprite to be on top of layer 1, we set the default
# layer for sprites as 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=2)
self.hero = Hero()
# put the hero in the center of the map
self.hero.position = self.map_layer.map_rect.center
self.hero._position[0] += 200
self.hero._position[1] += 400
# add our hero to the group
self.group.add(self.hero)
def draw(self) -> None:
# center the map/screen on our Hero
self.group.center(self.hero.rect.center)
# draw the map and all sprites
self.group.draw(self.screen)
def handle_input(self) -> None:
"""Handle pygame input events"""
poll = pygame.event.poll
event = poll()
while event:
if event.type == QUIT:
self.running = False
break
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.running = False
break
elif event.key == K_EQUALS:
self.map_layer.zoom += 0.25
elif event.key == K_MINUS:
value = self.map_layer.zoom - 0.25
if value > 0:
self.map_layer.zoom = value
# this will be handled if the window is resized
elif event.type == VIDEORESIZE:
self.screen = init_screen(event.w, event.h)
self.map_layer.set_size((event.w, event.h))
event = poll()
# using get_pressed is slightly less accurate than testing for events
# but is much easier to use.
pressed = pygame.key.get_pressed()
if pressed[K_UP]:
self.hero.velocity[1] = -HERO_MOVE_SPEED
elif pressed[K_DOWN]:
self.hero.velocity[1] = HERO_MOVE_SPEED
else:
self.hero.velocity[1] = 0
if pressed[K_LEFT]:
self.hero.velocity[0] = -HERO_MOVE_SPEED
elif pressed[K_RIGHT]:
self.hero.velocity[0] = HERO_MOVE_SPEED
else:
self.hero.velocity[0] = 0
def update(self, dt):
"""Tasks that occur over time should be handled here"""
self.group.update(dt)
# check if the sprite's feet are colliding with wall
# sprite must have a rect called feet, and move_back method,
# otherwise this will fail
for sprite in self.group.sprites():
if sprite.feet.collidelist(self.walls) > -1:
sprite.move_back(dt)
def run(self):
"""Run the game loop"""
clock = pygame.time.Clock()
self.running = True
from collections import deque
times = deque(maxlen=30)
try:
while self.running:
dt = clock.tick() / 1000.0
times.append(clock.get_fps())
self.handle_input()
self.update(dt)
self.draw()
pygame.display.flip()
except KeyboardInterrupt:
self.running = False
class MainGame:
filename = load_map(MAP_FILENAME)
def __init__(self):
# true while running
self.running = False
# load data from pytmx
tmx_data = load_pygame(self.filename)
# set the current resolution
self.res = get_screen_res()
self.up = self.down = self.right = self.left = 0 # set up for declaration
for key in config.items('KEY_CONFIG'): # declare config keys
exec('self.' + key[0] + ' = K_' + key[1])
# setup level geometry with simple pygame rects, loaded from pytmx
self.walls = list()
for obj in tmx_data.objects:
self.walls.append(pygame.Rect(
obj.x, obj.y,
obj.width, obj.height))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(tmx_data)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data, screen.get_size())
self.map_layer.zoom = 2
# pyscroll supports layered rendering. our map has 3 'under' layers
# layers begin with 0, so the layers are 0, 1, and 2.
# since we want the sprite to be on top of layer 1, we set the default
# layer for sprites as 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=2)
# Define characters
self.prototype = Prototype(res=self.res)
self.enemy = Enemy(enemy_type=enemy.suicide_explode, res=self.res)
# Set character positions
self.prototype.position = self.map_layer.map_rect.center
self.enemy.position = (300, 300)
# add our hero to the group
self.group.add(self.enemy)
self.group.add(self.prototype)
def draw(self, surface):
# center the map/screen on our Hero
self.group.center(self.prototype.rect.center)
# draw the map and all sprites
self.group.draw(surface)
def handle_input(self):
# Handle pygame input events
poll = pygame.event.poll
event = poll()
while event:
if hasattr(event, "pos"):
mx, my = event.pos
self.prototype.m_pos = [mx, my]
if event.type == QUIT:
self.running = False
break
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.running = False
break
elif event.key == K_EQUALS:
self.map_layer.zoom += .25
elif event.key == K_MINUS:
value = self.map_layer.zoom - .25
if value > 0:
self.map_layer.zoom = value
event = poll()
# using get_pressed is slightly less accurate than testing for events
# but is much easier to use.
pressed = pygame.key.get_pressed()
if pressed[self.up]:
self.prototype.velocity[1] = -movement_speed
elif pressed[self.down]:
self.prototype.velocity[1] = movement_speed
else:
self.prototype.velocity[1] = 0
if pressed[self.left]:
self.prototype.velocity[0] = -movement_speed
elif pressed[self.right]:
self.prototype.velocity[0] = movement_speed
else:
self.prototype.velocity[0] = 0
def update(self, dt):
""" Tasks that occur over time should be handled here
"""
self.group.update(dt)
global i
i += 1
# check if the sprite's feet are colliding with wall
# sprite must have a rect called feet, and move_back method,
# otherwise this will fail
for sprite in self.group.sprites():
if sprite.hit_box.collidelist(self.walls) > -1:
sprite.move_back(dt)
def run(self):
""" Run the game loop
"""
clock = pygame.time.Clock()
self.running = True
try:
while self.running:
dt = clock.tick() / 1000.
self.handle_input()
self.update(dt)
self.draw(screen)
pygame.display.flip()
except KeyboardInterrupt:
self.running = False
class Invertibles(object):
filename = get_map(MAP_FILENAME)
def __init__(self):
pygame.mixer.pre_init(44100, 16, 1, 4096)
pygame.init()
pygame.font.init()
self.screen = init_screen(800, 600)
pygame.display.set_caption('Polaria')
# Music channel
self.music_channel = pygame.mixer.Channel(1)
self.sounds = Sounds()
# Store projectiles in a group
self.projectiles = Group()
# true while running
self.running = False
# load data from pytmx
tmx_data = load_pygame(self.filename)
# setup level geometry with simple pygame rects, loaded from pytmx
self.walls = list()
for object in tmx_data.objects:
self.walls.append(
pygame.Rect(object.x, object.y, object.width, object.height))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(tmx_data)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data,
self.screen.get_size())
self.map_layer.zoom = 3.75
# pyscroll supports layered rendering. our map has 3 'under' layers
# layers begin with 0, so the layers are 0, 1, and 2.
# since we want the sprite to be on top of layer 1, we set the default
# layer for sprites as 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=3)
self.hero = Hero()
self.heroes = list()
self.heroes.append(self.hero)
# Spawn an npc
self.npc = NPC()
self.npc.position = self.map_layer.map_rect.move(544, 592).topleft
self.group.add(self.npc)
self.npcs = list()
self.npcs.append(self.npc)
# Spawn an elemental below the house
self.spawn_elementals()
# Spawn the hero outside his house
self.hero.position = self.map_layer.map_rect.move(528, 592).topleft
# add our hero to the group
self.group.add(self.hero)
self.projectile_skin = 0 # Which spell the user has selected
self.clock = pygame.time.Clock()
# Dictionary to hold onto what keys are being held down
self.movement_keys = {
'UP': False,
'DOWN': False,
'LEFT': False,
'RIGHT': False
}
def draw(self, surface, text=None):
# center the map/screen on our Hero
self.group.center(self.hero.rect.center)
# draw the map and all sprites
self.group.draw(surface)
#self.projectiles.draw(self.screen)
score = Text(self.screen,
str(len(self.elementals)) + " dark elementals remaining",
(0, 0, 0), 650, 10)
score.blitme()
if text:
dialogbox = DialogBox(self.screen)
dialogbox.blitme()
rendered_text = dialogbox.render_textrect(text)
if rendered_text:
self.screen.blit(rendered_text, dialogbox.textarea_rect)
def handle_input(self):
""" Handle pygame input events """
poll = pygame.event.poll
event = poll()
while event:
if event.type == QUIT:
self.running = False
break
elif event.type == KEYDOWN:
self.check_keydown_events(event)
elif event.type == KEYUP:
self.check_keyup_events(event)
self.move_hero()
if not self.running:
break
# this will be handled if the window is resized
elif event.type == VIDEORESIZE:
init_screen(event.w, event.h)
self.map_layer.set_size((event.w, event.h))
event = poll()
def reset_movement_keys(self):
"""Reset movement keys to False."""
self.movement_keys = {
'UP': False,
'DOWN': False,
'LEFT': False,
'RIGHT': False
}
def check_keydown_events(self, event):
"""Check for keypresses and respond to them."""
if event.key == K_ESCAPE or event.key == K_q:
self.running = False
# Set movement key flags
if event.key == K_a:
self.reset_movement_keys()
self.hero.reset_velocity()
self.movement_keys['LEFT'] = True
elif event.key == K_d:
self.reset_movement_keys()
self.hero.reset_velocity()
self.movement_keys['RIGHT'] = True
elif event.key == K_w:
self.reset_movement_keys()
self.hero.reset_velocity()
self.movement_keys['UP'] = True
elif event.key == K_s:
self.reset_movement_keys()
self.hero.reset_velocity()
self.movement_keys['DOWN'] = True
# Cast spells
if event.key == K_UP:
new_projectile = Projectile(self.screen, self.hero, 'UP',
self.projectile_skin)
self.group.add(new_projectile)
self.sounds.fireball.play()
elif event.key == K_LEFT:
new_projectile = Projectile(self.screen, self.hero, 'LEFT',
self.projectile_skin)
self.group.add(new_projectile)
self.sounds.fireball.play()
elif event.key == K_RIGHT:
new_projectile = Projectile(self.screen, self.hero, 'RIGHT',
self.projectile_skin)
self.group.add(new_projectile)
self.sounds.fireball.play()
elif event.key == K_DOWN:
new_projectile = Projectile(self.screen, self.hero, 'DOWN',
self.projectile_skin)
self.group.add(new_projectile)
self.sounds.fireball.play()
# Change spells
if event.key == K_1:
self.projectile_skin = 0
self.sounds.select_spell.play()
elif event.key == K_2:
self.projectile_skin = 1
self.sounds.select_spell.play()
elif event.key == K_3:
self.projectile_skin = 2
self.sounds.select_spell.play()
elif event.key == K_4:
self.projectile_skin = 3
self.sounds.select_spell.play()
def check_keyup_events(self, event):
"""Check for keyreleases and respond to them."""
# Set movement key flags
if event.key == K_a:
self.movement_keys['LEFT'] = False
if event.key == K_d:
self.movement_keys['RIGHT'] = False
if event.key == K_w:
self.movement_keys['UP'] = False
if event.key == K_s:
self.movement_keys['DOWN'] = False
def move_hero(self):
"""Only move hero if one movement key is being pressed."""
count = 0
key_pressed = ''
for key, pressed in self.movement_keys.items():
if pressed:
key_pressed = key
count += 1
if count == 1:
self.hero.set_direction(key_pressed)
else:
self.hero.set_idle()
def update_projectiles(self):
"""Update position of projectiles and get rid of old bullets."""
# Update projectile positions
self.projectiles.update()
# Get rid of projectiles that have gone off screen
for projectile in self.projectiles.copy():
if projectile.rect.bottom <= 0:
self.projectiles.remove(projectile)
def update(self, dt):
""" Tasks that occur over time should be handled here"""
self.group.update(dt)
self.update_projectiles()
# check if the sprite's feet are colliding with wall
# sprite must have a rect called feet, and move_back method,
# otherwise this will fail
for sprite in self.group.sprites():
if sprite.name == 'hero':
if sprite.feet.collidelist(self.walls) > -1:
sprite.move_back(dt)
elif sprite.feet.collidelist(self.elementals) > -1:
sprite.move_back(dt)
elif sprite.feet.collidelist(self.npcs) > -1:
sprite.move_back(dt)
elif sprite.name == 'elemental':
if sprite.feet.collidelist(self.walls) > -1:
sprite.move_back(dt)
elif sprite.feet.collidelist(self.heroes) > -1:
sprite.move_back(dt)
elif sprite.name == 'projectile':
collide_elemental = sprite.rect.collidelist(self.elementals)
if sprite.rect.collidelist(self.walls) > -1:
self.group.remove(sprite)
elif collide_elemental > -1:
self.group.remove(sprite)
self.group.remove(self.elementals[collide_elemental])
self.elementals.pop(collide_elemental)
self.sounds.monster_kill.play()
def run(self):
""" Run the game loop"""
self.running = True
self.music_channel.play(self.sounds.town_theme, -1)
text = [
'We, the people of Polaria have summoned thee, the Lord of Light!\n\nPress enter to continue.',
'Our beloved town has been overrun by evil dark elementals! Their dark magic can only be fought with the magic of Light!\n\nPress Enter to continue.',
'Use WASD to move around and the arrow keys to cast your spells. You can switch spells with keys 1-4.\n\nPress Enter to continue.',
'Good luck! And may the power of Light be with you!\n\nPress enter to continue.'
]
self.run_dialog(text)
while self.running:
dt = self.clock.tick(60) / 1000.
self.handle_input()
self.update(dt)
if len(self.elementals) <= 0:
self.run_dialog([
"Congratulations! You saved our town! Polaria is safe once more!"
])
self.running = False
else:
self.draw(self.screen)
pygame.display.update()
def run_dialog(self, text):
self.update(0)
while text:
self.clock.tick(60)
self.draw(self.screen, text[0])
if self.handle_dialog_box_input():
text.remove(text[0])
pygame.display.update()
def spawn_elementals(self):
"""Spawn elementals in random positions on the map."""
self.elementals = list()
count = 0
while count < 100:
x = randint(0, 1120)
y = randint(0, 1120)
elemental = Elementals()
elemental.position = self.map_layer.map_rect.move(x, y).topleft
elemental.set_rect(x, y)
if elemental.rect.collidelist(self.walls) == -1:
self.elementals.append(elemental)
self.group.add(elemental)
count += 1
def handle_dialog_box_input(self):
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RETURN:
return True
if event.key == K_ESCAPE or event.key == K_q:
sys.exit()
if event.type == VIDEORESIZE:
init_screen(event.w, event.h)
self.map_layer.set_size((event.w, event.h))
class QuestGame(object):
""" This class is a basic game.
This class will load data, create a pyscroll group, a hero object.
It also reads input and moves the Hero around the map.
Finally, it uses a pyscroll group to render the map and Hero.
"""
filename = get_map(MAP_FILENAME)
def __init__(self, state):
if state == False:
screenMode = pygame.RESIZABLE
# true while running.
self.running = False
self.clock = pygame.time.Clock()
self.direction = "still"
self.fps = 180
self.counter = 1
self.counter2 = 1
heroPos1 = False
# load data from pytmx
tmx_data = load_pygame(self.filename)
mapPlay = load_pygame(get_map(stats['map']))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(mapPlay)
# setup level geometry with simple pygame rects, loaded from pytmx.
self.walls = list()
for object in mapPlay.objects:
self.walls.append(pygame.Rect(
object.x, object.y,
object.width, object.height))
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data, screen.get_size())
self.map_layer.zoom = 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=4)
self.hero = Hero('Tiles/character/character_still.png')
self.hero.position = stats['pos']
# add our hero to the group
self.group.add(self.hero)
def map_change(self, map):
mapfile = get_map(map)
tmx_data = load_pygame(mapfile)
print(tmx_data)
map_data = pyscroll.data.TiledMapData(tmx_data)
self.walls = list()
for object in tmx_data.objects:
self.walls.append(pygame.Rect(
object.x, object.y,
object.width, object.height))
self.map_layer = pyscroll.BufferedRenderer(map_data, screen.get_size())
self.map_layer.zoom = 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=4)
self.hero = Hero('Tiles/character/character_still.png')
self.hero.position = self.map_layer.map_rect.center
def switcher(self):
if len(doorX) == len(doorY) == len(targetPosX) == len(targetPosY) == len(currentMap) == len(targetMap) == len(animationDirection) == len(targetMapFile):
for i in range(len(doorX)):
if self.map == currentMap[i]:
if self.hero.position[0] - 15 <= doorX[i] <= self.hero.position[0] + 15:
print("OK!")
if self.hero.position[1] - 15 <= doorY[i] <= self.hero.position[1] + 15:
self.map_change(targetMapFile[i])
self.map = targetMap[i]
stats['map'] = targetMapFile[i]
heroPos = (targetPosX[i], targetPosY[i])
self.animation(animationDirection[i], 1)
self.hero.position = heroPos
print("Yeah!")
break
else:
print("Nope!")
print(str(doorX[i]) +" " +str(self.hero.position[0]))
print(str(doorY[i]) +" " +str(self.hero.position[1]))
else:
#print("Never!")
pass
else:
print("Error: Invalid number of door entries.")
## elif self.map == "maze1":
## #HOUSE2
## if self.hero.position[0] >= -20 and self.hero.position[0] <= 20 and self.hero.position[1] <= 20 and self.hero.position[1] >= -15:
## self.map_change(HOUSE1)
## stats['map'] = HOUSE1
## self.map = "house1"
## heroPos = 206, 48
## self.animation("down", 1)
## self.hero.position = heroPos
## self.group.remove(self)
## self.group.empty()
## self.group.add(self.hero)
def draw(self, surface):
self.group.center(self.hero.rect.center)
# draw the map and all sprites
self.group.draw(surface)
def handle_input(self, keyset):
""" Handle pygame input events
"""
poll = pygame.event.poll
event = poll()
while event:
if event.type == QUIT:
self.running = False
pygame.quit()
break
elif event.type == KEYDOWN:
if keyset == "game":
if event.key == K_EQUALS:
self.map_layer.zoom += .25
elif event.key == K_MINUS:
value = self.map_layer.zoom - .25
if value > 0:
self.map_layer.zoom = value
elif event.key == K_KP0:
self.switcher()
pass
elif event.key == K_e:
self.menu = "inventory"
print("Inventory")
pass
if event.key == K_ESCAPE:
pickle.dump(stats, open(os.path.join("data", "saves", "save.dat"), "wb"))
pickle.dump(inventory, open(os.path.join("data", "saves", "inventory.dat"), "wb"))
self.running = False
pygame.quit()
print(" ")
sleep(0.5)
print("Shutdown... Complete")
sys.exit()
break
if keyset == "inventory":
if event.key == K_ESCAPE:
self.menu = "game"
print("Game")
pass
if event.key == K_r:
self.genchests()
elif event.key == K_KP1:
self.menu = "game"
print("Game")
pass
elif event.key == K_KP2:
self.map_change(FOREST)
self.map = "forest"
elif event.key == K_KP3:
self.menu = "inventory"
print("Inventory")
pass
elif event.key == K_KP4:
pass
elif event.key == K_KP5:
pass
elif event.key == K_KP6:
print("X :" +str(self.hero.position[0]) +", Y: " +str(self.hero.position[1]))
pass
elif event.key == K_KP7:
print(str(pygame.mouse.get_pos()))
pass
elif event.key == K_KP8:
sleep(0.5)
elif event.key == K_KP9:
self.genchests()
pass
elif event.key == K_F11:
pygame.display.toggle_fullscreen()
elif event.type == VIDEORESIZE:
self.map_layer.set_size((event.w, event.h))
dispHeight = event.h
dispWidth = event.w
event = poll()
# using get_pressed is slightly less accurate than testing for events
# but is much easier to use.
if keyset == "game":
pressed = pygame.key.get_pressed()
if pressed[K_UP]:
self.hero.velocity[1] = -HERO_MOVE_SPEED
self.direction = "up"
self.direction2 = "up"
elif pressed[K_DOWN]:
self.hero.velocity[1] = HERO_MOVE_SPEED
self.direction = "down"
self.direction2 = "down"
elif pressed[K_w]:
self.hero.velocity[1] = -HERO_SPRINT_SPEED
self.direction = "up"
self.direction2 = "up"
elif pressed[K_s]:
self.hero.velocity[1] = HERO_SPRINT_SPEED
self.direction = "down"
self.direction2 = "down"
else:
self.hero.velocity[1] = 0
self.direction2 = "still"
if pressed[K_LEFT]:
self.hero.velocity[0] = -HERO_MOVE_SPEED
self.direction = "left"
self.direction2 = "left"
elif pressed[K_RIGHT]:
self.hero.velocity[0] = HERO_MOVE_SPEED
self.direction = "right"
self.direction2 = "right"
elif pressed[K_a]:
self.hero.velocity[0] = -HERO_SPRINT_SPEED
self.direction = "left"
self.direction2 = "left"
elif pressed[K_d]:
self.hero.velocity[0] = HERO_SPRINT_SPEED
self.direction = "right"
self.direction2 = "right"
else:
self.hero.velocity[0] = 0
self.direction1 = "still"
if self.direction1 == "still" and self.direction2 == "still":
self.direction = "still"
def update(self, dt):
""" Tasks that occur over time should be handled here
"""
self.group.update(dt)
# check if the sprite's feet are colliding with wall
# sprite must have a rect called feet, and move_back method,
# otherwise this will fail
for sprite in self.group.sprites():
if sprite.feet.collidelist(self.walls) > -1:
sprite.move_back(dt)
def animation(self, direction, number):
self.counter += 1
if self.direction1 == "still" and self.direction2 == "still":
if self.direction == "left":
self.hero = Hero('Tiles/character/walking_left/walking_left1.png')
if self.direction == "right":
self.hero = Hero('Tiles/character/walking_right/walking_right1.png')
if self.direction == "up":
self.hero = Hero('Tiles/character/walking_up/walking_up1.png')
if self.direction == "down":
self.hero = Hero('Tiles/character/walking_down/walking_down1.png')
else:
self.hero = Hero('Tiles/character/walking_' +direction +'/walking_' +direction +str(number) +'.png')
self.group.remove(self)
self.group.empty()
self.group.add(self.hero)
def genchests(self):
itm1, itm2, itm3, itm4, itm5, itm6 = "0", "0", "0", "0", "0", "0"
numberItems = random.randint(1, 6)
for i in range(0, numberItems):
item = random.randint(1, 5)
if i == 1:
itm1 = item
if i == 2:
itm2 = item
if i == 3:
itm3 = item
if i == 4:
itm4 = item
if i == 5:
itm5 = item
if i == 6:
itm6 = item
print("Found Chest With "+str(numberItems) +" Items: " +str(itm1) +" " +str(itm2) +" " +str(itm3) +" " +str(itm4) +" " +str(itm5) +" " +str(itm6) +" ")
if 1 in(itm1, itm2, itm3, itm4, itm5, itm6):
inventory['sword'] = True
else:
inventory['sword'] = False
if 2 in(itm1, itm2, itm3, itm4, itm5, itm6):
inventory['axe'] = True
else:
inventory['axe'] = False
if 3 in(itm1, itm2, itm3, itm4, itm5, itm6):
inventory['shovel'] = True
else:
inventory['shovel'] = False
if 4 in(itm1, itm2, itm3, itm4, itm5, itm6):
inventory['bow'] = True
else:
inventory['bow'] = False
def run(self):
screenMode = pygame.RESIZABLE
self.map = stats['map'][:-4].lower()
self.map = self.map.lstrip("maps/")
oldPlay = stats['playTime']
clock = pygame.time.Clock()
self.running = True
debug = True
dispWidth, dispHeight = 1024, 768
self.menu = "game"
game_time = pygame.time.get_ticks()
playTime = font.render("Timer: ", False, pygame.Color('white'))
minutes = 0
try:
while self.running:
dt = (clock.tick() / 500)
clock.tick(self.fps)
if self.counter2 == 5:
heroPos = self.hero.position
self.animation(self.direction, self.counter)
self.counter += 1
self.counter2 = 0
guiX = (dispWidth / 2) - 175
guiY = (dispHeight / 2) - 165
self.hero.position = heroPos
self.counter2 += 1
if self.counter > 9:
self.counter = 1
stats['pos'] = self.hero.position
currentTime = systime()
seconds = currentTime - gameStart + oldPlay
dispWidth, dispHeight = pygame.display.get_surface().get_size()
stats['playTime'] = seconds
self.group.remove(self)
self.group.add(self.hero)
if debug == True:
location = font.render("Position: " + str(round(round(self.hero.position[0], -1) / 10)) + ", " + str(round(round(self.hero.position[1], -1) / 10)), False, pygame.Color('white'))
fps = font.render("FPS:" + str(int(clock.get_fps())), False, pygame.Color('white'))
mapdebug = font.render("Map Name: " + str(self.map), False, pygame.Color('white'))
minutes = seconds // 60
secondsDisp = seconds % 60
if minutes < 1:
minutes = 0
if secondsDisp == 60:
secondsDisp = 0
minutes += 1
playTime = font.render("Timer: " + str(floor(minutes)) + " : " + str(round(secondsDisp)), True, pygame.Color('white'))
screen.blit(playTime, (50,100))
screen.blit(fps, (50, 50))
screen.blit(location, (50,75))
screen.blit(mapdebug, (50, 125))
if self.menu == "inventory":
screen.blit(load_image(os.path.join("Images", "transparent.png")),( 0, 0))
screen.blit(load_image(os.path.join("Images", "inventory.png")),(guiX, guiY))
if inventory["sword"] == True:
screen.blit(load_image(os.path.join("Images", "sword.png")),( guiX + 16, guiY + 168))
if inventory["axe"] == True:
screen.blit(load_image(os.path.join("Images", "axe.png")),( guiX + 52, guiY + 168))
if inventory["bow"] == True:
screen.blit(load_image(os.path.join("Images", "bow.png")),( guiX + 88, guiY + 168))
if inventory["shovel"] == True:
screen.blit(load_image(os.path.join("Images", "shovel.png")),( guiX + 124, guiY + 168))
pygame.display.update()
self.handle_input(self.menu)
self.update(dt)
self.draw(screen)
except KeyboardInterrupt:
self.running = False
pygame.quit()
class BinalGame(object):
""" This class is a basic game.
This class will load data, create a pyscroll group, a hero object.
It also reads input and moves the Hero around the map.
Finally, it uses a pyscroll group to render the map and Hero.
"""
filename = get_map(MAP_FILENAME)
def __init__(self, filename, oldEntrance=None, oldmap=None, hero=None):
self.portalName = ''
self.portalsIn = list()
self.portalsOut = list()
self.olfFilename = None
self.filename = get_map(filename)
if self.filename in heroStates:
self.mode = heroStates[self.filename]
else:
self.mode = "Peaceful"
if oldmap == None:
self.oldMap = filename
else:
self.oldMap = oldmap
overworld = 'BinalOverworld2.tmx'
self.oldEntrance = oldEntrance
self.battleInstance = False
# true while running
self.running = False
# load data from pytmx
tmx_data = load_pygame(self.filename)
# setup level geometry with simple pygame rects, loaded from pytmx
self.walls = list()
for object in tmx_data.objects:
self.walls.append(
pygame.Rect(object.x, object.y, object.width, object.height))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(tmx_data)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data,
screen.get_size(),
clamp_camera=False,
tall_sprites=1)
self.map_layer.zoom = 2
# pyscroll supports layered rendering. our map has 3 'under' layers
# layers begin with 0, so the layers are 0, 1, and 2.
# since we want the sprite to be on top of layer 1, we set the default
# layer for sprites as 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=2)
self.hero = Hero()
# put the hero in the center of the map
# self.hero.position = self.map_layer.map_rect.center
# self.hero._position[0] += 200
# self.hero._position[1] += 400
# add our hero to the group
self.group.add(self.hero)
# startpoints
self.startpoints = []
for object in tmx_data.objects:
if object.name == "startpoint":
self.startpoints.append((object.x, object.y))
self.hero.position = (self.startpoints[0][0], self.startpoints[0][1])
self.oldPosition = self.hero.position
self.group.add(self.hero)
self.steps = 0
self.battle = 1
# set default zoom when not in overworld
if self.oldMap == overworld and self.filename != "data/" + overworld:
self.map_layer.zoom = self.map_layer.zoom - .25
self.portalNames = list()
# add portals to collider lists
for object in tmx_data.objects:
if object.type == "portalIn":
self.portalNames.append(object)
self.portalsIn.append(
pygame.Rect(object.x, object.y, object.width,
object.height))
elif object.type == "portalO":
self.portalsOut.append(
pygame.Rect(object.x, object.y, object.width,
object.height))
def draw(self, surface):
# center the map/screen on our Hero
self.group.center(self.hero.rect.center)
# draw the map and all sprites
self.group.draw(surface)
def nearestPortal(self, trigger=False):
(x, y) = self.hero.position
for portal in self.portalsIn:
if trigger == False:
trigger = True
self.oldEntrance = (portal.x, portal.y)
(p, q) = self.oldEntrance
distanceNew = (math.sqrt((x - portal.x)**2 + (y - portal.y)**2))
distanceOld = (math.sqrt((x - p)**2 + (y - q)**2))
if distanceNew < distanceOld:
distanceOld = distanceNew
self.oldEntrance = (portal.x, portal.y)
(p, q) = (portal.x, portal.y)
for portal in self.portalNames:
if self.almostEqual((p, q), (portal.x, portal.y)):
self.portalName = portal.name
def handle_input(self):
""" Handle pygame input events
"""
poll = pygame.event.poll
clock = pygame.time.Clock()
event = poll()
while event:
ticks = pygame.time.get_ticks()
if event.type == QUIT:
self.running = False
break
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.running = False
break
elif event.key == K_EQUALS:
self.map_layer.zoom += .25
elif event.key == K_MINUS:
value = self.map_layer.zoom - .25
if value > 0:
self.map_layer.zoom = value
# this will be handled if the window is resized
elif event.type == VIDEORESIZE:
init_screen(event.w, event.h)
self.map_layer.set_size((event.w, event.h))
event = poll()
# using get_pressed is slightly less accurate than testing for events
# but is much easier to use.
pressed = pygame.key.get_pressed()
# if pressed[K_UP]:
# self.hero.velocity[1] = -HERO_MOVE_SPEED
# elif pressed[K_DOWN]:
# self.hero.velocity[1] = HERO_MOVE_SPEED
# else:
# self.hero.velocity[1] = 0
# if pressed[K_LEFT]:
# self.hero.velocity[0] = -HERO_MOVE_SPEED
# elif pressed[K_RIGHT]:
# self.hero.velocity[0] = HERO_MOVE_SPEED
# else:
# self.hero.velocity[0] = 0
# if self.moving != False:
ticks = pygame.time.get_ticks()
if pressed[K_UP]:
self.hero.currImageList = self.hero.downs
self.hero.walkAnimation(ticks)
self.hero.velocity[1] = -HERO_MOVE_SPEED
#self.steps += 1
elif pressed[K_DOWN]:
self.hero.currImageList = self.hero.ups
self.hero.walkAnimation(ticks)
self.hero.velocity[1] = HERO_MOVE_SPEED
#self.steps += 1
else:
self.hero.velocity[1] = 0
if pressed[K_LEFT]:
self.hero.currImageList = self.hero.lefts
self.hero.walkAnimation(ticks)
self.hero.velocity[0] = -HERO_MOVE_SPEED
#self.steps += 1
elif pressed[K_RIGHT]:
self.hero.currImageList = self.hero.rights
self.hero.walkAnimation(ticks)
self.hero.velocity[0] = HERO_MOVE_SPEED
#self.steps += 1
else:
self.hero.velocity[0] = 0
# sprint
if pressed[K_SPACE]:
self.hero.velocity[0] *= 1.7
self.hero.velocity[1] *= 1.7
# more likely to battle encounter if sprinting
# if self.hero.velocity[0] > 0 or self.hero.velocity[1] > 0:
# #self.steps += 2
# if self.hero.velocity[0] >= 1.5 * HERO_MOVE_SPEED:
# pass
# if self.hero.velocity[1] >= 1.5 * HERO_MOVE_SPEED:
# pass
# stops character from moving when battlescreen is initiated
#if self.mode == "Battle":
# (self.hero.velocity[0], self.hero.velocity[1]) = (0, 0)
def update(self, dt):
""" Tasks that occur over time should be handled here
"""
self.group.update(dt)
# check if the sprite's feet are colliding with wall
# sprite must have a rect called feet, and move_back method,
# otherwise this will fail
for sprite in self.group.sprites():
if sprite.feet.collidelist(self.portalsIn) > -1:
if sprite.type == "hero":
self.nearestPortal()
self.filename = inPortalDict[self.filename +
self.portalName]
self.hero.position = (self.startpoints[0][0],
self.startpoints[0][1])
elif sprite.feet.collidelist(self.portalsOut) > -1:
if sprite.type == "hero":
filename = outPortalDict[self.filename]
self.filename = filename
self.hero.position = (self.startpoints[0][0],
self.startpoints[0][1])
if sprite.feet.collidelist(self.walls) > -1:
sprite.move_back(dt)
# plays music based on map file keyed to dictionary
# also covers changing map sound effect
# def changeMusicAndInstance(self, surface, oldMusic=None):
# tmap = self.filename
# song = MusicDict[tmap]
# # instance change sound, from Zelda stairs sound
# playSound("Enter.wav", .15)
# if oldMusic == None:
# oldMusic = MusicDict[self.oldMap]
# if self.mode != "Overworld":
# if song == oldMusic: return None
# # loops music indefinitely for that map
# playMusic(song)
# def showStartScreen(self):
# self.draw('title_demo')
# if checkForKeyPress():
# self.run()
@staticmethod
def almostEqual(position1, position2):
(x1, y1) = position1
(x2, y2) = position2
epsilon = 60
if abs(x1 - x2) < epsilon:
if abs(y1 - y2) < epsilon:
return True
return False
def randomBattle(self):
# prevents battle from happening right on town portal
for sprite in self.group.sprites():
if sprite.feet.collidelist(self.portalsIn) > -1:
return None
if self.almostEqual(position, self.oldPosition):
return None
if self.mode == "Peaceful" or self.mode == "Battle":
return None
diceRoll = random.randint(0, 100)
#increased encounter rate when walking without encountering
# a single battle for a certain number of steps
threshold = 600
if self.steps > threshold:
if diceRoll < 50:
self.mode = "Battle"
self.steps = 0
if self.steps > 200:
# lower encounter rate when just beginning to walk
if diceRoll < 200:
self.mode = "Battle"
self.steps = 0
self.oldPosition = position
def run(self):
""" Run the game loop
"""
filename = self.filename
clock = pygame.time.Clock()
self.running = True
from collections import deque
times = deque(maxlen=30)
#idle hero animation
ticks = pygame.time.get_ticks()
self.hero.walkAnimation(ticks)
playMusic('overworld.wav')
try:
while self.running:
dt = clock.tick() / 1000.
times.append(clock.get_fps())
# print(sum(times)/len(times))#idle hero animation
ticks = pygame.time.get_ticks()
self.hero.walkAnimation(ticks)
# beginning of random battle
# self.randomBattle()
# changing map
if self.filename != filename:
# leaving map toward overworld
if self.oldMap == os.path.join(RESOURCES_DIR,
self.filename):
oldMap = inPortalDict[
str(os.path.join(RESOURCES_DIR, self.filename)) +
self.portalName]
else:
oldMap = outPortalDict[str(
os.path.join(RESOURCES_DIR, self.filename))]
self.__init__(self.filename, self.oldEntrance, oldMap,
self.hero)
self.oldEntrance = OldEntranceDict[filename]
if os.path.join(RESOURCES_DIR,
outPortalDict[filename]) == self.filename:
if self.oldEntrance != None:
position = (self.oldEntrance[0],
self.oldEntrance[1])
self.hero.position = position
self.oldPosition = position
self.run()
self.handle_input()
self.update(dt)
self.draw(screen)
pygame.display.flip()
except KeyboardInterrupt:
self.running = False
class QuestGame(object):
""" This class is a basic game.
This class will load data, create a pyscroll group, a hero object.
It also reads input and moves the Hero around the map.
Finally, it uses a pyscroll group to render the map and Hero.
"""
filename = get_map(MAP_FILENAME)
def __init__(self):
# true while running
self.running = True
self.time_step = 0
# load data from pytmx
tmx_data = load_pygame(self.filename)
# setup level geometry with simple pygame rects, loaded from pytmx
self.walls = list()
for object in tmx_data.objects:
self.walls.append(
pygame.Rect(object.x, object.y, object.width, object.height))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(tmx_data)
# create new renderer (camera)
screens = screen.get_size()
self.map_layer = pyscroll.BufferedRenderer(map_data, (10, 40),
clamp_camera=True,
tall_sprites=1)
self.map_layer.zoom = 0.75
# pyscroll supports layered rendering. our map has 3 'under' layers
# layers begin with 0, so the layers are 0, 1, and 2.
# since we want the sprite to be on top of layer 1, we set the defaultmm m,m
# layer for sprites as 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=3)
self.hero = Hero()
# put the hero in the center of the map
self.hero.vi_tri[0] += 200
self.hero.vi_tri[1] += 100
# add our hero to the group
self.group.add(self.hero)
self.map_layer.set_size(screens)
def draw(self, surface):
# center the map/screen on our Hero
self.group.center(self.hero.rect)
# draw the map and all sprites
self.group.draw(surface)
def handle_input(self, dt):
""" xử lý sự kiện nhấn nút """
for event in pygame.event.get():
if event.type == pygame.QUIT:
if event.key == pygame.K_ESCAPE:
return False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
return False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
self.hero.go_left(dt)
if event.key == pygame.K_RIGHT:
self.hero.go_right(dt)
if event.key == pygame.K_UP:
for sprite in self.group.sprites():
if sprite.feet.collidelist(self.walls) > -1:
self.hero.jump(dt)
else:
self.hero.stop(dt)
def update(self, dt):
""" Tasks that occur over time should be handled here
"""
self.group.update(dt)
# check if the sprite's feet are colliding with wall
# sprite must have a rect called feet, and move_back method,
# otherwise this will fail
for sprite in self.group.sprites():
if sprite.feet.collidelist(self.walls) > -1:
self.hero.move_back(dt)
self.hero.va_cham = True
else:
self.hero.vi_tri[1] += 2
print(self.hero.direction)
def run(self):
""" Run the game loop
"""
clock = pygame.time.Clock()
self.running = True
from collections import deque
times = deque(maxlen=30)
try:
while self.running:
dt = clock.tick() / 1000.
times.append(clock.get_fps())
#print(sum(times)/len(times))
self.handle_input(dt)
self.update(dt)
self.draw(screen)
pygame.display.flip()
except KeyboardInterrupt:
self.running = False
class QuestGame(object):
""" This class is a basic game.
This class will load data, create a pyscroll group, a hero object.
It also reads input and moves the Hero around the map.
Finally, it uses a pyscroll group to render the map and Hero.
"""
filename = get_map(MAP_FILENAME)
counter = 1
counter2 = 1
def __init__(self, state):
if state == False:
self.fullscreen = False
# true while running.
self.running = False
self.clock = pygame.time.Clock()
# create all the directio variables
self.direction = "still"
self.EntityDirection = "still"
self.EntityDirection1, self.EntityDirection2 = "still", "still"
self.fps = 1000
self.bypass = False
entityPos1, heroPos1 = False, False
# load data from pytmx
tmx_data = load_pygame(self.filename)
self.tmx_data = tmx_data
mapPlay = load_pygame(get_map(stats['map']))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(mapPlay)
# setup level geometry with simple pygame rects, loaded from pytmx.
self.walls = list()
for object in mapPlay.objects:
self.walls.append(pygame.Rect(
object.x, object.y,
object.width, object.height))
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data, screen.get_size())
self.map_layer.zoom = 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=4)
self.hero = Hero('Tiles/hero/character_still.png')
self.entity = Entity('Tiles/hero/character_still.png')
self.hero.position = stats['pos']
self.entity.position = stats['pos']
# add our hero to the group
self.group.add(self.hero)
#self.group.add(self.entity)
self.entVel = (0, 0)
def deep_thought(self): # The 'AI' function, needs work
if self.counter2 % 75 == 0 or self.bypass == True:
self.bypass = False
if random.randint(0, 1) == 1:
self.entity.velocity[0], self.entity.velocity[1] = 0, 0
movement = random.choice(["self.entity.velocity[0] = -45; self.EntityDirection = 'left'; self.EntityDirection2 = 'left'",
"self.entity.velocity[0] = 45; self.EntityDirection = 'right'; self.EntityDirection2 = 'right'",
"self.entity.velocity[1] = -45; self.EntityDirection = 'up'; self.EntityDirection1 = 'up'",
"self.entity.velocity[1] = 45; self.EntityDirection = 'down'; self.EntityDirection1 = 'down'"])
exec(movement)
def EntityAnimation(self, direction, number, character="hero"):
self.entVel = self.entity.velocity
self.counter += 1
if self.EntityDirection1 == "still" and self.EntityDirection2 == "still":
if self.EntityDirection == "left":
self.entity = Entity('Tiles/' +character +'/walking_left/walking_left1.png')
if self.EntityDirection == "right":
self.entity = Entity('Tiles/' +character +'/walking_right/walking_right1.png')
if self.EntityDirection == "up":
self.entity = Entity('Tiles/' +character +'/walking_up/walking_up1.png')
if self.EntityDirection == "down":
self.entity = Entity('Tiles/' +character +'/walking_down/walking_down1.png')
else:
self.entity = Entity('Tiles/' +character +'/walking_' +direction +'/walking_' +direction +str(number) +'.png')
self.entity.velocity = self.entVel
def EntMoveBack(self):
#self.deep_thought(self, True) # Comment this to disable the 'AI'
pass
def map_change(self, map, target=False): # Does what it says on the tin
mapfile = get_map(map)
tmx_data = load_pygame(mapfile)
self.tmx_data = tmx_data
map_data = pyscroll.data.TiledMapData(tmx_data)
self.walls = list()
for object in tmx_data.objects:
self.walls.append(pygame.Rect(
object.x, object.y,
object.width, object.height))
# creates new 'camera'
self.map_layer = pyscroll.BufferedRenderer(map_data, screen.get_size())
self.map_layer.zoom = 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=4)
#creates a new Hero to go on our new camera
self.hero = Hero('Tiles/hero/character_still.png')
try:
self.hero.position = (target)
except TypeError:
self.hero.position = self.map_layer.map_rect.center
self.map = stats['map'][:-4].lower()
self.map = self.map.lstrip("m") # Fix that stupid bug that changes "maze1" to "ze1"
self.map = self.map.lstrip("aps/")
def switcher(self): # Bunch of IF statements to decide if we're at a door or not, then changes the map.
if len(objectX) == len(objectY) == len(targetPosX) == len(targetPosY) == len(currentMap) == \
len(targetMap) == len(animationDirection) == len(targetMapFile) == len(objectType):
heroPos = [0, 0]
heroPos[0], heroPos[1] = self.hero.position[0], self.hero.position[1]
for i in range(len(objectX)):
if self.map == currentMap[i]:
if self.hero.position[0] - 15 <= int(objectX[i]) <= self.hero.position[0] + 15:
if self.hero.position[1] - 15 <= int(objectY[i]) <= self.hero.position[1] + 15:
if objectType[i] == "door":
used[i] = True
self.map_change(targetMapFile[i])
self.map = targetMap[i]
stats['map'] = targetMapFile[i]
heroPos = (int(targetPosX[i]), int(targetPosY[i]))
self.animation(animationDirection[i], 1)
self.hero.position = heroPos
return False
elif objectType[i] == "chest":
keyset, self.menu = "chest", "chest"
if used[i] == False:
if chestContents[i] == None and used[i] == False:
used[i] = True
pickle.dump(used, open(os.path.join("data", "saves", "used.dat"), "wb"))
chestContents[i] = self.genchests()
pickle.dump(chestContents, open(os.path.join("data", "saves", "chestContents.dat"), "wb"))
self.chestNo = i
return False
def generate_surrounding_maps(self):
heroPos = [0, 0]
heroPos = self.hero.position
if int(self.hero.position[0]) in range((self.tmx_data.width*32)-64,
(self.tmx_data.width*32)):
target = (32, heroPos[1])
self.grid[0] = self.grid[0]+1
try:
self.map_change(str(self.grid[0]+1) +", "+ str(self.grid[1]) +".tmx",
target)
self.map = str(self.grid).lstrip("[").rstrip("]")
stats['map'] = self.map + ".tmx"
self.animation("right", 1)
target = (32, heroPos[1])
#self.hero.position = target
except FileNotFoundError:
self.generate_new_map(4, 16, 2, self.grid, target)
elif int(self.hero.position[1]) in range((self.tmx_data.height*32)-64,
self.tmx_data.width*32):
target = (heroPos[0], 32)
self.grid[1] = self.grid[1]+1
try:
self.map_change(str(self.grid[0]) +", "+ str(self.grid[1]+1) +".tmx",
target)
self.map = str(self.grid).lstrip("[").rstrip("]")
stats['map'] = self.map + ".tmx"
heroPos[0], heroPos[1] = self.hero.position[0], self.hero.position[1]
self.animation("up", 1)
except FileNotFoundError:
self.generate_new_map(4, 16, 2, self.grid, target)
elif int(self.hero.position[0]) in range(0, 64):
target = (self.tmx_data.width*32 - 32, heroPos[1])
self.grid[0] = self.grid[0]-1
try:
self.map_change(str(self.grid[0]-1) +", "+ str(self.grid[1]) +".tmx",
target)
self.map = str(self.grid).lstrip("[").rstrip("]")
stats['map'] = self.map + ".tmx"
heroPos[0], heroPos[1] = self.hero.position[0], self.hero.position[1]
self.animation("left", 1)
#self.hero.position = target
except FileNotFoundError:
self.generate_new_map(4, 16, 2, self.grid, target)
elif int(self.hero.position[1]) in range(0, 64):
target = (heroPos[0], self.tmx_data.height*32 - 32)
self.grid[1] = self.grid[1]-1
try:
self.map_change(str(self.grid[0]) +", "+ str(self.grid[1]-1) +".tmx",
target)
self.map = str(self.grid).lstrip("[").rstrip("]")
stats['map'] = self.map + ".tmx"
heroPos[0], heroPos[1] = self.hero.position[0], self.hero.position[1]
self.animation("down", 1)
#self.hero.position = target
except FileNotFoundError:
self.generate_new_map(4, 16, 2, self.grid, target)
else:
pass
def generate_new_map(self, octaves, freq, area, target, position):
command = "{}/lib/generate/__init__.py".format(os.getcwd())
if sys.platform.startswith('win32'):
executeable = ("Python35\python.exe")
elif sys.platform.startswith('linux'):
executeable = ("python3.5")
for y in range(self.grid[1] + eval("-"+ str(area)),self.grid[1] + area):
for x in range(self.grid[0] + eval("-"+ str(area)),self.grid[0] + area):
if os.path.isfile("data/maps/"+str(x)+", "+str(y)+".tmx"):
pass
else:
p = subprocess.Popen([executeable, command, ("data/maps/"+
str(x)+", "+str(y)+".tmx"),
str(octaves), str(freq), str(x), str(y)],
close_fds=True)
try:
if p is not None:
disp_width, disp_height = pygame.display.get_surface().get_size()
#self.blit_inventory("speach", "Generating Map... Please Wait...")
self.speach(disp_width, disp_height,
"Generating Map... Please Wait...")
pygame.display.update()
p.wait()
self.map_change((str(target[0])+", "+str(target[1])+".tmx"), position)
self.map = str(self.grid).lstrip("[").rstrip("]")
stats['map'] = self.map + ".tmx"
except UnboundLocalError:
pass
def draw(self, surface):
self.group.center(self.hero.rect.center)
# draw the map and all sprites
self.group.draw(surface)
def speach(self, dispWidth, dispHeight, text):
## text = "Laudem bonorum salutandi pri te, tollit melius delicata mel cu,\
## eu mea ullum legimus. Probo debitis te vel. Labores vulputate \
## argumentum sea id. Cibo vitae vocent eos no, ne odio molestiae\
## duo."
screen.blit(pygame.transform.scale(load_image(os.path.join(
"images", "gui", "speach.png")), (dispWidth, 150)), (0, dispHeight-150))
text = textwrap.wrap(text, width=95)
for i, line in enumerate(text):
text_blit = pixel_font.render(line, False, pygame.Color('white'))
screen.blit(text_blit, (60, dispHeight-110 + 25*i))
def map_generate(self, output, octaves, freq, x, y):
command = "{}/lib/generate/__init__.py".format(os.getcwd())
if sys.platform.startswith('win32'):
executeable = ("Python35\python.exe")
elif sys.platform.startswith('linux'):
executeable = ("python3.5")
subprocess.Popen([executeable, command, output, str(octaves), str(freq),
str(x), str(y)],close_fds=True)
def handle_input(self, keyset):
""" Handle pygame input events
"""
poll = pygame.event.poll
event = poll()
while event:
if event.type == QUIT:
self.running = False
pygame.quit()
break
elif event.type == KEYDOWN:
if keyset == "game":
if event.key == K_EQUALS:
self.map_layer.zoom += .25
elif event.key == K_MINUS:
value = self.map_layer.zoom - .25
if value > 0:
self.map_layer.zoom = value
else:
self.map_layer.zoom = 0.1
elif event.key == K_KP0:
try:
if self.switcher() == True:
self.generate_surrounding_maps()
except FileNotFoundError:
print("Exception Caught")
pass
elif event.key == K_e:
self.menu = "inventory"
pass
if event.key == K_ESCAPE:
for i in attack_stats_types:
stats[i] = attack_stats[i]
pickle.dump(stats, open(os.path.join("data", "saves", "save.dat"), "wb"))
pickle.dump(inventory, open(os.path.join("data", "saves", "inventory.dat"), "wb"))
self.running = False
pygame.quit()
print(" ")
sleep(0.5)
print("Shutdown... Complete")
sys.exit()
break
if keyset != "game":
if event.key == K_ESCAPE:
self.menu = "game"
pass
if keyset == "inventory":
if event.key == K_r:
self.genchests()
if keyset == "chest":
if event.key == K_r:
chestContents[self.chestNo] = self.genchests()
if event.key == K_t:
if taken[self.chestNo] != True:
self.takeChest()
taken[self.chestNo] = True
pickle.dump(taken, open(os.path.join("data", "saves", "taken.dat"), "wb"))
if keyset == "attack":
pass
#Basically just debug keys
if event.key == K_KP1:
self.menu = "game"
pass
elif event.key == K_KP2:
self.map_change(FOREST)
self.map = "forest"
elif event.key == K_KP3:
self.generate_new_map(4, 16, 3)
pass
elif event.key == K_KP4:
self.map_generate(str(self.grid[0]) +", "+ str(self.grid[1]) +".tmx", 4, 16.0, self.grid[0], self.grid[1])
pass
elif event.key == K_KP5:
self.enemy_stats = self.gen_enemy(attack_stats, enemy_stats)
self.menu = "attack"
pass
elif event.key == K_KP6:
print("X :" +str(int(self.hero.position[0])) +
", Y: " +str(int(self.hero.position[1])) +
", Map: "+ self.map)
pass
elif event.key == K_KP7:
print(str(pygame.mouse.get_pos()))
pass
elif event.key == K_KP8:
sleep(0.5)
elif event.key == K_KP9:
editor = db_interface.Editor()
conn = sqlite3.connect('data/saves/data.db')
c = conn.cursor()
for var in vars:
exec("del "+var+"[:]")
for data in c.execute("SELECT {} FROM csv".format(var)):
data = str(data[0])
exec("{}.append(\"{}\")".format(var, data))
pass
elif event.key == K_F11:
for m in screeninfo.get_monitors():
displ = str(m)
w, h, mx, c = displ.split(", ")
if self.fullscreen:
self.fullscreen = False
screen = init_screen(1024, 700, pygame.HWSURFACE | pygame.FULLSCREEN )
else:
self.fullscreen = True
screen = init_screen(w, h, pygame.HWSURFACE | pygame.RESIZABLE )
pygame.display.toggle_fullscreen()
elif event.type == VIDEORESIZE:
self.map_layer.set_size((event.w, event.h))
dispHeight = event.h
dispWidth = event.w
event = poll()
# using get_pressed is slightly less accurate than testing for events
# but is much easier to use.
if keyset == "game":
pressed = pygame.key.get_pressed()
if pressed[K_UP]:
self.hero.velocity[1] = -HERO_MOVE_SPEED
self.direction = "up"
self.direction2 = "up"
elif pressed[K_DOWN]:
self.hero.velocity[1] = HERO_MOVE_SPEED
self.direction = "down"
self.direction2 = "down"
elif pressed[K_w]:
self.hero.velocity[1] = -HERO_SPRINT_SPEED
self.direction = "up"
self.direction2 = "up"
elif pressed[K_s]:
self.hero.velocity[1] = HERO_SPRINT_SPEED
self.direction = "down"
self.direction2 = "down"
else:
self.hero.velocity[1] = 0
self.direction2 = "still"
if pressed[K_LEFT]:
self.hero.velocity[0] = -HERO_MOVE_SPEED
self.direction = "left"
self.direction1 = "left"
elif pressed[K_RIGHT]:
self.hero.velocity[0] = HERO_MOVE_SPEED
self.direction = "right"
self.direction1 = "right"
elif pressed[K_a]:
self.hero.velocity[0] = -HERO_SPRINT_SPEED
self.direction = "left"
self.direction1 = "left"
elif pressed[K_d]:
self.hero.velocity[0] = HERO_SPRINT_SPEED
self.direction = "right"
self.direction1 = "right"
else:
self.hero.velocity[0] = 0
self.direction1 = "still"
if self.direction1 == "still" and self.direction2 == "still":
self.direction = "still"
def update(self, dt):
""" Tasks that occur over time should be handled here
"""
self.group.update(dt)
# check if the sprite's feet are colliding with wall
# sprite must have a rect called feet, and move_back method,
# otherwise this will fail
for sprite in self.group.sprites():
if sprite.feet.collidelist(self.walls) > -1:
sprite.move_back(dt)
def animation(self, direction, number):
if self.direction1 == "still" and self.direction2 == "still":
if self.direction == "left":
self.hero = Hero('Tiles/hero/walking_left/walking_left1.png')
if self.direction == "right":
self.hero = Hero('Tiles/hero/walking_right/walking_right1.png')
if self.direction == "up":
self.hero = Hero('Tileshero/walking_up/walking_up1.png')
if self.direction == "down":
self.hero = Hero('Tiles/hero/walking_down/walking_down1.png')
else:
self.hero = Hero('Tiles/hero/walking_' +direction +'/walking_' +direction +str(number) +'.png')
def genchests(self):
wr = WeightedRandomizer(itemsProbability)
self.taken = False
chest.clear()
numItems = random.randint(1, random.randint(2, 4))
if random.randint(0, 3) < 1:
numItems += 1
elif random.randint(0, 9) < 2:
numItems += 2
elif random.randint(0, 18) < 2:
numItems += 5
for i in range(0, numItems):
item = wr.random()
while item in chest:
item = wr.random()
chest.append(item)
return chest
def gen_enemy(self, player_stats, enemy_stat):
stats = attack_stats_types
stat = player_stats
for i in range(len(player_stats)):
j = stats[i]
try:
enemy_stat[stats[i]] = int((stat[j]-(stat[j]*0.2)) + random.randint(0, int(stat[j]*0.4)))
except TypeError:
enemy_stat[j] = choice(attack_types)
return enemy_stat
pass
def player_attack():
type = None
while type not in attack_types:
type = input("[ QUESTION ] Enter attack type. ")
if type not in attack_types:
print("[ ERROR ] Attack type {} not found. Must be {}".format(type, attack_types))
else:
break
return type
pass
def attack(self, attacker_stats, defender_stats, player_attack_type):
fraction = attacker_stats['strength'] / defender_stats['blocking']
print("[ INFO ] Defender attack type: {}".format(defender_stats['attack']))
if player_attack_type != defender_stats['attack']:
if fraction > (0.8 + (randint(0, 40)/100)):
attacker_stats['health'] -= int(fraction*10)
pass # Attacker Win
else:
defender_stats['health'] -= int(fraction*10)
pass # Attacker Loss
elif player_attack_type == attacker_stats['attack']: # Better odds here
if fraction > (0.9 + (randint(0, 40)/100)):
attacker_stats['health'] -= int(fraction*10)
pass # Attacker Win
else:
defender_stats['health'] -= int(fraction*10)
pass # Attacker Loss
else:
if fraction > (0.70 + (randint(0, 40)/100)): # Odds are worse here
attacker_stats['health'] -= int(fraction*10)
pass # Attacker Win
else:
defender_stats['health'] -= int(fraction*10)
pass # Attacker Loss
print("[ INFO ] Attacker: {} Defender: {}".format(attacker_stats['health'], defender_stats['health']))
print("[ INFO ] Health to be lost: {}".format(int(fraction*10)))
return attacker_stats, defender_stats
def blit_inventory(self, screenMode, speach=None):
if screenMode != "game":
xCounter, counter, OverCounter = 0, 0, 0
dispWidth, dispHeight = pygame.display.get_surface().get_size()
guiX = (dispWidth / 2) - 175
guiY = (dispHeight / 2) - 165
screen.blit(load_image(os.path.join("images", "gui", "transparent.png")),( 0, 0))
screen.blit(load_image(os.path.join("images", "gui", screenMode +".png")),(guiX, guiY))
if screenMode == "inventory" or screenMode == "chest":
dt = (clock.tick() / 500)
clock.tick(self.fps)
if len(inventory) > 0:
for i in range(0, len(inventory)):
OverCounter += 1
if xCounter >= 9:
counter += 1
xCounter = 0
screen.blit(load_image(os.path.join("images", "items",\
str(items[inventory[i]])+".png")), (guiX + 16 + 36*xCounter, guiY + 168 + 36*counter))
xCounter += 1
if screenMode == "chest" and chestContents[self.chestNo] != None:
itemNo = 0
for i in range(0, len(chestContents[self.chestNo])):
screen.blit(load_image(os.path.join("images", "items",\
items[str(chestContents[self.chestNo][i])]\
+".png")), (guiX + 123 + 36*itemNo,\
guiY + 34 + int(35 * (i/3)) - int(35 * (i/3)) % 35))
if itemNo < 2:
itemNo += 1
else:
itemNo = 0
if screenMode == "speach":
self.speach(dispWidth, dispHeight, speach)
if screenMode == "attack":
picture = load_image(os.path.join("Tiles", "hero", "walking_down", "walking_down1.png"))
picture = pygame.transform.scale(picture, (100, 100))
rect = picture.get_rect()
rect = rect.move((guiX + 50, guiY + 28))
screen.blit(picture, rect)
text = font.render("Player : Enemy", True, pygame.Color('black'))
screen.blit(text, (guiX + 172, guiY + 45))
text = "Health: "+str(attack_stats['health'])+" Skill: "+str(attack_stats['skill'])+" Attack: "+str(attack_stats['attack'])
text_render = pixel_font.render(text, False, pygame.Color('gray27'))
screen.blit(text_render, (guiX+20, guiY+290))
for i, attack in enumerate(attack_types):
text = load_font(30, "data/PixelFont.ttf").render(attack, False, pygame.Color('black'))
screen.blit(text, (guiX+172, guiY+25+28*(i+2)))
#
if pygame.mouse.get_pressed()[0] == 1:
#print(pygame.mouse.get_pos())
mouse_pos = pygame.mouse.get_pos()
if guiX+160 < mouse_pos[0] and guiX+330 > mouse_pos[0]:
for i, attack in enumerate(attack_types):
if guiY+25+28*(i+2) < mouse_pos[1] and (guiY+25+28*(i+2))+28 > mouse_pos[1]:
print(attack)
self.attack(attack_stats, enemy_stats, attack)
else:
pass
pass
def takeChest(self):
if len(inventory) < 27:
if chestContents[self.chestNo] != None:
for i in range(0, (len(chestContents[self.chestNo]))):
#print(i)
inventory.append(chestContents[self.chestNo][i])
chestContents[self.chestNo][:] = []
pickle.dump(chestContents, open(os.path.join("data", "saves", "chestContents.dat"), "wb"))
def run(self):
screenMode = pygame.RESIZABLE
oldPlay = stats['playTime']
clock = pygame.time.Clock()
self.running = True
self.grid = [0, 0]
debug = True
dispWidth, dispHeight = 1024, 768
self.menu = "game"
game_time = pygame.time.get_ticks()
playTime = font.render("Timer: ", False, pygame.Color('white'))
minutes = 0
self.map = stats['map'][:-4].lower()
self.map = self.map.lstrip("m") # Fix that stupid bug that changes "maze1" to "ze1"
self.map = self.map.lstrip("aps/")
try:
while self.running:
dt = (clock.tick() / 500)
clock.tick(self.fps)
if self.menu == "game":
#self.deep_thought()
if self.counter2 % 7 == 0:
heroPos = self.hero.position
self.animation(self.direction, self.counter)
self.hero.position = heroPos
#entityPos = self.entity.position
#self.EntityAnimation(self.EntityDirection, self.counter, "princess")
#self.entity.position = entityPos
self.counter += 1
guiX = (dispWidth / 2) - 175
guiY = (dispHeight / 2) - 165
self.group.remove(self.hero)
#self.group.remove(self.entity)
self.group.empty()
self.group.add(self.hero)
#self.group.add(self.entity)
self.counter2 += 1
if self.counter > 8:
self.counter = 1
stats['pos'] = self.hero.position
currentTime = systime()
seconds = currentTime - gameStart + oldPlay
dispWidth, dispHeight = pygame.display.get_surface().get_size()
stats['playTime'] = seconds
if debug == True and self.counter2 % 1 == 0:
location = font.render("Position: " + str(round(round(self.hero.position[0], -1) / 10)) + ", " + str(round(round(self.hero.position[1], -1) / 10)), False, pygame.Color('white'))
mapdebug = font.render("Map Name: " + str(self.map), False, pygame.Color('white'))
minutes = seconds // 60
secondsDisp = seconds % 60
if minutes < 1:
minutes = 0
if secondsDisp == 60:
secondsDisp = 0
minutes += 1
fps = font.render("FPS:" + str(int(clock.get_fps())), False, pygame.Color('white'))
screen.blit(fps, (50, 50))
screen.blit(playTime, (50,100))
screen.blit(location, (50,75))
screen.blit(mapdebug, (50, 125))
playTime = font.render("Timer: " + str(floor(minutes)) + " : " + str(round(secondsDisp)), True, pygame.Color('white'))
screen.blit(playTime, (50,100))
self.blit_inventory(str(self.menu))
pygame.display.update()
#pygame,display.flip()
self.handle_input(self.menu)
self.update(dt)
self.draw(screen)
except KeyboardInterrupt:
self.running = False
pygame.quit()
class QuestGame(object):
""" This class is a basic game.
This class will load data, create a pyscroll group, a hero object.
It also reads input and moves the Hero around the map.
Finally, it uses a pyscroll group to render the map and Hero.
"""
filename = get_map(MAP_FILENAME)
def __init__(self):
# true while running
self.running = False
# load data from pytmx
tmx_data = load_pygame(self.filename)
# setup level geometry with simple pygame rects, loaded from pytmx
self.walls = list()
for object in tmx_data.objects:
self.walls.append(pygame.Rect(
object.x, object.y,
object.width, object.height))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(tmx_data)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data, screen.get_size())
self.map_layer.zoom = 2
# pyscroll supports layered rendering. our map has 3 'under' layers
# layers begin with 0, so the layers are 0, 1, and 2.
# since we want the sprite to be on top of layer 1, we set the default
# layer for sprites as 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=2)
self.hero = Hero()
# put the hero in the center of the map
self.hero.position = self.map_layer.map_rect.center
# add our hero to the group
self.group.add(self.hero)
def draw(self, surface):
# center the map/screen on our Hero
self.group.center(self.hero.rect.center)
# draw the map and all sprites
self.group.draw(surface)
def handle_input(self):
""" Handle pygame input events
"""
poll = pygame.event.poll
event = poll()
while event:
if event.type == QUIT:
self.running = False
break
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.running = False
break
elif event.key == K_EQUALS:
self.map_layer.zoom += .25
elif event.key == K_MINUS:
value = self.map_layer.zoom - .25
if value > 0:
self.map_layer.zoom = value
# this will be handled if the window is resized
elif event.type == VIDEORESIZE:
init_screen(event.w, event.h)
self.map_layer.set_size((event.w, event.h))
event = poll()
# using get_pressed is slightly less accurate than testing for events
# but is much easier to use.
pressed = pygame.key.get_pressed()
if pressed[K_UP]:
self.hero.velocity[1] = -HERO_MOVE_SPEED
elif pressed[K_DOWN]:
self.hero.velocity[1] = HERO_MOVE_SPEED
else:
self.hero.velocity[1] = 0
if pressed[K_LEFT]:
self.hero.velocity[0] = -HERO_MOVE_SPEED
elif pressed[K_RIGHT]:
self.hero.velocity[0] = HERO_MOVE_SPEED
else:
self.hero.velocity[0] = 0
def update(self, dt):
""" Tasks that occur over time should be handled here
"""
self.group.update(dt)
# check if the sprite's feet are colliding with wall
# sprite must have a rect called feet, and move_back method,
# otherwise this will fail
for sprite in self.group.sprites():
if sprite.feet.collidelist(self.walls) > -1:
sprite.move_back(dt)
def run(self):
""" Run the game loop
"""
clock = pygame.time.Clock()
self.running = True
try:
while self.running:
dt = clock.tick() / 1000.
self.handle_input()
self.update(dt)
self.draw(screen)
pygame.display.flip()
except KeyboardInterrupt:
self.running = False
class Level:
"""
Class that holds map, and any game object that should be rendered or updated
"""
def __init__(self, screen_size, logic_manager):
self._logic_manager = logic_manager
self.screen_size = screen_size
self.tmx_data = None
self.map_data = None
self.map_layer = None
self.group = None
self.paths = []
self.base = None
def load(self, filename):
"""
Loads map
:param filename:
:return:
"""
self.tmx_data = load_pygame(filename)
self.map_data = TiledMapData(self.tmx_data)
self.map_layer = BufferedRenderer(self.map_data,
self.screen_size, alpha=True)
self.group = PyscrollGroup(map_layer=self.map_layer)
Camera.set_up(self.group, self.map_layer, self.screen_size)
for obj in self.tmx_data.get_layer_by_name("paths"):
self.paths.append(obj.points)
for obstacle in self.obstacle_iterator():
obstacle.rect = Rect(obstacle.x, obstacle.y, obstacle.width,
obstacle.height)
for actor in self.tmx_data.get_layer_by_name("actors"):
if actor.name == 'base':
self.base = Base()
self.base.position = Vector2(actor.x, actor.y)
self.base.team = PLAYER_TEAM
self.add(self.base)
def add(self, obj):
"""
Add actor
:param obj:
:return:
"""
self.group.add(obj, layer=self.get_layer_index("actors"))
self._logic_manager.on_object_added_to_scene(obj)
def add_obstacle(self, obstacle):
"""
Add obstacle
:param obstacle:
:return:
"""
self.tmx_data.get_layer_by_name("obstacles").append(obstacle)
def actor_iterator(self):
"""
Returns iterator that goe through actors
:return:
"""
for o in self.group.sprites():
if isinstance(o, Actor):
yield o
def obstacle_iterator(self):
"""
Returns iterator that goes through obstacles
:return:
"""
for obstacle in self.tmx_data.get_layer_by_name("obstacles"):
yield obstacle
def get_layer_index(self, layer_name):
"""
Returns index of layer by name
:param layer_name:
:return:
"""
for i, layer in enumerate(self.tmx_data.layers):
if layer.name == layer_name:
return i
return -1
def is_rectangle_colliding(self, rectangle):
"""
Checks if rect is colliding with any obstacle
:param rectangle:
:return:
"""
for obstacle in self.obstacle_iterator():
if rectangle.colliderect(obstacle.rect):
return True
return False
def get_actor_on_position(self, position, lambda_filter=None):
"""
Checks if given position collides with any actor and returns it
:param position:
:param lambda_filter:
:return:
"""
if lambda_filter is not None:
for actor in self.actor_iterator():
if actor.rect.collidepoint(position.x,
position.y) and lambda_filter(actor):
return actor
else:
for actor in self.actor_iterator():
if actor.rect.collidepoint(position.x, position.y):
return actor
return None
def update(self, dt):
"""
Updates level
:param dt:
:return:
"""
self.group.update(dt)
for obj in self.actor_iterator():
if obj.state != ActorState.DEATH:
visible = pygame.sprite.spritecollide(obj, self.group.sprites(),
False, is_visible)
obj.actors_in_attack_range = visible
for new_object in GameObject.objects_to_create:
self.add(new_object)
GameObject.objects_to_create.clear()
def draw(self, surface):
"""
Draw level objects
:param surface:
:return:
"""
self.group.draw(surface)
class Game(object):
filename = get_map(MAP_FILENAME)
def __init__(self):
# true while running
self.currentAnim = CurrentAnim.RIGHT
# load data from pytmx
tmx_data = load_pygame(self.filename)
# setup level geometry with simple pygame rects, loaded from pytmx
self.walls = list()
for object in tmx_data.objects:
self.walls.append(
pygame.Rect(object.x, object.y, object.width, object.height))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(tmx_data)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data,
screen.get_size(),
clamp_camera=False,
tall_sprites=0)
self.map_layer.zoom = 1.8
# pyscroll supports layered rendering. our map has 3 'under' layers
# layers begin with 0, so the layers are 0, 1, and 2.
# since we want the sprite to be on top of layer 1, we set the default
# layer for sprites as 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=1)
self.doorPosX = 157
self.doorPosY = 208
self.offset = 0
for j in range(2):
for i in range(39):
doors.append(Door(self.doorPosX, self.doorPosY))
self.doorPosY += 113 - self.offset
self.offset += 0.06
self.doorPosX = 270
self.offset = 0
self.doorPosY = 208
self.doorPosX = 457
self.doorPosY = 208
self.offset = 0
for j in range(2):
for i in range(39):
doors.append(Door(self.doorPosX, self.doorPosY))
self.doorPosY += 113 - self.offset
self.offset += 0.06
self.doorPosX = 588
self.offset = 0
self.doorPosY = 208
self.elevatorInitX = 350
self.elevatorInitY = 200
for i in range(20):
elevator.append(
Elevator(ElevatorImage, self.elevatorInitX,
self.elevatorInitY))
self.elevatorInitY += 250
for i in elevator:
self.group.add(i)
self.playerCharacter = Character(PlayerWalkAnimList[0])
#self.playerCharacter._position = self.map_layer.map_rect.center
self.playerCharacter._positionX += 300
self.playerCharacter._positionY += 20
self.group.add(self.playerCharacter)
#Variables
self.animDelay = 50
self.JumpTimer = 1700
self.FireDelay = 2000
self.lastUpdate = 0
self.SpawnlastUpdate = 0
self.JumplastUpdate = 0
self.AttacklastUpdate = 0
self.ScoreIncreaseTimer = 0
self.playerVel = [0, 0]
self.velX = 0
self.velY = 0
self.jumpVel = 0.5
self.Gravity = 0
self.bIsJumping = False
self.bCanJump = True
self.WalkAnimIndex = 0
self.CrouchAnimIndex = 0
self.AttackAnimIndex = 0
self.bIsWalking = False
self.bCollided = False
self.bCanMoveRight = True
self.bCanMoveLeft = True
self.bIsFiring = False
self.bHasFired = False
self.bCanFire = True
self.bAddEnemy = False
self.facing = 1
self.PlayeBulletOffset = 0
self.bCanSpawnEnemy = True
self.WalkSoundTimer = 0
pygame.display.set_caption("Elevator action")
self.clock = pygame.time.Clock()
self.score = 0
self.health = 10
self.bHealthCheck = True
self.bGameOver = False
self.bLevelPassed = False
def MovementHandle(self):
self.keys = pygame.key.get_pressed()
if self.keys[pygame.K_LEFT]:
self.bIsWalking = True
self.currentAnim = CurrentAnim.LEFT
elif self.keys[pygame.K_RIGHT]:
self.bIsWalking = True
self.currentAnim = CurrentAnim.RIGHT
if self.bIsWalking == True:
if self.currentAnim == CurrentAnim.LEFT:
if self.bCanMoveLeft == True:
self.velX = -2.5
elif self.currentAnim == CurrentAnim.RIGHT:
if self.bCanMoveRight == True:
self.velX = 2.5
def AddEnemy_thread(self):
count = 0
if count < 1 and len(Enemies) < 50:
for i in doors:
if self.playerCharacter._positionY >= i.positionY - random.randrange(
20, 200
) and self.playerCharacter._positionY <= i.positionY + random.randrange(
20, 200
) and self.playerCharacter._positionX >= i.positionX - random.randrange(
20, 200
) and self.playerCharacter._positionX <= i.positionX + random.randrange(
20, 200):
enemy = Enemy(WalkAnimList[0])
enemy._positionX = i.positionX
enemy._positionY = i.positionY
Enemies.append(enemy)
self.group.add(enemy)
count += 1
self.bCanSpawnEnemy = False
if count >= 2:
count = 0
def Bullet_thread_player(self):
if self.currentAnim == CurrentAnim.LEFT:
self.facing = -1
self.PlayeBulletOffset = -10
elif self.currentAnim == CurrentAnim.RIGHT:
self.facing = 1
self.PlayeBulletOffset = 10
BulletsPlayer.append(
Bullet(BulletImage,
self.playerCharacter._positionX + self.PlayeBulletOffset,
self.playerCharacter._positionY + 20, self.facing))
self.group.add(BulletsPlayer[len(BulletsPlayer) - 1])
def Bullet_thread_enemy(self):
for i in Enemies:
BulletsEnemy.append(
Bullet(BulletImage, i._positionX, i._positionY + 5, i.facing))
self.group.add(BulletsEnemy[len(BulletsEnemy) - 1])
def run(self, done):
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
if self.bIsWalking == True:
if pygame.time.get_ticks() - self.WalkSoundTimer > 500:
runSound.play(0)
self.WalkSoundTimer = pygame.time.get_ticks()
self.keys = pygame.key.get_pressed()
if self.keys[pygame.K_SPACE]:
if self.bCanJump == True:
jumpSound.play(0)
self.bIsJumping = True
self.bCanJump = False
if self.keys[pygame.K_z]:
if self.bCanFire == True:
self.bIsFiring = True
self.bHasFired = True
self.bCanFire = False
pistolFire()
else:
self.bIsFiring = False
else:
self.bIsFiring = False
self.bCanFire = True
if self.bIsWalking == False:
self.playerCharacter.setAnim(PlayerIdleAnimList[0],
self.currentAnim)
if self.keys[pygame.K_x]:
pass
if self.keys[pygame.K_q]:
pass
if self.keys[pygame.K_e]:
if self.bAddEnemy == False:
self.bAddEnemy = True
else:
self.bIsWalking = False
if self.keys[pygame.K_DOWN]:
self.playerCharacter.bPlayerCrouching = True
else:
self.playerCharacter.bPlayerCrouching = False
if self.bIsWalking == False:
self.velX = 0
if self.bIsJumping == True:
self.bIsInAir = True
self.bCollided = False
if self.jumpVel > 0:
self.velY -= self.jumpVel
self.jumpVel -= 0.03
else:
self.jumpVel = 0.5
self.velY = 0
self.bIsJumping = False
self.MovementHandle()
for sprite in self.group.sprites():
if sprite.bIsPlayer == ObjectType.PLAYER:
for i in elevator:
if sprite.feet.collidelist(
self.walls) > -1 or i.CollideWithElavator == True:
self.bCollided = True
if self.bIsJumping == False:
self.velY = 0
if self.bCanJump == False:
if self.bCollided == True:
self.bCanJump = True
else:
self.bCollided = False
elif sprite.bIsPlayer == ObjectType.ENEMY:
if sprite.feet.collidelist(
self.walls) > -1 and i.CollideWithElavator == False:
sprite.bCollided = True
else:
sprite.bCollided = False
for i in elevator:
if i.CollideWithElavator == False:
if self.bCollided == False:
self.velY += 0.1 / len(elevator)
else:
if i.Dir == ElevatorDir.DOWN:
if self.bIsJumping == False:
self.velY += 1.0 / len(elevator) + 0.82
else:
self.velY -= 1.0 * 1.1
for i in Enemies:
if i.bCollided == False:
i.velY += 0.1
else:
i.velY = 0.0
i.setVelocity()
i.result = self.playerCharacter._positionX - i._positionX
i.updateDir()
#print(i.result)
if i.result <= 100 and i.result >= -100 and i._positionY >= self.playerCharacter._positionY - 20 and i._positionY <= self.playerCharacter._positionY + 20:
i.AIRotate()
i.velocityX = 0
if i.bIsFiring == True and i.result <= 600 and i.result >= -600 and i._positionY >= self.playerCharacter._positionY - 20 and i._positionY <= self.playerCharacter._positionY + 20:
thread = threading.Thread(target=self.Bullet_thread_enemy)
enemyGun.play(0)
thread.start()
i.bIsFiring = False
if i.bIsFiring == False:
if pygame.time.get_ticks(
) - i.FireUpdate > self.FireDelay * random.randrange(2, 8):
i.bIsFiring = True
i.FireUpdate = pygame.time.get_ticks()
i.UpdatePosition()
if i.bIsDead == False:
if i.velocityX != 0:
i.UpdateAnim(self.animDelay)
else:
i.setAnim(IdleAnimList[0])
else:
i.UpdateAnim(self.animDelay)
if self.playerCharacter.right.collidelist(self.walls) > -1:
self.bCanMoveRight = False
else:
self.bCanMoveRight = True
if self.playerCharacter.left.collidelist(self.walls) > -1:
self.bCanMoveLeft = False
else:
self.bCanMoveLeft = True
for i in Enemies:
if i.left.collidelist(self.walls) > -1:
i.velocityX = 0
i.facing = 1
elif i.right.collidelist(self.walls) > -1:
i.velocityX = 0
i.facing = -1
if self.bIsFiring == True:
self.playerCharacter.bPlayShootingAnim = True
if self.playerCharacter.bPlayShootingAnim == False:
if self.playerCharacter.bPlayerCrouching == False:
if self.bIsWalking == True:
self.playerCharacter.setAnim(
PlayerWalkAnimList[self.WalkAnimIndex],
self.currentAnim)
if self.WalkAnimIndex < len(PlayerWalkAnimList) - 1:
if pygame.time.get_ticks(
) - self.lastUpdate > self.animDelay:
self.WalkAnimIndex += 1
self.lastUpdate = pygame.time.get_ticks()
else:
self.WalkAnimIndex = 0
else:
self.WalkAnimIndex = 0
else:
self.playerCharacter.setAnim(
playerCrouchAnimList[self.CrouchAnimIndex],
self.currentAnim)
if self.CrouchAnimIndex < len(playerCrouchAnimList) - 1:
if pygame.time.get_ticks(
) - self.lastUpdate > self.animDelay:
self.CrouchAnimIndex += 1
self.lastUpdate = pygame.time.get_ticks()
else:
self.CrouchAnimIndex = len(playerCrouchAnimList) - 1
else:
self.playerCharacter.PlayShootAnim(self.currentAnim)
self.playerCharacter.setVelocity(self.velX, self.velY)
if self.bCanSpawnEnemy == True:
threadAddEnemy = threading.Thread(target=self.AddEnemy_thread)
threadAddEnemy.start()
if self.bCanSpawnEnemy == False:
if pygame.time.get_ticks() - self.SpawnlastUpdate > 8000:
self.SpawnlastUpdate = pygame.time.get_ticks()
self.bCanSpawnEnemy = True
self.group.center(self.playerCharacter.rect.center)
self.playerCharacter.UpdatePosition()
#print(self.bCanSpawnEnemy)
if self.bIsFiring == True:
thread = threading.Thread(target=self.Bullet_thread_player)
thread.start()
if BulletsPlayer:
for i in BulletsPlayer:
i.UpdatePosition()
#print("[ "+str(i.positionX)+", "+str(i.positionY)+" ]")
if i.positionX > W or i.positionX < 0:
self.group.remove(i)
BulletsPlayer.pop(BulletsPlayer.index(i))
if len(BulletsPlayer) > 20:
for i in BulletsPlayer:
BulletsPlayer.pop(BulletsPlayer.index(i))
if BulletsEnemy:
for i in BulletsEnemy:
i.UpdatePosition()
if i.positionX > W or i.positionX < 0:
self.group.remove(i)
BulletsEnemy.pop(BulletsEnemy.index(i))
for i in elevator:
if self.playerCharacter.rect[
1] >= i.rect[1] - 20 and self.playerCharacter.rect[
1] <= i.rect[1] + 20 and self.playerCharacter.rect[
0] >= i.rect[0] - 50 and self.playerCharacter.rect[
0] <= i.rect[0] + 50:
i.CollideWithElavator = True
else:
i.CollideWithElavator = False
i.setVelocity()
i.UpdatePosition()
for i in Enemies:
if i._positionY >= self.playerCharacter._positionY + 200 or i._positionY <= self.playerCharacter._positionY - 200:
self.group.remove(i)
Enemies.pop(Enemies.index(i))
if i.velocityY > 20:
self.group.remove(i)
Enemies.pop(Enemies.index(i))
if i.bDeathAnimCompleted == True:
self.group.remove(i)
Enemies.pop(Enemies.index(i))
for i in BulletsPlayer:
if i.rect.collidelist(self.walls) > -1:
self.group.remove(i)
BulletsPlayer.pop(BulletsPlayer.index(i))
for i in BulletsEnemy:
if i.rect.collidelist(self.walls) > -1:
self.group.remove(i)
BulletsEnemy.pop(BulletsEnemy.index(i))
for i in BulletsPlayer:
for j in Enemies:
if (i.rect[1] <= j.rect[1] + 20 and i.rect[1] >= j.rect[1] - 20
) and (i.rect[0] <= j.rect[0] + 5
and i.rect[0] >= j.rect[0] - 5):
j.bIsDead = True
if pygame.time.get_ticks(
) - self.ScoreIncreaseTimer > 1000:
self.score += 50
self.ScoreIncreaseTimer = pygame.time.get_ticks()
self.bHealthCheck = True
hitmarkSound.play(0)
self.group.remove(i)
try:
BulletsPlayer.pop(BulletsPlayer.index(i))
except:
continue
for i in BulletsEnemy:
if self.playerCharacter.bPlayerCrouching == False and self.bIsJumping == False:
if (i.rect[1] <= self.playerCharacter.rect[1] + 20
and i.rect[1] >= self.playerCharacter.rect[1] - 20
) and (i.rect[0] <= self.playerCharacter.rect[0] + 5
and i.rect[0] >= self.playerCharacter.rect[0] - 5):
#print("PLAYER HIT")
self.playerCharacter._positionY -= 4
print(i.facing)
if i.facing < 0:
self.playerCharacter._positionX -= 5
elif i.facing > 0:
self.playerCharacter._positionX += 5
self.health -= 1
self.score -= 75
damageTakenSound.play(0)
self.group.remove(i)
BulletsEnemy.pop(BulletsEnemy.index(i))
if self.score == 250 and self.bHealthCheck == True:
self.health += 1
hpGain.play(0)
self.bHealthCheck = False
if self.score == 500 and self.bHealthCheck == True:
self.health += 1
hpGain.play(0)
self.bHealthCheck = False
if self.score == 750 and self.bHealthCheck == True:
self.health += 1
hpGain.play(0)
self.bHealthCheck = False
if self.score == 1000 and self.bHealthCheck == True:
self.health += 1
hpGain.play(0)
self.bHealthCheck = False
if self.score == 1500 and self.bHealthCheck == True:
self.health += 1
hpGain.play(0)
self.bHealthCheck = False
if self.score == 2000 and self.bHealthCheck == True:
self.health += 2
hpGain.play(0)
self.bHealthCheck = False
if self.score == 3000 and self.bHealthCheck == True:
self.health += 3
hpGain.play(0)
self.bHealthCheck = False
if self.score == 4000 and self.bHealthCheck == True:
self.health += 3
hpGain.play(0)
self.bHealthCheck = False
if self.score == 5000 and self.bHealthCheck == True:
self.health += 3
hpGain.play(0)
self.bHealthCheck = False
if self.score == 10000 and self.bHealthCheck == True:
self.health += 5
hpGain.play(0)
self.bHealthCheck = False
if self.playerCharacter._positionX >= 687 - 40 and self.playerCharacter._positionX <= 687 + 40 and self.playerCharacter._positionY >= 4657 - 40 and self.playerCharacter._positionY <= 4657 + 40:
self.bLevelPassed = True
if self.health <= 0:
self.bGameOver = True
print(
str(self.playerCharacter._positionX) + ", " +
str(self.playerCharacter._positionY))
self.group.draw(screen)
draw_score(screen, 30, 30, self.score)
draw_health(screen, 1120, 30, self.health)
pygame.display.flip()
self.clock.tick(60)
class QuestGame(object):
""" This class is a basic game.
This class will load data, create a pyscroll group, a hero object.
It also reads input and moves the Hero around the map.
Finally, it uses a pyscroll group to render the map and Hero.
"""
filename = get_map(MAP_FILENAME)
def __init__(self):
# true while running
self.running = False
# load data from pytmx
tmx_data = load_pygame(self.filename)
# setup level geometry with simple pygame rects, loaded from pytmx
self.walls = list()
for object in tmx_data.objects:
self.walls.append(
pygame.Rect(object.x, object.y, object.width, object.height))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(tmx_data)
w, h = screen.get_size()
# create new renderer (camera)
# clamp_camera is used to prevent the map from scrolling past the map's edge
self.map_layer = pyscroll.BufferedRenderer(map_data, (w / 2, h / 2),
clamp_camera=True)
# pyscroll supports layered rendering. our map has 3 'under' layers
# layers begin with 0, so the layers are 0, 1, and 2.
# since we want the sprite to be on top of layer 1, we set the default
# layer for sprites as 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=2)
self.hero = Hero()
# put the hero in the center of the map
self.hero.position = self.map_layer.map_rect.center
# add our hero to the group
self.group.add(self.hero)
def draw(self, surface):
# center the map/screen on our Hero
self.group.center(self.hero.rect.center)
# draw the map and all sprites
self.group.draw(surface)
def handle_input(self):
""" Handle pygame input events
"""
poll = pygame.event.poll
event = poll()
while event:
if event.type == QUIT:
self.running = False
break
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.running = False
break
# this will be handled if the window is resized
elif event.type == VIDEORESIZE:
init_screen(event.w, event.h)
self.map_layer.set_size((event.w / 2, event.h / 2))
event = poll()
# using get_pressed is slightly less accurate than testing for events
# but is much easier to use.
pressed = pygame.key.get_pressed()
if pressed[K_UP]:
self.hero.velocity[1] = -HERO_MOVE_SPEED
elif pressed[K_DOWN]:
self.hero.velocity[1] = HERO_MOVE_SPEED
else:
self.hero.velocity[1] = 0
if pressed[K_LEFT]:
self.hero.velocity[0] = -HERO_MOVE_SPEED
elif pressed[K_RIGHT]:
self.hero.velocity[0] = HERO_MOVE_SPEED
else:
self.hero.velocity[0] = 0
def update(self, dt):
""" Tasks that occur over time should be handled here
"""
self.group.update(dt)
# check if the sprite's feet are colliding with wall
# sprite must have a rect called feet, and move_back method,
# otherwise this will fail
for sprite in self.group.sprites():
if sprite.feet.collidelist(self.walls) > -1:
sprite.move_back(dt)
def run(self):
""" Run the game loop
"""
clock = pygame.time.Clock()
scale = pygame.transform.scale
self.running = True
try:
while self.running:
dt = clock.tick() / 1000.
self.handle_input()
self.update(dt)
self.draw(temp_surface)
scale(temp_surface, screen.get_size(), screen)
pygame.display.flip()
except KeyboardInterrupt:
self.running = False
class QuestGame(object):
""" This class is a basic game.
This class will load data, create a pyscroll group, a hero object.
It also reads input and moves the Hero around the map.
Finally, it uses a pyscroll group to render the map and Hero.
"""
filename = get_map(MAP_FILENAME)
counter = 1
counter2 = 1
def __init__(self, state):
if state == False:
self.fullscreen = False
# true while running.
self.running = False
self.clock = pygame.time.Clock()
# create all the directio variables
self.direction = "still"
self.EntityDirection = "still"
self.EntityDirection1, self.EntityDirection2 = "still", "still"
self.fps = 1000
self.bypass = False
entityPos1, heroPos1 = False, False
# load data from pytmx
tmx_data = load_pygame(self.filename)
self.tmx_data = tmx_data
mapPlay = load_pygame(get_map(stats['map']))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(mapPlay)
# setup level geometry with simple pygame rects, loaded from pytmx.
self.walls = list()
for object in mapPlay.objects:
self.walls.append(
pygame.Rect(object.x, object.y, object.width,
object.height))
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data,
screen.get_size())
self.map_layer.zoom = 2
self.group = PyscrollGroup(map_layer=self.map_layer,
default_layer=4)
self.hero = Hero('Tiles/hero/character_still.png')
self.entity = Entity('Tiles/hero/character_still.png')
self.hero.position = stats['pos']
self.entity.position = stats['pos']
# add our hero to the group
self.group.add(self.hero)
#self.group.add(self.entity)
self.entVel = (0, 0)
def deep_thought(self): # The 'AI' function, needs work
if self.counter2 % 75 == 0 or self.bypass == True:
self.bypass = False
if random.randint(0, 1) == 1:
self.entity.velocity[0], self.entity.velocity[1] = 0, 0
movement = random.choice([
"self.entity.velocity[0] = -45; self.EntityDirection = 'left'; self.EntityDirection2 = 'left'",
"self.entity.velocity[0] = 45; self.EntityDirection = 'right'; self.EntityDirection2 = 'right'",
"self.entity.velocity[1] = -45; self.EntityDirection = 'up'; self.EntityDirection1 = 'up'",
"self.entity.velocity[1] = 45; self.EntityDirection = 'down'; self.EntityDirection1 = 'down'"
])
exec(movement)
def EntityAnimation(self, direction, number, character="hero"):
self.entVel = self.entity.velocity
self.counter += 1
if self.EntityDirection1 == "still" and self.EntityDirection2 == "still":
if self.EntityDirection == "left":
self.entity = Entity('Tiles/' + character +
'/walking_left/walking_left1.png')
if self.EntityDirection == "right":
self.entity = Entity('Tiles/' + character +
'/walking_right/walking_right1.png')
if self.EntityDirection == "up":
self.entity = Entity('Tiles/' + character +
'/walking_up/walking_up1.png')
if self.EntityDirection == "down":
self.entity = Entity('Tiles/' + character +
'/walking_down/walking_down1.png')
else:
self.entity = Entity('Tiles/' + character + '/walking_' +
direction + '/walking_' + direction +
str(number) + '.png')
self.entity.velocity = self.entVel
def EntMoveBack(self):
#self.deep_thought(self, True) # Comment this to disable the 'AI'
pass
def map_change(self, map, target=False): # Does what it says on the tin
mapfile = get_map(map)
tmx_data = load_pygame(mapfile)
self.tmx_data = tmx_data
map_data = pyscroll.data.TiledMapData(tmx_data)
self.walls = list()
for object in tmx_data.objects:
self.walls.append(
pygame.Rect(object.x, object.y, object.width, object.height))
# creates new 'camera'
self.map_layer = pyscroll.BufferedRenderer(map_data, screen.get_size())
self.map_layer.zoom = 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=4)
#creates a new Hero to go on our new camera
self.hero = Hero('Tiles/hero/character_still.png')
try:
self.hero.position = (target)
except TypeError:
self.hero.position = self.map_layer.map_rect.center
self.map = stats['map'][:-4].lower()
self.map = self.map.lstrip(
"m") # Fix that stupid bug that changes "maze1" to "ze1"
self.map = self.map.lstrip("aps/")
def switcher(
self
): # Bunch of IF statements to decide if we're at a door or not, then changes the map.
if len(objectX) == len(objectY) == len(targetPosX) == len(targetPosY) == len(currentMap) == \
len(targetMap) == len(animationDirection) == len(targetMapFile) == len(objectType):
heroPos = [0, 0]
heroPos[0], heroPos[1] = self.hero.position[0], self.hero.position[
1]
for i in range(len(objectX)):
if self.map == currentMap[i]:
if self.hero.position[0] - 15 <= int(
objectX[i]) <= self.hero.position[0] + 15:
if self.hero.position[1] - 15 <= int(
objectY[i]) <= self.hero.position[1] + 15:
if objectType[i] == "door":
used[i] = True
self.map_change(targetMapFile[i])
self.map = targetMap[i]
stats['map'] = targetMapFile[i]
heroPos = (int(targetPosX[i]),
int(targetPosY[i]))
self.animation(animationDirection[i], 1)
self.hero.position = heroPos
return False
elif objectType[i] == "chest":
keyset, self.menu = "chest", "chest"
if used[i] == False:
if chestContents[i] == None and used[
i] == False:
used[i] = True
pickle.dump(
used,
open(
os.path.join(
"data", "saves",
"used.dat"), "wb"))
chestContents[i] = self.genchests()
pickle.dump(
chestContents,
open(
os.path.join(
"data", "saves",
"chestContents.dat"),
"wb"))
self.chestNo = i
return False
def generate_surrounding_maps(self):
heroPos = [0, 0]
heroPos = self.hero.position
if int(self.hero.position[0]) in range((self.tmx_data.width * 32) - 64,
(self.tmx_data.width * 32)):
target = (32, heroPos[1])
self.grid[0] = self.grid[0] + 1
try:
self.map_change(
str(self.grid[0] + 1) + ", " + str(self.grid[1]) + ".tmx",
target)
self.map = str(self.grid).lstrip("[").rstrip("]")
stats['map'] = self.map + ".tmx"
self.animation("right", 1)
target = (32, heroPos[1])
#self.hero.position = target
except FileNotFoundError:
self.generate_new_map(4, 16, 2, self.grid, target)
elif int(self.hero.position[1]) in range(
(self.tmx_data.height * 32) - 64, self.tmx_data.width * 32):
target = (heroPos[0], 32)
self.grid[1] = self.grid[1] + 1
try:
self.map_change(
str(self.grid[0]) + ", " + str(self.grid[1] + 1) + ".tmx",
target)
self.map = str(self.grid).lstrip("[").rstrip("]")
stats['map'] = self.map + ".tmx"
heroPos[0], heroPos[1] = self.hero.position[
0], self.hero.position[1]
self.animation("up", 1)
except FileNotFoundError:
self.generate_new_map(4, 16, 2, self.grid, target)
elif int(self.hero.position[0]) in range(0, 64):
target = (self.tmx_data.width * 32 - 32, heroPos[1])
self.grid[0] = self.grid[0] - 1
try:
self.map_change(
str(self.grid[0] - 1) + ", " + str(self.grid[1]) + ".tmx",
target)
self.map = str(self.grid).lstrip("[").rstrip("]")
stats['map'] = self.map + ".tmx"
heroPos[0], heroPos[1] = self.hero.position[
0], self.hero.position[1]
self.animation("left", 1)
#self.hero.position = target
except FileNotFoundError:
self.generate_new_map(4, 16, 2, self.grid, target)
elif int(self.hero.position[1]) in range(0, 64):
target = (heroPos[0], self.tmx_data.height * 32 - 32)
self.grid[1] = self.grid[1] - 1
try:
self.map_change(
str(self.grid[0]) + ", " + str(self.grid[1] - 1) + ".tmx",
target)
self.map = str(self.grid).lstrip("[").rstrip("]")
stats['map'] = self.map + ".tmx"
heroPos[0], heroPos[1] = self.hero.position[
0], self.hero.position[1]
self.animation("down", 1)
#self.hero.position = target
except FileNotFoundError:
self.generate_new_map(4, 16, 2, self.grid, target)
else:
pass
def generate_new_map(self, octaves, freq, area, target, position):
command = "{}/lib/generate/__init__.py".format(os.getcwd())
if sys.platform.startswith('win32'):
executeable = ("Python35\python.exe")
elif sys.platform.startswith('linux'):
executeable = ("python3.5")
for y in range(self.grid[1] + eval("-" + str(area)),
self.grid[1] + area):
for x in range(self.grid[0] + eval("-" + str(area)),
self.grid[0] + area):
if os.path.isfile("data/maps/" + str(x) + ", " + str(y) +
".tmx"):
pass
else:
p = subprocess.Popen([
executeable, command,
("data/maps/" + str(x) + ", " + str(y) + ".tmx"),
str(octaves),
str(freq),
str(x),
str(y)
],
close_fds=True)
try:
if p is not None:
disp_width, disp_height = pygame.display.get_surface(
).get_size()
#self.blit_inventory("speach", "Generating Map... Please Wait...")
self.speach(disp_width, disp_height,
"Generating Map... Please Wait...")
pygame.display.update()
p.wait()
self.map_change(
(str(target[0]) + ", " + str(target[1]) + ".tmx"),
position)
self.map = str(self.grid).lstrip("[").rstrip("]")
stats['map'] = self.map + ".tmx"
except UnboundLocalError:
pass
def draw(self, surface):
self.group.center(self.hero.rect.center)
# draw the map and all sprites
self.group.draw(surface)
def speach(self, dispWidth, dispHeight, text):
## text = "Laudem bonorum salutandi pri te, tollit melius delicata mel cu,\
## eu mea ullum legimus. Probo debitis te vel. Labores vulputate \
## argumentum sea id. Cibo vitae vocent eos no, ne odio molestiae\
## duo."
screen.blit(
pygame.transform.scale(
load_image(os.path.join("images", "gui", "speach.png")),
(dispWidth, 150)), (0, dispHeight - 150))
text = textwrap.wrap(text, width=95)
for i, line in enumerate(text):
text_blit = pixel_font.render(line, False, pygame.Color('white'))
screen.blit(text_blit, (60, dispHeight - 110 + 25 * i))
def map_generate(self, output, octaves, freq, x, y):
command = "{}/lib/generate/__init__.py".format(os.getcwd())
if sys.platform.startswith('win32'):
executeable = ("Python35\python.exe")
elif sys.platform.startswith('linux'):
executeable = ("python3.5")
subprocess.Popen([
executeable, command, output,
str(octaves),
str(freq),
str(x),
str(y)
],
close_fds=True)
def handle_input(self, keyset):
""" Handle pygame input events
"""
poll = pygame.event.poll
event = poll()
while event:
if event.type == QUIT:
self.running = False
pygame.quit()
break
elif event.type == KEYDOWN:
if keyset == "game":
if event.key == K_EQUALS:
self.map_layer.zoom += .25
elif event.key == K_MINUS:
value = self.map_layer.zoom - .25
if value > 0:
self.map_layer.zoom = value
else:
self.map_layer.zoom = 0.1
elif event.key == K_KP0:
try:
if self.switcher() == True:
self.generate_surrounding_maps()
except FileNotFoundError:
print("Exception Caught")
pass
elif event.key == K_e:
self.menu = "inventory"
pass
if event.key == K_ESCAPE:
for i in attack_stats_types:
stats[i] = attack_stats[i]
pickle.dump(
stats,
open(os.path.join("data", "saves", "save.dat"),
"wb"))
pickle.dump(
inventory,
open(
os.path.join("data", "saves", "inventory.dat"),
"wb"))
self.running = False
pygame.quit()
print(" ")
sleep(0.5)
print("Shutdown... Complete")
sys.exit()
break
if keyset != "game":
if event.key == K_ESCAPE:
self.menu = "game"
pass
if keyset == "inventory":
if event.key == K_r:
self.genchests()
if keyset == "chest":
if event.key == K_r:
chestContents[self.chestNo] = self.genchests()
if event.key == K_t:
if taken[self.chestNo] != True:
self.takeChest()
taken[self.chestNo] = True
pickle.dump(
taken,
open(
os.path.join("data", "saves", "taken.dat"),
"wb"))
if keyset == "attack":
pass
#Basically just debug keys
if event.key == K_KP1:
self.menu = "game"
pass
elif event.key == K_KP2:
self.map_change(FOREST)
self.map = "forest"
elif event.key == K_KP3:
self.generate_new_map(4, 16, 3)
pass
elif event.key == K_KP4:
self.map_generate(
str(self.grid[0]) + ", " + str(self.grid[1]) + ".tmx",
4, 16.0, self.grid[0], self.grid[1])
pass
elif event.key == K_KP5:
self.enemy_stats = self.gen_enemy(attack_stats,
enemy_stats)
self.menu = "attack"
pass
elif event.key == K_KP6:
print("X :" + str(int(self.hero.position[0])) + ", Y: " +
str(int(self.hero.position[1])) + ", Map: " +
self.map)
pass
elif event.key == K_KP7:
print(str(pygame.mouse.get_pos()))
pass
elif event.key == K_KP8:
sleep(0.5)
elif event.key == K_KP9:
editor = db_interface.Editor()
conn = sqlite3.connect('data/saves/data.db')
c = conn.cursor()
for var in vars:
exec("del " + var + "[:]")
for data in c.execute(
"SELECT {} FROM csv".format(var)):
data = str(data[0])
exec("{}.append(\"{}\")".format(var, data))
pass
elif event.key == K_F11:
for m in screeninfo.get_monitors():
displ = str(m)
w, h, mx, c = displ.split(", ")
if self.fullscreen:
self.fullscreen = False
screen = init_screen(
1024, 700, pygame.HWSURFACE | pygame.FULLSCREEN)
else:
self.fullscreen = True
screen = init_screen(
w, h, pygame.HWSURFACE | pygame.RESIZABLE)
pygame.display.toggle_fullscreen()
elif event.type == VIDEORESIZE:
self.map_layer.set_size((event.w, event.h))
dispHeight = event.h
dispWidth = event.w
event = poll()
# using get_pressed is slightly less accurate than testing for events
# but is much easier to use.
if keyset == "game":
pressed = pygame.key.get_pressed()
if pressed[K_UP]:
self.hero.velocity[1] = -HERO_MOVE_SPEED
self.direction = "up"
self.direction2 = "up"
elif pressed[K_DOWN]:
self.hero.velocity[1] = HERO_MOVE_SPEED
self.direction = "down"
self.direction2 = "down"
elif pressed[K_w]:
self.hero.velocity[1] = -HERO_SPRINT_SPEED
self.direction = "up"
self.direction2 = "up"
elif pressed[K_s]:
self.hero.velocity[1] = HERO_SPRINT_SPEED
self.direction = "down"
self.direction2 = "down"
else:
self.hero.velocity[1] = 0
self.direction2 = "still"
if pressed[K_LEFT]:
self.hero.velocity[0] = -HERO_MOVE_SPEED
self.direction = "left"
self.direction1 = "left"
elif pressed[K_RIGHT]:
self.hero.velocity[0] = HERO_MOVE_SPEED
self.direction = "right"
self.direction1 = "right"
elif pressed[K_a]:
self.hero.velocity[0] = -HERO_SPRINT_SPEED
self.direction = "left"
self.direction1 = "left"
elif pressed[K_d]:
self.hero.velocity[0] = HERO_SPRINT_SPEED
self.direction = "right"
self.direction1 = "right"
else:
self.hero.velocity[0] = 0
self.direction1 = "still"
if self.direction1 == "still" and self.direction2 == "still":
self.direction = "still"
def update(self, dt):
""" Tasks that occur over time should be handled here
"""
self.group.update(dt)
# check if the sprite's feet are colliding with wall
# sprite must have a rect called feet, and move_back method,
# otherwise this will fail
for sprite in self.group.sprites():
if sprite.feet.collidelist(self.walls) > -1:
sprite.move_back(dt)
def animation(self, direction, number):
if self.direction1 == "still" and self.direction2 == "still":
if self.direction == "left":
self.hero = Hero('Tiles/hero/walking_left/walking_left1.png')
if self.direction == "right":
self.hero = Hero('Tiles/hero/walking_right/walking_right1.png')
if self.direction == "up":
self.hero = Hero('Tileshero/walking_up/walking_up1.png')
if self.direction == "down":
self.hero = Hero('Tiles/hero/walking_down/walking_down1.png')
else:
self.hero = Hero('Tiles/hero/walking_' + direction + '/walking_' +
direction + str(number) + '.png')
def genchests(self):
wr = WeightedRandomizer(itemsProbability)
self.taken = False
chest.clear()
numItems = random.randint(1, random.randint(2, 4))
if random.randint(0, 3) < 1:
numItems += 1
elif random.randint(0, 9) < 2:
numItems += 2
elif random.randint(0, 18) < 2:
numItems += 5
for i in range(0, numItems):
item = wr.random()
while item in chest:
item = wr.random()
chest.append(item)
return chest
def gen_enemy(self, player_stats, enemy_stat):
stats = attack_stats_types
stat = player_stats
for i in range(len(player_stats)):
j = stats[i]
try:
enemy_stat[
stats[i]] = int((stat[j] - (stat[j] * 0.2)) +
random.randint(0, int(stat[j] * 0.4)))
except TypeError:
enemy_stat[j] = choice(attack_types)
return enemy_stat
pass
def player_attack():
type = None
while type not in attack_types:
type = input("[ QUESTION ] Enter attack type. ")
if type not in attack_types:
print(
"[ ERROR ] Attack type {} not found. Must be {}".format(
type, attack_types))
else:
break
return type
pass
def attack(self, attacker_stats, defender_stats, player_attack_type):
fraction = attacker_stats['strength'] / defender_stats['blocking']
print("[ INFO ] Defender attack type: {}".format(
defender_stats['attack']))
if player_attack_type != defender_stats['attack']:
if fraction > (0.8 + (randint(0, 40) / 100)):
attacker_stats['health'] -= int(fraction * 10)
pass # Attacker Win
else:
defender_stats['health'] -= int(fraction * 10)
pass # Attacker Loss
elif player_attack_type == attacker_stats[
'attack']: # Better odds here
if fraction > (0.9 + (randint(0, 40) / 100)):
attacker_stats['health'] -= int(fraction * 10)
pass # Attacker Win
else:
defender_stats['health'] -= int(fraction * 10)
pass # Attacker Loss
else:
if fraction > (0.70 +
(randint(0, 40) / 100)): # Odds are worse here
attacker_stats['health'] -= int(fraction * 10)
pass # Attacker Win
else:
defender_stats['health'] -= int(fraction * 10)
pass # Attacker Loss
print("[ INFO ] Attacker: {} Defender: {}".format(
attacker_stats['health'], defender_stats['health']))
print("[ INFO ] Health to be lost: {}".format(int(fraction * 10)))
return attacker_stats, defender_stats
def blit_inventory(self, screenMode, speach=None):
if screenMode != "game":
xCounter, counter, OverCounter = 0, 0, 0
dispWidth, dispHeight = pygame.display.get_surface().get_size()
guiX = (dispWidth / 2) - 175
guiY = (dispHeight / 2) - 165
screen.blit(
load_image(os.path.join("images", "gui", "transparent.png")),
(0, 0))
screen.blit(
load_image(os.path.join("images", "gui", screenMode + ".png")),
(guiX, guiY))
if screenMode == "inventory" or screenMode == "chest":
dt = (clock.tick() / 500)
clock.tick(self.fps)
if len(inventory) > 0:
for i in range(0, len(inventory)):
OverCounter += 1
if xCounter >= 9:
counter += 1
xCounter = 0
screen.blit(load_image(os.path.join("images", "items",\
str(items[inventory[i]])+".png")), (guiX + 16 + 36*xCounter, guiY + 168 + 36*counter))
xCounter += 1
if screenMode == "chest" and chestContents[self.chestNo] != None:
itemNo = 0
for i in range(0, len(chestContents[self.chestNo])):
screen.blit(load_image(os.path.join("images", "items",\
items[str(chestContents[self.chestNo][i])]\
+".png")), (guiX + 123 + 36*itemNo,\
guiY + 34 + int(35 * (i/3)) - int(35 * (i/3)) % 35))
if itemNo < 2:
itemNo += 1
else:
itemNo = 0
if screenMode == "speach":
self.speach(dispWidth, dispHeight, speach)
if screenMode == "attack":
picture = load_image(
os.path.join("Tiles", "hero", "walking_down",
"walking_down1.png"))
picture = pygame.transform.scale(picture, (100, 100))
rect = picture.get_rect()
rect = rect.move((guiX + 50, guiY + 28))
screen.blit(picture, rect)
text = font.render("Player : Enemy", True, pygame.Color('black'))
screen.blit(text, (guiX + 172, guiY + 45))
text = "Health: " + str(
attack_stats['health']) + " Skill: " + str(
attack_stats['skill']) + " Attack: " + str(
attack_stats['attack'])
text_render = pixel_font.render(text, False,
pygame.Color('gray27'))
screen.blit(text_render, (guiX + 20, guiY + 290))
for i, attack in enumerate(attack_types):
text = load_font(30, "data/PixelFont.ttf").render(
attack, False, pygame.Color('black'))
screen.blit(text, (guiX + 172, guiY + 25 + 28 * (i + 2)))
#
if pygame.mouse.get_pressed()[0] == 1:
#print(pygame.mouse.get_pos())
mouse_pos = pygame.mouse.get_pos()
if guiX + 160 < mouse_pos[0] and guiX + 330 > mouse_pos[0]:
for i, attack in enumerate(attack_types):
if guiY + 25 + 28 * (i + 2) < mouse_pos[1] and (
guiY + 25 + 28 * (i + 2)) + 28 > mouse_pos[1]:
print(attack)
self.attack(attack_stats, enemy_stats, attack)
else:
pass
pass
def takeChest(self):
if len(inventory) < 27:
if chestContents[self.chestNo] != None:
for i in range(0, (len(chestContents[self.chestNo]))):
#print(i)
inventory.append(chestContents[self.chestNo][i])
chestContents[self.chestNo][:] = []
pickle.dump(
chestContents,
open(os.path.join("data", "saves", "chestContents.dat"), "wb"))
def run(self):
screenMode = pygame.RESIZABLE
oldPlay = stats['playTime']
clock = pygame.time.Clock()
self.running = True
self.grid = [0, 0]
debug = True
dispWidth, dispHeight = 1024, 768
self.menu = "game"
game_time = pygame.time.get_ticks()
playTime = font.render("Timer: ", False, pygame.Color('white'))
minutes = 0
self.map = stats['map'][:-4].lower()
self.map = self.map.lstrip(
"m") # Fix that stupid bug that changes "maze1" to "ze1"
self.map = self.map.lstrip("aps/")
try:
while self.running:
dt = (clock.tick() / 500)
clock.tick(self.fps)
if self.menu == "game":
#self.deep_thought()
if self.counter2 % 7 == 0:
heroPos = self.hero.position
self.animation(self.direction, self.counter)
self.hero.position = heroPos
#entityPos = self.entity.position
#self.EntityAnimation(self.EntityDirection, self.counter, "princess")
#self.entity.position = entityPos
self.counter += 1
guiX = (dispWidth / 2) - 175
guiY = (dispHeight / 2) - 165
self.group.remove(self.hero)
#self.group.remove(self.entity)
self.group.empty()
self.group.add(self.hero)
#self.group.add(self.entity)
self.counter2 += 1
if self.counter > 8:
self.counter = 1
stats['pos'] = self.hero.position
currentTime = systime()
seconds = currentTime - gameStart + oldPlay
dispWidth, dispHeight = pygame.display.get_surface().get_size()
stats['playTime'] = seconds
if debug == True and self.counter2 % 1 == 0:
location = font.render(
"Position: " +
str(round(round(self.hero.position[0], -1) / 10)) +
", " +
str(round(round(self.hero.position[1], -1) / 10)),
False, pygame.Color('white'))
mapdebug = font.render("Map Name: " + str(self.map), False,
pygame.Color('white'))
minutes = seconds // 60
secondsDisp = seconds % 60
if minutes < 1:
minutes = 0
if secondsDisp == 60:
secondsDisp = 0
minutes += 1
fps = font.render("FPS:" + str(int(clock.get_fps())),
False, pygame.Color('white'))
screen.blit(fps, (50, 50))
screen.blit(playTime, (50, 100))
screen.blit(location, (50, 75))
screen.blit(mapdebug, (50, 125))
playTime = font.render(
"Timer: " + str(floor(minutes)) + " : " +
str(round(secondsDisp)), True, pygame.Color('white'))
screen.blit(playTime, (50, 100))
self.blit_inventory(str(self.menu))
pygame.display.update()
#pygame,display.flip()
self.handle_input(self.menu)
self.update(dt)
self.draw(screen)
except KeyboardInterrupt:
self.running = False
pygame.quit()
