def __init__(self):
super(Intro, self).__init__()
tmx_data = load_pygame(MAP['intro'])
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 = GFX['intro'].convert_alpha()
self.cheat = False
timespan = 3000
midbottom = (SCREEN_RECT.centerx, SCREEN_RECT.bottom - 20)
font = FONTS["UbuntuMono-B"]
self.prompt = Blinker("Press Enter key to continue", {"midbottom": midbottom},
500, text_color=(255, 255, 255), font_path=font,
font_size= 25)
Label('UP-UP-DOWN-DOWN-LEFT-RIGHT-LEFT-RIGHT-B-A',{"topleft": (50, 0)},self.labels,font_path=font,font_size = 7)
task = Task(self.labels.add, timespan, args=(self.prompt,))
self.animations.add(task)
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 __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 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 __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 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/")
class NewRender(object):
def __init__(self, filename):
self.tmx_data = util_pygame.load_pygame(filename)
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(self.tmx_data)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data, (640,640))
self.map_layer.zoom = 1
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=0)
def draw_map(self, display, playChar):
# center the map/screen on our Hero
#self.group.center(self.hero.rect.center)
self.group.center(playChar.rect.center)
# draw the map and all sprites
self.group.draw(display)
def get_dims(self):
props = self.tmx_data.properties
width = int(props['Width'])
height = int(props['Height'])
return width, height
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 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__(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 __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, 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 __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 __init__(self, filename):
self.tmx_data = util_pygame.load_pygame(filename)
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(self.tmx_data)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data, (640,640))
self.map_layer.zoom = 1
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=0)
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 __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 __init__(self, fileName):
#Создать объект карты из PyTMX
self.mapObject = pytmx.load_pygame(fileName)
##Настройка геометрии уровня с простыми pygame прямоугольниками, загруженными из pytmx
self.walls = list()
self.npcs = list()
self.stairs = list()
for map_object in self.mapObject.objects:
if map_object.type == "wall":
print("wall загрузка не удалась: переопределение wall")
#self.walls.append(Wall(map_object))
elif map_object.type == "stair":
print("stair загрузка не удалась: переопределение stair")
#self.stairs.append(Wall(map_object))
elif map_object.type == "guard":
print("npc загрузка не удалась: переопределение npc")
#self.npcs.append(Npc(map_object))
elif map_object.type == "hero":
print("hero загрузка не удалась: переопределение hero")
#self.hero = Hero(map_object)
##Создать новый источник данных для pyscroll
map_data = pyscroll.data.TiledMapData(self.mapObject)
##Создать новый рендер (камера)
screen = init_screen(SCREEN_WIDTH, SCREEN_HEIGHT)
self.map_layer = pyscroll.BufferedRenderer(map_data,
screen.get_size(),
clamp_camera=True,
tall_sprites=1)
self.map_layer.zoom = 2
##pyscroll поддерживает многоуровневую визуализацию. наша карта имеет 3 нижних слоя
##Слои начинаются с 0, поэтому это 0, 1 и 2.
##Так как мы хотим, чтобы спрайт был на вершине слоя 1, мы устанавливаем значение по умолчанию
##слой для спрайтов как 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=3)
##Добавить нашего героя в группу объектов для рендеринга
##self.group.add(self.hero)
##for npc in self.npcs:
## self.group.add(npc)
#Создать список слоев для карты
self.layers = []
#Число сдвига уровня влево/вправо
self.levelShift = 0
#Создайте слои для каждого слоя на карте тайлов
for layer in range(len(self.mapObject.layers)):
self.layers.append(Layer(index=layer, mapObject=self.mapObject))
def load_level(self, level_info):
tiled_map = load_pygame(level_info['tmx_file'])
map_data = pyscroll.data.TiledMapData(tiled_map)
map_layer = RogueRenderer(map_data, [800, 600],
clamp_camera=False,
tall_sprites=0)
map_layer._redraw_cutoff = 24
map_layer.zoom = 1
sprite_group = PyscrollGroup(map_layer=map_layer, default_layer=0)
level_info['tiled_map'] = tiled_map
level_info['map_layer'] = map_layer
level_info['sprite_group'] = sprite_group
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 __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 __init__(self, screen):
State.__init__(self, screen)
self.name = "GameState"
self.description = "Draw your game inside here"
# A whole Block just to display the Text ...
self.font1 = pygame.font.SysFont("Monospaced", 50)
self.font2 = pygame.font.SysFont("Monospaced", 32)
# Render the text
self.text1 = self.font1.render(self.name, True, (255,255, 255), (159, 182, 205))
self.text2 = self.font2.render(self.description, True, (255,255, 255), (159, 182, 205))
# Create Text-rectangles
self.text1Rect = self.text1.get_rect()
self.text2Rect = self.text2.get_rect()
# Center the Text-rectangles
self.text1Rect.centerx = self.screen.get_rect().centerx
self.text1Rect.centery = self.screen.get_rect().centery
self.text2Rect.centerx = self.screen.get_rect().centerx
self.text2Rect.centery = self.screen.get_rect().centery+50
self.screen_rect = screen.get_rect()
self.done = False
self.fps = 60
self.done = False
self.keys = pygame.key.get_pressed()
# true while running
self.running = False
# load data from pytmx
self.tmx_data = load_pygame(self.filename, pixelalpha=True)
#print self.tmx_data.layers.TiledTileLayer.properties['under0']
# setup level geometry with simple pygame rects, loaded from pytmx
# create new data source for pyscroll
self.map_data = pyscroll.data.TiledMapData(self.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
# cambiar el 1 por el tamano de zoom
self.map_layer = pyscroll.BufferedRenderer(self.map_data,
(w / 1, h / 1),
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)
def __init__(self, fname):
self.width, self.height = 1024, 768
self.tile_width, self.tile_height = 64, 32
self.fullname = os.path.join('data', '%s.tmx' % fname)
self.tmx_data = load_pygame(self.fullname)
self.map_data = pyscroll.TiledMapData(self.tmx_data)
self.tileset = load_image("iso-64x64-outside.png")
self.map_layer = pyscroll.IsometricBufferedRenderer(self.map_data, (self.width, self.height))
self.map_layer.zoom = 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=2)
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 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 __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 __init__(self):
super(Hunting, self).__init__()
map_data = MapData()
map_layer = BufferedRenderer(map_data, prepare.SCREEN_SIZE)
self.all_sprites = PyscrollGroup(map_layer=map_layer)
self.colliders = pg.sprite.Group()
self.ui = pg.sprite.Group()
self.noise_detector = NoiseDetector((10, 80), self.ui)
self.animations = pg.sprite.Group()
self.hunter = Hunter(map_layer.map_rect.center, 0,
self.noise_detector, self.all_sprites)
self.leaves = pg.sprite.Group()
self.roasts = pg.sprite.Group()
self.flocks = pg.sprite.Group()
self.turkeys = self.add_turkeys()
self.bullets = pg.sprite.Group()
self.make_trees()
hx, hy = self.hunter.rect.center
self.ammo_crate = AmmoCrate((hx - 50, hy - 50), self.colliders,
self.all_sprites)
self.rustle_sounds = [prepare.SFX["rustle{}".format(x)]
for x in range(1, 21)]
self.wind_gust()
style = {"font_path": prepare.FONTS["pretzel"],
"font_size": 24, "text_color": (58, 41, 18)}
self.shell_label = Label("{}".format(self.hunter.shells),
{"topleft": (50, 10)}, **style)
self.roasts_label = Label("{}".format(self.hunter.roasts),
{"topleft": (50, 50)}, **style)
Icon((20, 3), "shell", self.ui)
Icon((10, 45), "roast", self.ui)
self.add_flock()
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 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))
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
}
class Intro(tools._State):
def __init__(self):
super(Intro, self).__init__()
tmx_data = load_pygame(MAP['intro'])
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 = GFX['intro'].convert_alpha()
self.cheat = False
timespan = 3000
midbottom = (SCREEN_RECT.centerx, SCREEN_RECT.bottom - 20)
font = FONTS["UbuntuMono-B"]
self.prompt = Blinker("Press Enter key to continue", {"midbottom": midbottom},
500, text_color=(255, 255, 255), font_path=font,
font_size= 25)
Label('UP-UP-DOWN-DOWN-LEFT-RIGHT-LEFT-RIGHT-B-A',{"topleft": (50, 0)},self.labels,font_path=font,font_size = 7)
task = Task(self.labels.add, timespan, args=(self.prompt,))
self.animations.add(task)
def startup(self, persist):
pg.mixer.init()
song = MUSIC['intro']
pg.mixer.music.load(song)
pg.mixer.music.set_volume(0.1)
pg.mixer.music.play()
self.persist = persist
self.mask = self.persist['surface']
self.transition = Transition(self.mask)
self.code = ''
def cleanup(self):
pg.mixer.quit()
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.key == pg.K_ESCAPE:
self.quit = True
elif event.key == pg.K_RETURN:
self.done = True
self.next = 'BOTTOM'
elif event.key == pg.K_UP:
self.code += 'u'
elif event.key == pg.K_DOWN:
self.code += 'd'
elif event.key == pg.K_LEFT:
self.code += 'l'
elif event.key == pg.K_RIGHT:
self.code += 'r'
elif event.key == pg.K_a:
self.code += 'a'
elif event.key == pg.K_b:
self.code += 'b'
else:
pass
def update(self, dt):
if self.code.endswith('uuddlrlrba'):
self.cheat = True
self.persist['lives'] = CHEAT_LIVES
self.code += 'a'
if self.cheat == True:
sound = SFX['cheat']
sound.play()
self.cheat = False
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))
self.transition.draw(surface)
self.letters.draw(surface)
self.labels.draw(surface)
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 GameState(State):
# Gamestate - run your stuff inside here (maybe another manager?
# for your levelmanagment?)
filename = get_map(MAP_FILENAME)
def __init__(self, screen):
State.__init__(self, screen)
self.name = "GameState"
self.description = "Draw your game inside here"
# A whole Block just to display the Text ...
self.font1 = pygame.font.SysFont("Monospaced", 50)
self.font2 = pygame.font.SysFont("Monospaced", 32)
# Render the text
self.text1 = self.font1.render(self.name, True, (255,255, 255), (159, 182, 205))
self.text2 = self.font2.render(self.description, True, (255,255, 255), (159, 182, 205))
# Create Text-rectangles
self.text1Rect = self.text1.get_rect()
self.text2Rect = self.text2.get_rect()
# Center the Text-rectangles
self.text1Rect.centerx = self.screen.get_rect().centerx
self.text1Rect.centery = self.screen.get_rect().centery
self.text2Rect.centerx = self.screen.get_rect().centerx
self.text2Rect.centery = self.screen.get_rect().centery+50
self.screen_rect = screen.get_rect()
self.done = False
self.fps = 60
self.done = False
self.keys = pygame.key.get_pressed()
# true while running
self.running = False
# load data from pytmx
self.tmx_data = load_pygame(self.filename, pixelalpha=True)
#print self.tmx_data.layers.TiledTileLayer.properties['under0']
# setup level geometry with simple pygame rects, loaded from pytmx
# create new data source for pyscroll
self.map_data = pyscroll.data.TiledMapData(self.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
# cambiar el 1 por el tamano de zoom
self.map_layer = pyscroll.BufferedRenderer(self.map_data,
(w / 1, h / 1),
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
def render(self, screen):
# Rendering the State
pygame.display.set_caption(self.name +" "+self.description)
screen.fill((20, 20, 20))
self.screen.blit(self.text1, self.text1Rect)
self.screen.blit(self.text2, self.text2Rect)
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 update(self):
clock = pygame.time.Clock()
scale = pygame.transform.scale
self.running = True
try:
while self.running:
dt = clock.tick() / 1000.
self.draw(temp_surface)
scale(temp_surface, self.screen.get_size(), self.screen)
pygame.display.flip()
#self.clocky.tick(self.fps)
#self.display_fps()
except KeyboardInterrupt:
self.running = False
pass
def handle_events(self,events):
# every State has its own eventmanagment
for e in events:
if e.type == QUIT:
print ("Pressed Quit (Window)")
return False
elif e.type == KEYDOWN:
if e.key == K_ESCAPE:
print ("Pressed Quit (Esc)")
return False
# change State if user presses "2"
if e.key == K_2:
self.manager.change(MenuState(self.screen))
# change State if user presses "1"
if e.key == K_1:
self.manager.change(IntroState(self.screen))
return True
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)
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
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))
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 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 Hunting(GameState):
"""The main game state."""
roast_live_time = 10000
roast_fade_time = 1000
def __init__(self):
super(Hunting, self).__init__()
map_data = MapData()
map_layer = BufferedRenderer(map_data, prepare.SCREEN_SIZE)
self.all_sprites = PyscrollGroup(map_layer=map_layer)
self.colliders = pg.sprite.Group()
self.ui = pg.sprite.Group()
self.noise_detector = NoiseDetector((10, 80), self.ui)
self.animations = pg.sprite.Group()
self.hunter = Hunter(map_layer.map_rect.center, 0,
self.noise_detector, self.all_sprites)
self.leaves = pg.sprite.Group()
self.roasts = pg.sprite.Group()
self.flocks = pg.sprite.Group()
self.turkeys = self.add_turkeys()
self.bullets = pg.sprite.Group()
self.make_trees()
hx, hy = self.hunter.rect.center
self.ammo_crate = AmmoCrate((hx - 50, hy - 50), self.colliders,
self.all_sprites)
self.rustle_sounds = [prepare.SFX["rustle{}".format(x)]
for x in range(1, 21)]
self.wind_gust()
style = {"font_path": prepare.FONTS["pretzel"],
"font_size": 24, "text_color": (58, 41, 18)}
self.shell_label = Label("{}".format(self.hunter.shells),
{"topleft": (50, 10)}, **style)
self.roasts_label = Label("{}".format(self.hunter.roasts),
{"topleft": (50, 50)}, **style)
Icon((20, 3), "shell", self.ui)
Icon((10, 45), "roast", self.ui)
self.add_flock()
def wind_gust(self):
"""Play wind sound and set up next gust."""
prepare.SFX["wind"].play()
task = Task(self.wind_gust, randint(15000, 45000))
self.animations.add(task)
def add_turkeys(self):
"""Spawn turkeys."""
turkeys = pg.sprite.Group()
w, h = prepare.WORLD_SIZE
for _ in range(35):
pos = randint(20, w - 20), randint(20, h - 20)
Turkey(pos, turkeys, self.all_sprites)
return turkeys
def make_trees(self):
"""Spawn trees."""
self.trees = pg.sprite.Group()
w, h = prepare.WORLD_SIZE
for _ in range(120):
while True:
pos = (randint(50, w - 20), randint(20, h - 20))
tree = Tree(pos)
collisions = (tree.collider.colliderect(other.collider)
for other in self.colliders)
if not any(collisions) and not tree.collider.colliderect(self.hunter.collider):
break
self.trees.add(tree)
self.colliders.add(tree)
self.all_sprites.add(tree)
def add_flock(self):
"""Add a Flock of birds."""
flock = Flock((self.hunter.collider.centerx, -1500), self.animations,
self.all_sprites, self.flocks)
next_flock = randint(45000, 150000) #next flock in 45-150 seconds
task = Task(self.add_flock, next_flock)
self.animations.add(task)
def add_roast(self, position):
roast = Roast(position, self.roasts, self.all_sprites)
task = Task(roast.kill, self.roast_live_time)
self.animations.add(task)
return roast
def update(self, dt):
self.animations.update(dt)
keys = pg.key.get_pressed()
self.hunter.update(dt, keys, self.bullets, self.turkeys,
self.colliders, self.all_sprites, self.animations)
self.turkeys.update(dt, self.trees)
self.bullets.update(dt)
for sprite in self.all_sprites:
self.all_sprites.change_layer(sprite, sprite.collider.bottom)
view_rect = self.all_sprites._map_layer.view_rect
for bullet in self.bullets:
if not bullet.rect.colliderect(view_rect):
bullet.kill()
tree_hits = pg.sprite.groupcollide(self.bullets, self.trees, True,
False, footprint_collide)
for bullet in tree_hits:
for tree in tree_hits[bullet]:
choice(self.rustle_sounds).play()
num = randint(3, 9)
for spot_info in sample(leaf_spots[tree.trunk], num):
self.add_leaf(tree, spot_info)
turkey_hits = pg.sprite.groupcollide(self.bullets, self.turkeys,
True, True, footprint_collide)
for t_bullet in turkey_hits:
for turkey in turkey_hits[t_bullet]:
self.add_roast(turkey.pos)
if self.hunter.shells < self.hunter.max_shells:
if self.hunter.collider.colliderect(self.ammo_crate.rect.inflate(16, 16)):
prepare.SFX["gunload"].play()
self.hunter.shells = self.hunter.max_shells
if self.hunter.state == "move":
self.scare_turkeys()
self.noise_detector.update(dt)
self.shell_label.set_text("{}".format(self.hunter.shells))
self.roasts_label.set_text("{}".format(self.hunter.roasts))
roast_collisions = pg.sprite.spritecollide(self.hunter, self.roasts,
True, footprint_collide)
if roast_collisions:
prepare.SFX["knifesharpener"].play()
self.hunter.roasts += len(roast_collisions)
self.flocks.update(self.hunter)
def scare_turkeys(self):
"""Make turkeys flee depending on distance and the player's noise level."""
size = self.noise_detector.noise_level
scare_rect = self.hunter.collider.inflate(size, size)
scared_turkeys = (t for t in self.turkeys
if t.collider.colliderect(scare_rect) and t.state.name != "flee")
for scared in scared_turkeys:
scared.flee(self.hunter)
def add_leaf(self, tree, spot_info):
"""Add a falling leaf."""
fall_time = randint(2000, 2500)
leaf = Leaf(tree, spot_info, self.leaves, self.all_sprites)
y = leaf.rect.centery + leaf.fall_distance
ani = Animation(centery=y, duration=fall_time, round_values=True)
ani.callback = leaf.land
ani.start(leaf.rect)
ani2 = Animation(centery=leaf.collider.centery + leaf.fall_distance,
duration=fall_time, round_values=True)
ani2.start(leaf.collider)
fade = Animation(img_alpha=0, duration=3000, delay=fall_time,
round_values=True)
fade.callback = leaf.kill
fade.update_callback = leaf.set_alpha
fade.start(leaf)
self.animations.add(ani, ani2, fade)
def draw(self, surface):
self.all_sprites.center(self.hunter.pos)
self.all_sprites.draw(surface)
self.shell_label.draw(surface)
self.roasts_label.draw(surface)
self.ui.draw(surface)
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 = 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 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 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 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 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()
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
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])
