class FarmGame(object):
def __init__(self):
self.screen = pygame.display.get_surface()
GLOBALS.UI = UserInterface()
GLOBALS.game_running = False
GLOBALS.tile_map = TileMap()
GLOBALS.tile_map.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=GLOBALS.tile_map.map_layer, default_layer=2)
GLOBALS.hero = Hero()
GLOBALS.hero.position = GLOBALS.tile_map.map_layer.map_rect.center
for tree in GLOBALS.trees:
self.group.add(tree)
for ground in GLOBALS.ground:
self.group.add(ground)
self.group.add(GLOBALS.hero) # add player last!
self.input = Input()
def run(self):
clock = pygame.time.Clock()
GLOBALS.game_running = True
try:
while GLOBALS.game_running:
dt = clock.tick(60)/1000. # limit to 60fps, but also damn milliseconds, you fast
self.input.handle()
self.update(dt)
self.draw(self.screen)
GLOBALS.UI.draw(self.screen)
pygame.display.flip()
except KeyboardInterrupt:
GLOBALS.game_running = False
def update(self, dt):
self.group.update(dt)
def draw(self, surface):
self.group.center(GLOBALS.hero.rect.center)
self.group.draw(surface)
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 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 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 Map:
def __init__(self, game):
self.game = game
self.screen = game.screen
self.datahelper = game.datahelper
self.hero = game.hero
self.scriptengine = game.scriptengine
self.hero.map = self
def load(self, data):
#loading map to creating group
tmx_data = load_pygame(
path.join(self.game.dir, "data",
self.datahelper.maps[data["mapname"]]["file"]))
map_data = pyscroll.data.TiledMapData(tmx_data)
self.map_layer = pyscroll.BufferedRenderer(
map_data, self.screen.surface.get_size(),
clamp_camera=False) #tall_sprites=1)
self.map_layer.zoom = 2
self.group = PyscrollGroup(map_layer=self.map_layer,
default_layer=5) #data["layer"])
#setting up player
self.mapname = data["mapname"]
self.hero.position = [data["player"]["x"], data["player"]["y"] - 8]
if data["player"]["walking"] == 1:
self.hero.walking = True
self.hero.movingx, self.hero.movingy = data["player"][
"walkingx"], data["player"]["walkingy"]
self.hero.steps = 16
self.group.add(self.hero)
self.hero.rect.topleft = self.hero.position
#colliditon
self.collidable = {}
self.interactable = {}
self.warps = {}
self.npcs = {}
i = j = k = l = 0
for id in tmx_data.objects_by_id:
#print(tmx_data.objects_by_id[id].name)
if tmx_data.objects_by_id[id].name in self.datahelper.interactable:
self.interactable[j] = tmx_data.objects_by_id[id]
j += 1
if tmx_data.objects_by_id[id].name in self.datahelper.collidable:
self.collidable[i] = (tmx_data.objects_by_id[id].x,
tmx_data.objects_by_id[id].y)
i += 1
if "Warp" in tmx_data.objects_by_id[id].name:
self.warps[k] = tmx_data.objects_by_id[id]
k += 1
if "npc" in tmx_data.objects_by_id[id].name:
self.npcs[l] = self.scriptengine.load_npc(
tmx_data.objects_by_id[id])
#self.npcs[l] = NPC(tmx_data.objects_by_id[id].name)
#self.npcs[l].position = [tmx_data.objects_by_id[id].x, tmx_data.objects_by_id[id].y-8]
self.group.add(self.npcs[l])
self.npcs[l].map = self
#self.npcs[l].rect.topleft = self.npcs[l].position
#if "dir" in tmx_data.objects_by_id[id].properties.keys():
#self.npcs[l].dir = tmx_data.objects_by_id[id].properties["dir"]
#self.scriptengine.load(self.npcs[l])
#self.npcs[l].map = self
l += 1
#animations
#print(self.warps)
self.timer = 0
self.warping = False
self.nextmap = {}
def draw(self):
self.group.update()
self.hero.tick()
self.group.center(self.hero.rect.topleft)
#self.group.draw(screen)
#if self.loaded:
self.group.draw(self.screen.surface)
def change_map(self, data):
self.warps = 0
self.scriptengine.clear()
self.load(data)
def update(self):
for key, warp in self.warps.items():
if self.hero.rect.collidepoint(warp.x, warp.y):
if not self.screen.state["fade"]:
self.screen.drawFade()
if self.screen.fadein:
self.change_map(self.datahelper.warps[warp.name])
def collide(self, rect, npc=False):
for i in self.collidable:
if rect.collidepoint(self.collidable[i]):
return True
for i in self.npcs:
if self.npcs[i].walking:
if rect.colliderect(self.npcs[i].facing):
return True
if rect.collidepoint(self.npcs[i].position[0],
self.npcs[i].position[1] + 8):
return True
if npc and rect.collidepoint(self.hero.position[0],
self.hero.position[1] + 8):
return True
return False
def interact(self):
#print(self.interactable)
for i in self.interactable:
if self.hero.facing.collidepoint(self.interactable[i].x,
self.interactable[i].y):
dialogbox = Dialog(
self.datahelper.interactable[self.interactable[i].name],
self.screen.surface)
self.screen.drawDialog(dialogbox)
for i in self.npcs:
if not self.npcs[i].walking:
if self.hero.facing.collidepoint(self.npcs[i].rect.x,
self.npcs[i].rect.y + 8):
self.scriptengine.run(self.npcs[i])
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:
"""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 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(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)
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):
"""This class is essentially the Wizard of Oz"""
def __init__(self,
charactername='Zaxim',
username='******',
password='******',
ip='127.0.0.1',
current_room=None):
# Client for issuing requests to server and receiving responses
self.client = GameClient(charactername=charactername,
username=username,
password=password,
ip=ip)
# Remote sprite controller
self.rsc = RemoteSpriteController(self)
# Rate that chat polls are sent to server
self.poll_frequency = POLL_RATE
self.poll_timer = self.poll_frequency
self.out_going_message = None
# true while running
self.running = False
# load data from pytmx
if not current_room:
current_room = STARTING_ROOM
tmx_data = load_pygame(current_room)
self.map_data = tmx_data
# 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 = MAP_ZOOM
# pyscroll supports layered rendering.
self.group = PyscrollGroup(map_layer=self.map_layer,
default_layer=DEFAULT_LAYER)
# GUI ELEMENTS
# Create text box
text_box_x, text_box_y = self.screen_coords((3, 95))
self.text_box = eztext.Input(maxlength=90,
color=(255, 255, 255),
x=text_box_x,
y=text_box_y,
font=pygame.font.Font(FONT, 22),
prompt=': ')
# Create InputLog
self.inputlog = InputLog(coords=self.screen_coords((3, 88)),
max_length=10,
size=18,
spacing=18,
font=FONT)
# Create Combatlog
self.combatlog = InputLog(coords=(1050, 860),
max_length=10,
size=22,
spacing=18,
font=FONT)
# Login to server:
# Get room instance and player object id
response = self.client.login()
id = response['response']['id']
sprite = response['response']['sprite']
coords = response['response']['coords']
self.hero = Hero(game=self, id=id, sprite=sprite, coords=coords)
# Player input module
self.input = PlayerController(game=self)
# This is late -- ??? TODO This is garbage, current room needs to be discovered way earlier from login()
self.current_room = response['response']['current_room']
self.hero.position = STARTING_POSITION
self.group.add(self.hero.remotesprite)
self.rsc.initialize()
@property
def screen_size(self):
return pygame.display.Info().current_w, pygame.display.Info().current_h
@property
def map_size(self):
return self.map_data.width, self.map_data.height
@property
def charactername(self):
return self.client.charactername
def screen_coords(self, coords):
"""
:param coords: percentage of each axis. i.e. (50, 50) based on MAP position.
:return: Actual co-ords per resolution
"""
screen_x, screen_y = self.screen_size
new_x = (coords[0] / 100) * screen_x
new_y = (coords[1] / 100) * screen_y
return new_x, new_y
def poll_server(self, dt=60):
""" get remotesprite coordinate updates from server and pass to remotesprite controller """
self.poll_timer -= dt / 50.
if self.poll_timer <= 0:
self.poll_timer = self.poll_frequency
# Interface with RemoteSpriteController and update all lifeform coords
self.update_lifeforms()
# Update target if hero has one
self.hero.tgh.update_target()
# Update our Hero's armor
equipment_graphics = self.hero.remoteinventory.equipped_graphics()
self.hero.remotesprite.visualequipment.update_sprites(
equipment_graphics)
# TODO: Update remote player's inventory graphics
def update_lifeforms(self):
"""Update co-ordinates of all remote sprites with new information from server, also updates chat que and other
important information from the server """
# Update data on all lifeforms in room
r = self.client.send('get_roomdata')
coords_dict = r['response']['coords']
if coords_dict:
self.rsc.update_coords(coords_dict)
# Update chat messages
messages = r['response']['messages']
for message in messages:
self.inputlog.add_line(string=message['message'],
color=message['color'])
# Update remotesprite visual equipment (for remote players)
payloads = r['response']['payloads']
for payload in payloads:
if payload['tag'] == 'visualequipment':
playerid = payload['data']['playerid']
if playerid == self.hero.id:
continue
equip_data = payload['data']['visualequipment']
remotesprite = self.rsc.remotesprites[playerid]
graphics = [item for item in equip_data]
if not remotesprite.visualequipment:
remotesprite.visualequipment = VisualEquipment(
remotesprite=remotesprite, group=self.group)
remotesprite.visualequipment.update_sprites(graphics)
def update(self, dt):
""" Tasks that occur over time should be handled here"""
# self.hero.remotesprite.visualequipment.update()
# update all sprites in game world
self.group.update(dt)
# update camera position (follows player)
self.hero.camera.update(dt)
# move player (including animation) if we're moving
self.move(dt)
# perform auto attack if we're autoattacking
self.autoattack(dt)
def move(self, dt):
self.hero.move_timer -= dt / 100.
if self.hero.moving:
distance_x, distance_y = (self.hero.target_coords[0] - self.hero.x,
self.hero.target_coords[1] - self.hero.y)
stepx, stepy = (negpos(distance_x), negpos(distance_y))
self.hero.x += stepx
self.hero.y += stepy
if self.hero.move_timer <= 0:
self.hero.moving = False
self.hero.position = self.hero.target_coords
r = self.client.send('update_coords',
[self.hero.x, self.hero.y])
self.hero.move_time = r['response']['move_time']
self.hero.attack_time = r['response']['attack_time']
def autoattack(self, dt):
if self.hero.attacking:
self.hero.attack_timer -= dt / 100.
if self.hero.attack_timer <= 0:
self.hero.attack_timer = self.hero.attack_time
if self.hero.tgh.target:
if point_distance(self.hero.coords,
self.hero.tgh.coords) < 14:
self.client.send('attack', self.hero.tgh.id)
def draw(self, surface):
# center the map/screen on our Hero
self.group.center(self.hero.camera.rect.center)
# draw the Pyscroll map group
self.group.draw(surface)
def run(self):
""" Run the game loop"""
clock = pygame.time.Clock()
self.running = True
pygame.mouse.set_visible(False)
from collections import deque
times = deque(maxlen=30)
try:
while self.running:
dt = clock.tick(60)
times.append(clock.get_fps())
# Update From Server
try:
self.poll_server(dt)
except PacketSizeMismatch:
self.inputlog.add_line('Packet size mismatch!! Ignoring')
# Handle input and render
self.input.handle_input(dt)
self.update(dt)
self.draw(screen)
if self.hero.particle:
self.hero.particle.update()
# blit GUI objects to screen
self.text_box.draw(screen)
self.inputlog.draw(screen)
self.combatlog.draw(screen)
self.hero.tgh.display.draw(screen)
# debug draw co-ordinates
if DEBUG_MODE:
# # pos = [coord/16 for coord in self.hero.position]
# draw_text('hero.position:. . . . {0}'.format(str(self.hero.position)), screen, coords=(10, 10))
# draw_text('delta t:. . . . . . . {0}'.format(str(dt)), screen, coords=(10, 40))
# draw_text('server poll:. . . . . {0}'.format(str(self.poll_timer)), screen, coords=(10, 55))
# draw_text('moving: . . . . . . . {0}'.format(str(self.hero.moving)), screen, coords=(10, 70))
# draw_text('target_coords:. . . . {0}'.format(str(self.hero.target_coords)), screen, coords=(10, 85))
# draw_text('map_zoom: . . . . . . {0}'.format(str(self.map_layer.zoom)), screen, coords=(10, 100))
# draw_text('screen size:. . . . . {0}'.format(str(self.screen_size)), screen, coords=(10, 115))
# draw_text(str(pygame.display.Info().current_w), screen, coords=(10, 130))
#
# draw_text('Target ID: ', screen, coords=(10, 10))
# draw_text('Name: ', screen, coords=(10, 25))
# draw_text('Stats: ', screen, coords=(10, 40))
# draw_text('Center Offset: {0}'.format(offset), screen, coords=(10, 55))
# draw_text('MousePos: {0}'.format(pygame.mouse.get_pos()), screen, coords=(10, 70))
# draw_text('MousePosC: {0},{1}'.format(new_x, new_y), screen, coords=(10, 85))
# draw_text('PlayerCoords: {0}'.format(self.hero.coords), screen, coords=(10, 100))
# draw_text('CursorCoords: {0}'.format(cursor_coords), screen, coords=(10, 115))
# draw_text('Zoom: {0}'.format(zoom), screen, coords=(10, 130))
#draw_text('Nearby Lifeforms: {0}'.format(self.hero.nearby_lifeforms), screen, coords=(10, 130))
# if self.hero.tgh.target:
# distance = point_distance(self.hero.coords, self.hero.tgh.coords)
# draw_text('Target Distance: {0}'.format(distance), screen, coords=(10, 145))
#
# draw_text('Attacking: {0}'.format(self.hero.attacking), screen, coords=(10, 160))
pass
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 = 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 Game:
def __init__(self):
self.running = False
self.file_name = 'map/map.tmx'
self.tmx_data = load_pygame(self.file_name)
self.map = Map(tmx_data=self.tmx_data)
self.font = pygame.font.Font('freesansbold.ttf', 32)
self.focus_car = False
def init_group(self):
map_data = pyscroll.data.TiledMapData(self.tmx_data)
self.map_layer = pyscroll.BufferedRenderer(map_data,
screen.get_size(),
clamp_camera=True)
self.map_layer.zoom = 0.3
self.zoomchange = 1
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=1)
def init_world(self):
self.car = Car('mymap/car.png', (450, 450), 45)
self.render_car()
def update(self, dt):
self.group.update(dt)
def draw(self, surface):
if self.focus_car:
self.group.center(self.car.rect.center)
self.group.draw(surface)
def render_car(self):
self.focus_car = True
self.group.add(self.car)
def handle_input(self, event):
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_EQUALS:
self.map_layer.zoom += .25
elif event.key == pygame.K_MINUS:
value = self.map_layer.zoom - .25
if value > 0:
self.map_layer.zoom = value
if event.key == pygame.K_UP:
self.car.speed += 1
elif event.key == pygame.K_DOWN:
self.car.speed -= 1
elif event.key == pygame.K_LEFT:
self.car.angle_speed = -4
elif event.key == pygame.K_RIGHT:
self.car.angle_speed = 4
elif event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT:
self.car.angle_speed = 0
elif event.key == pygame.K_RIGHT:
self.car.angle_speed = 0
def run(self):
clock = pygame.time.Clock()
self.running = True
while self.running:
dt = clock.tick(60) / 1000
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
self.handle_input(event)
self.update(dt)
self.draw(screen)
pygame.display.flip()
class QuestGame(object):
""" This class is a basic game.
This class will load resources, 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.
"""
def __init__(self):
# true while running
self.running = False
# create new data source for pyscroll
self.map_data = InfiniteMap()
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(self.map_data,
screen.get_size())
self.map_layer.zoom = 1
# 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()
self.hero.position = 518 * 32, 560 * 32
# 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_r:
self.map_data.reload()
self.map_layer.redraw_tiles(self.map_layer._buffer)
elif event.key == K_q:
self.map_data.NOISE_SIZE -= .5
self.hero.position = self.hero.position[
0] * .985, self.hero.position[1] * .985
self.map_data.reload()
self.map_layer.redraw_tiles(self.map_layer._buffer)
elif event.key == K_w:
self.map_data.NOISE_SIZE += .5
self.map_data.reload()
self.hero.position = self.hero.position[
0] * 1.015, self.hero.position[1] * 1.015
self.map_layer.redraw_tiles(self.map_layer._buffer)
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)
def run(self):
""" Run the game loop
"""
clock = pygame.time.Clock()
self.running = True
from collections import deque
times = deque(maxlen=300)
noise = SimplexNoise().noise2
two_pi = 2 * math.pi
poll = 1
try:
while self.running:
dt = clock.tick_busy_loop(60) / 1000.
self.handle_input()
self.update(dt)
begin = time()
self.draw(screen)
times.append(time() - begin)
# if len(times) > 0:
# print(len(times), round(sum(times) / len(times), 4))
#
# poll -= dt
# if poll < 0:
# self.map_data._first_draw = True
# self.map_data.reload()
# self.map_layer.redraw_tiles(self.map_layer._buffer)
# xx, yy = self.hero.position
#
# xx /= 1000
# yy /= 1000
#
# for y in range(0, 320, 32):
# for x in range(0, 320, 32):
# v = (noise(xx + x / 1000, yy + y / 1000) + 1) * 128
# color = v, v, v
# print(color)
# screen.fill(color, (x, y, 32, 32))
pygame.display.flip()
except KeyboardInterrupt:
self.running = False
class ScrollMap(object):
"""Scroll Map object.
The implementation is based on [pyscroll](https://github.com/bitcraft/pyscroll)
This class provides functionality:
- create and manage a pyscroll group
- load a collision layers
- manage sprites added to the map
- allows to detect collisions with loaded collision layers
- render the map and the sprites on top
"""
def __init__(self,
screen_size: Tuple[int, int],
tmx: pytmx.TiledMap,
collision_layers: List[str] = []) -> None:
"""Create scroll map object.
Args:
screen_size (Tuple[int, int]): screen resolution will be used to the map rendering
tmx (pytmx.TiledMap): loaded `pytmx.TiledMap` object
collision_layers (List[str], optional): List of `pytmx.TiledMap` layer names will be used for tiles collision detection. Defaults to [].
"""
self._tmx = tmx
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(self._tmx)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data,
screen_size,
clamp_camera=False,
tall_sprites=1)
self.map_layer.zoom = 1
# 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._map_group = PyscrollGroup(map_layer=self.map_layer,
default_layer=2)
self._map_collision_obj: List[pygame.Rect] = []
self.add_collision_layers(collision_layers)
def add_collision_layers(self, collision_layers: List[str]) -> None:
"""Load `pytmx.TiledMap` layer tiles for collision detection.
Some layer in the `pytmx.TiledMap` might be be used for collision detection.
For example: the layer includes "island tiles" might be used for collision detection with a "ship" actor.
Args:
collision_layers (List[str]): List of `pytmx.TiledMap` layer names will be used for tiles collision detection.
"""
# setup level geometry with simple pygame rects, loaded from pytmx
self._map_collision_obj += extract_collision_objects_from_tile_layers(
self._tmx, collision_layers)
def view(self) -> Any:
return self._map_group.view
def transform(self, pos: Tuple[int, int]) -> Tuple[int, int]:
return (pos[0] + self._map_group.view.left,
pos[1] + self._map_group.view.top)
def draw(self, screen: Screen) -> None:
"""Draw method similar to the `pgz.scene.Scene.draw` method.
Will draw the map and all actors on top.
Args:
dt (float): time in milliseconds since the last update
"""
self._map_group.draw(screen.surface)
def update(self, dt: float) -> None:
"""Update method similar to the `pgz.scene.Scene.update` method.
All the actors attached to the map will be updated.
Args:
dt (float): time in milliseconds since the last update
"""
self._map_group.update(dt)
def add_sprite(self, sprite: pygame.sprite.Sprite) -> None:
"""Add actor/sprite to the map
Args:
sprite (pygame.sprite.Sprite): sprite object to add
"""
self._map_group.add(sprite)
def remove_sprite(self, sprite: pygame.sprite.Sprite) -> None:
"""Remove sprite/actor from the map.
Args:
sprite (pygame.sprite.Sprite): sprite object to remove
"""
sprite.remove(self._map_group)
def set_center(self, point: Tuple[int, int]) -> None:
self._map_group.center(point)
def get_center(self) -> Tuple[int, int]:
if not self.map_layer.map_rect:
raise Exception("Map was not configured properly")
return self.map_layer.map_rect.center # type: ignore
def change_zoom(self, change: float) -> None:
value = self.map_layer.zoom + change
if value > 0:
self.map_layer.zoom = value
def set_size(self, size: Tuple[int, int]) -> None:
self.map_layer.set_size(size)
def collide_map(self, sprite: pygame.sprite.Sprite) -> bool:
"""Detect a collision with tiles on the map
Args:
sprite (pygame.sprite.Sprite): sprite/actor for detection
Returns:
bool: True is the collision with the colision layers was detected
"""
if not sprite.rect:
return False
return bool(sprite.rect.collidelist(self._map_collision_obj) > -1)
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 WorldInfo(tools._State):
def __init__(self,map,surface,world,music):
super(WorldInfo, self).__init__()
tmx_data = load_pygame(map)
map_data = pyscroll.data.TiledMapData(tmx_data)
self.map_layer = pyscroll.BufferedRenderer(map_data, SCREEN_SIZE)
self.map_layer.zoom = 0.5
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=2)
self.animations = pg.sprite.Group()
self.labels = pg.sprite.Group()
self.letters = pg.sprite.Group()
self.surface = surface.convert_alpha()
self.world = world
self.music = music
for object in tmx_data.objects:
if object.name == 'enemy':
Enemy(object.x, object.y, self.group)
elif object.name == 'fish':
Fish(object.x, object.y, self.group)
elif object.name == 'fly':
Fly(object.x, object.y, self.group)
elif object.name == 'coin':
Coin(object.x, object.y, self.group)
elif object.name == 'bat':
Bat(object.x, object.y, self.group)
elif object.name == 'enimy':
Enimy(object.x, object.y, self.group)
elif object.name == 'f1sh':
F1sh(object.x, object.y, self.group)
self.font = FONTS["UbuntuMono-B"]
timespan = 3000
midbottom = (SCREEN_RECT.centerx, SCREEN_RECT.bottom - 20)
self.prompt = Blinker("Press Enter key to continue", {"midbottom": midbottom},
500, text_color=(255, 255, 255), font_path=self.font,
font_size= 25)
task = Task(self.labels.add, timespan, args=(self.prompt,))
self.animations.add(task)
def startup(self, persist):
pg.mixer.init()
song = self.music
pg.mixer.music.load(song)
pg.mixer.music.set_volume(0.1)
pg.mixer.music.play()
self.done = False
self.persist = persist
self.mask = self.persist['surface']
self.transition = Transition(self.mask)
if 'lives' in self.persist:
self.lives = self.persist['lives']
else:
self.lives = LIVES
if 'coins' in self.persist:
self.coins = self.persist['coins']
else:
self.coins = 0
font_color = (197, 143, 92)
text = 'Bottom World' if self.world =='bottom' else 'Upper World'
Label(text,{"topleft": (10, 10)}, self.labels, font_path=self.font, font_size=20,text_color = font_color)
self.live_surf = pg.Surface((100,20),pg.SRCALPHA)
image = pg.transform.scale(GFX['hud_0'],(20,20))
self.live_surf.blit(image, (30,0))
labels = pg.sprite.Group()
Label(' X {}'.format(self.lives), {"topleft": (50, 0)}, labels, font_path= self.font, font_size=20,text_color = font_color)
labels.draw(self.live_surf)
self.coin_surf = pg.Surface((100,20),pg.SRCALPHA)
img = pg.transform.scale(GFX['hud_coins'], (20, 20))
self.coin_surf.blit(img,(30,0))
lab = pg.sprite.Group()
Label(' X {}'.format(self.coins), {"topleft": (50, 0)}, lab, font_path=self.font, font_size=20,
text_color=font_color)
lab.draw(self.coin_surf)
def cleanup(self):
pg.mixer.quit()
self.persist['coins'] = self.coins
self.persist['lives'] = self.lives
self.persist['surface']= pg.display.get_surface()
return self.persist
def get_event(self, event):
if event.type == pg.QUIT:
self.quit = True
elif event.type == pg.KEYUP:
if event.type == pg.K_ESCAPE:
self.quit = True
elif event.key == pg.K_RETURN:
self.done = True
self.next = "LEVELPLAY"
def update(self, dt):
self.group.update(dt)
self.animations.update(dt)
self.labels.update(dt)
def draw(self, surface):
self.group.draw(surface)
self.group.center((SCREEN_RECT.centerx,SCREEN_RECT.bottom))
surface.blit(self.surface, (0, 0))
surface.blit(self.live_surf,(0,40))
surface.blit(self.coin_surf,(0,80))
self.letters.draw(surface)
self.labels.draw(surface)
self.transition.draw(surface)
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 LevelPlay(tools._State):
def __init__(self):
super(LevelPlay, self).__init__()
tmx_data = load_pygame(MAP['map0'])
map_data = pyscroll.data.TiledMapData(tmx_data)
self.map_rect = pg.Rect(0, 0,
map_data.map_size[0] * map_data.tile_size[0],
map_data.map_size[1] * map_data.tile_size[1])
self.map_layer = pyscroll.BufferedRenderer(map_data, SCREEN_SIZE)
self.map_layer.zoom = 1
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=2)
self.animations = pg.sprite.Group()
self.labels = pg.sprite.Group()
self.enemies = pg.sprite.Group()
self.coins = pg.sprite.Group()
self.pos_x = None
self.pos_y = None
self.pos_x_r = None
self.pos_y_r = None
self.upper_world = False
self.time = 0
self.timer = TIME
self.coin_num = 0
self.player_lives = 0
self.hud = Hud()
self.walls = list()
for object in tmx_data.objects:
if object.name == 'collide':
self.walls.append(
pg.Rect(object.x, object.y, object.width, object.height))
elif object.name == 'playerpos':
self.pos_x = object.x
self.pos_y = object.y
self.player = Player(self.pos_x, self.pos_y, False, self.group)
elif object.name == 'playerpos_r':
self.pos_x_r = object.x
self.pos_y_r = object.y
elif object.name == 'enemy':
Enemy(object.x, object.y, self.enemies)
elif object.name == 'fish':
Fish(object.x, object.y, self.enemies)
elif object.name == 'fly':
Fly(object.x, object.y, self.enemies)
elif object.name == 'coin':
Coin(object.x, object.y, self.coins)
elif object.name == 'bat':
Bat(object.x, object.y, self.enemies)
elif object.name == 'enimy':
Enimy(object.x, object.y, self.enemies)
elif object.name == 'f1sh':
F1sh(object.x, object.y, self.enemies)
elif object.name == 'over_event':
self.over_rect = pg.Rect(object.x, object.y, object.width,
object.height)
elif object.name == 'over_event_r':
self.over_rect_r = pg.Rect(object.x, object.y, object.width,
object.height)
self.player.platform = self.walls
def get_event(self, event):
self.player.get_event(event)
if event.type == pg.QUIT:
self.quit = True
elif event.type == pg.KEYDOWN:
if event.key == pg.K_SPACE:
self.map_layer.zoom = 0.5
elif event.type == pg.KEYUP:
if event.type == pg.K_ESCAPE:
self.quit = True
elif event.key == pg.K_SPACE:
self.map_layer.zoom = 1
else:
pass
def startup(self, persist):
pg.mixer.init()
song = MUSIC['bg']
pg.mixer.music.load(song)
pg.mixer.music.set_volume(0.1)
pg.mixer.music.play()
self.done = False
self.persist = persist
self.mask = self.persist['surface']
self.transition = Transition(self.mask)
self.player_lives = self.persist['lives']
self.coin_num = self.persist['coins']
if self.player.reverse == True:
self.fog = pg.Surface(SCREEN_RECT.size, pg.SRCALPHA)
self.fog_color = (0, 0, 0, 200)
self.fog.fill(self.fog_color)
def player_dead(self):
sound = SFX['dead0']
sound.play()
self.player_lives -= 1
if self.player_lives < 1:
self.done = True
self.next = 'LOSE'
buffer = pg.display.get_surface()
self.switch_screen = Transition(buffer)
if self.player.reverse == False:
self.player.rect.x, self.player.rect.y = self.pos_x, self.pos_y
elif self.player.reverse == True:
self.player.rect.x, self.player.rect.y = self.pos_x_r, self.pos_y_r
def update(self, dt):
self.offset_x, self.offset_y = self.group._map_layer.get_center_offset(
)
self.time += dt
if self.time > self.timer:
self.time -= self.timer
self.player_dead()
self.group.update(dt)
self.enemies.update(dt)
self.coins.update(dt)
self.hud.update(self, dt)
self.animations.update(dt)
if self.player.rect.colliderect(self.over_rect_r):
if self.player.reverse == True:
self.done = True
self.next = 'WIN'
if self.player.rect.colliderect(self.over_rect):
self.player.rect.x, self.player.rect.y = self.pos_x_r, self.pos_y_r
if self.coin_num >= 30:
self.player.kill()
self.player = Player(self.pos_x_r, self.pos_y_r, True,
self.group)
self.player.platform = self.walls
self.done = True
self.next = 'UPPER'
elif self.coin_num < 30:
self.player.reverse = False
self.done = True
self.next = 'BOTUP'
if pg.sprite.spritecollide(self.player, self.coins, True):
self.coin_num += 1
sound = SFX['coin']
sound.play()
self.labels.empty()
self.animations.empty()
coin_sprite = pg.sprite.Sprite(self.labels)
coin_sprite.image = GFX['hud_coins']
x = self.offset_x + self.player.rect.x
y = self.offset_y + self.player.rect.y
coin_sprite.rect = pg.Rect((x, y), coin_sprite.image.get_size())
ani = Animation(x=50, y=10, duration=100, transition="out_bounce")
ani.start(coin_sprite.rect)
self.animations.add(ani)
if not self.map_rect.contains(self.player.rect):
self.player_dead()
if pg.sprite.spritecollide(self.player, self.enemies, False):
self.player_dead()
self.labels.update(dt)
def cleanup(self):
pg.mixer.quit()
self.persist = {}
self.persist['coins'] = self.coin_num
self.persist['lives'] = self.player_lives
self.persist['surface'] = pg.display.get_surface()
return self.persist
def draw(self, surface):
self.group.empty()
if self.player.reverse == True:
close = (enemy for enemy in self.enemies if get_distance(
enemy.rect.center, self.player.rect.center) <= 100)
close_enemies = pg.sprite.Group(close)
self.group.add(self.player, self.coins, close_enemies)
elif self.player.reverse == False:
close = (enemy for enemy in self.enemies if get_distance(
enemy.rect.center, self.player.rect.center) <= SCREEN_SIZE[0])
close_enemies = pg.sprite.Group(close)
self.group.add(self.player, self.coins, close_enemies)
self.group.draw(surface)
self.group.center(self.player.rect.center)
if hasattr(self, 'fog') and self.map_layer.zoom == 1:
self.fog.fill(self.fog_color)
for i in range(200):
pg.draw.circle(self.fog, pg.Color(0, 0, 0, 200 - i),
(self.player.rect.centerx + self.offset_x,
self.player.rect.centery + self.offset_y),
int(100 - i * 0.5))
surface.blit(self.fog, (0, 0))
elif hasattr(self, 'fog') and self.map_layer.zoom == 0.5:
self.fog.fill(self.fog_color)
surface.blit(self.fog, (0, 0))
self.hud.draw(surface)
self.transition.draw(surface)
self.labels.draw(surface)
if hasattr(self, 'switch_screen'):
self.switch_screen.draw(surface)
class TravelGame(object):
filename = get_map('testing.tmx')
def __init__(self, *args, **kwargs):
self.running = False
tilemap_data = load_pygame(self.filename)
map_data = pyscroll.data.TiledMapData(tilemap_data)
self.map_layer = pyscroll.BufferedRenderer(map_data,
screen.get_size(),
clamp_camera=False)
self.map_layer.zoom = 5
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=4)
self.player = Player()
self.player.position = (128, 248)
self.group.add(self.player)
self.blockers = []
for obj in tilemap_data.get_layer_by_name("collision"):
properties = obj.__dict__
if properties['name'] == 'blocker':
x = properties['x']
y = properties['y']
width = properties['width']
height = properties['height']
new_rect = pygame.Rect(x, y, width, height)
self.blockers.append(new_rect)
def draw(self, surface):
self.group.center(self.player.rect.center)
self.group.draw(surface)
def handle_input(self):
poll = pygame.event.poll
event = poll()
while event:
if event.type == QUIT:
self.running = False
break
event = poll()
pressed = pygame.key.get_pressed()
if pressed[K_DOWN]:
self.player.vely = SPEED
elif pressed[K_UP]:
self.player.vely = -SPEED
else:
self.player.vely = 0
if pressed[K_LEFT]:
self.player.velx = -SPEED
elif pressed[K_RIGHT]:
self.player.velx = SPEED
else:
self.player.velx = 0
# TODO Fix collision so they player stops when they hit a collider
for blocker in self.blockers:
if self.player.rect.colliderect(blocker):
print("collide")
def update(self, dt):
self.group.update(dt)
def run(self):
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())
self.handle_input()
self.update(dt)
self.draw(screen)
pygame.display.flip()
except KeyboardInterrupt:
self.running = False
