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,
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):
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/")
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):
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 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 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, 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 __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, 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,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, *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):
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 __init__(self):
super(TitleScreen, self).__init__()
pg.mixer.init()
song = MUSIC['bg']
pg.mixer.music.load(song)
pg.mixer.music.set_volume(0.1)
pg.mixer.music.play()
tmx_data = load_pygame(MAP['title0'])
map_data = pyscroll.data.TiledMapData(tmx_data)
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.letters = pg.sprite.Group()
imgs0 = [GFX["letter_{}".format(letter)] for letter in "UPSIDE"]
delays0 = [x * 250 for x in (1, 2, 3, 4, 5, 6)]
w, h = imgs0[0].get_size()
space = 10
left0 = 70
top0 = SCREEN_RECT.centery - 90
timespan = 1500
for img, delay in zip(imgs0, delays0):
icon = Icon(img, (left0, -100), False, self.letters)
left0 += w + space
ani = Animation(top=top0,
duration=timespan,
delay=delay,
transition="out_bounce",
round_values=True)
ani.start(icon.rect)
self.animations.add(ani)
imgs1 = [GFX["letter_{}".format(letter)] for letter in "DOWN"]
delays1 = [x * 250 for x in (3, 4, 5, 6)]
space = 10
left1 = 280
top1 = SCREEN_RECT.centery
for img, delay in zip(imgs1, delays1):
icon = Icon(img, (left1, 580), True, self.letters)
left1 += w + space
ani = Animation(top=top1,
duration=timespan,
delay=delay,
transition="out_bounce",
round_values=True)
ani.start(icon.rect)
self.animations.add(ani)
midbottom = (SCREEN_RECT.centerx, SCREEN_RECT.bottom - 120)
font = FONTS["UbuntuMono-B"]
self.prompt = Blinker("Press any key to continue",
{"midbottom": midbottom},
500,
text_color=(255, 255, 255),
font_path=font,
font_size=30)
task = Task(self.labels.add,
max(delays1) + timespan,
args=(self.prompt, ))
self.animations.add(task)
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 __init__(self):
# true while running
self.currentAnim = CurrentAnim.RIGHT
# load data from pytmx
tmx_data = load_pygame(self.filename)
# setup level geometry with simple pygame rects, loaded from pytmx
self.walls = list()
for object in tmx_data.objects:
self.walls.append(
pygame.Rect(object.x, object.y, object.width, object.height))
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(tmx_data)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data,
screen.get_size(),
clamp_camera=False,
tall_sprites=0)
self.map_layer.zoom = 1.8
# pyscroll supports layered rendering. our map has 3 'under' layers
# layers begin with 0, so the layers are 0, 1, and 2.
# since we want the sprite to be on top of layer 1, we set the default
# layer for sprites as 2
self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=1)
self.doorPosX = 157
self.doorPosY = 208
self.offset = 0
for j in range(2):
for i in range(39):
doors.append(Door(self.doorPosX, self.doorPosY))
self.doorPosY += 113 - self.offset
self.offset += 0.06
self.doorPosX = 270
self.offset = 0
self.doorPosY = 208
self.doorPosX = 457
self.doorPosY = 208
self.offset = 0
for j in range(2):
for i in range(39):
doors.append(Door(self.doorPosX, self.doorPosY))
self.doorPosY += 113 - self.offset
self.offset += 0.06
self.doorPosX = 588
self.offset = 0
self.doorPosY = 208
self.elevatorInitX = 350
self.elevatorInitY = 200
for i in range(20):
elevator.append(
Elevator(ElevatorImage, self.elevatorInitX,
self.elevatorInitY))
self.elevatorInitY += 250
for i in elevator:
self.group.add(i)
self.playerCharacter = Character(PlayerWalkAnimList[0])
#self.playerCharacter._position = self.map_layer.map_rect.center
self.playerCharacter._positionX += 300
self.playerCharacter._positionY += 20
self.group.add(self.playerCharacter)
#Variables
self.animDelay = 50
self.JumpTimer = 1700
self.FireDelay = 2000
self.lastUpdate = 0
self.SpawnlastUpdate = 0
self.JumplastUpdate = 0
self.AttacklastUpdate = 0
self.ScoreIncreaseTimer = 0
self.playerVel = [0, 0]
self.velX = 0
self.velY = 0
self.jumpVel = 0.5
self.Gravity = 0
self.bIsJumping = False
self.bCanJump = True
self.WalkAnimIndex = 0
self.CrouchAnimIndex = 0
self.AttackAnimIndex = 0
self.bIsWalking = False
self.bCollided = False
self.bCanMoveRight = True
self.bCanMoveLeft = True
self.bIsFiring = False
self.bHasFired = False
self.bCanFire = True
self.bAddEnemy = False
self.facing = 1
self.PlayeBulletOffset = 0
self.bCanSpawnEnemy = True
self.WalkSoundTimer = 0
pygame.display.set_caption("Elevator action")
self.clock = pygame.time.Clock()
self.score = 0
self.health = 10
self.bHealthCheck = True
self.bGameOver = False
self.bLevelPassed = False
def __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 __init__(self,
charactername='Zaxim',
username='******',
password='******',
ip='127.0.0.1',
current_room=None):
# Client for issuing requests to server and receiving responses
self.client = GameClient(charactername=charactername,
username=username,
password=password,
ip=ip)
# Remote sprite controller
self.rsc = RemoteSpriteController(self)
# Rate that chat polls are sent to server
self.poll_frequency = POLL_RATE
self.poll_timer = self.poll_frequency
self.out_going_message = None
# true while running
self.running = False
# load data from pytmx
if not current_room:
current_room = STARTING_ROOM
tmx_data = load_pygame(current_room)
self.map_data = tmx_data
# create new data source for pyscroll
map_data = pyscroll.data.TiledMapData(tmx_data)
# create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(map_data, screen.get_size())
self.map_layer.zoom = MAP_ZOOM
# pyscroll supports layered rendering.
self.group = PyscrollGroup(map_layer=self.map_layer,
default_layer=DEFAULT_LAYER)
# GUI ELEMENTS
# Create text box
text_box_x, text_box_y = self.screen_coords((3, 95))
self.text_box = eztext.Input(maxlength=90,
color=(255, 255, 255),
x=text_box_x,
y=text_box_y,
font=pygame.font.Font(FONT, 22),
prompt=': ')
# Create InputLog
self.inputlog = InputLog(coords=self.screen_coords((3, 88)),
max_length=10,
size=18,
spacing=18,
font=FONT)
# Create Combatlog
self.combatlog = InputLog(coords=(1050, 860),
max_length=10,
size=22,
spacing=18,
font=FONT)
# Login to server:
# Get room instance and player object id
response = self.client.login()
id = response['response']['id']
sprite = response['response']['sprite']
coords = response['response']['coords']
self.hero = Hero(game=self, id=id, sprite=sprite, coords=coords)
# Player input module
self.input = PlayerController(game=self)
# This is late -- ??? TODO This is garbage, current room needs to be discovered way earlier from login()
self.current_room = response['response']['current_room']
self.hero.position = STARTING_POSITION
self.group.add(self.hero.remotesprite)
self.rsc.initialize()
def __init__(self, filename, game_loop, **kwargs):
self.map_filename = filename
self.map_path = os.path.join(resources.TMX_FOLDER, filename)
self.name = kwargs.get("name", os.path.splitext(filename)[0])
LOG.debug("Initializing level with map %s", self.map_path)
self.game_loop = game_loop
self.battles_allowed = kwargs.get("battles_allowed", False)
self.exclude_players = kwargs.get("exclude_players", False)
self.music = kwargs.get("music", None)
self.keydown_only = False
self.keydown_orig = self.keydown_only # Stash for flipping back to
self.current_dialog = []
self.poster_image = None
self.velocity = 2 # Default movement velocity
LOG.debug("Populating image cache...")
self.image_cache = []
for image in kwargs.get("images", []):
# If there is no location data tuple, just blit to the middle
if isinstance(image, str):
img = get_image(image)
self.image_cache.append((img, None, None))
else:
# Assuming a data tuple of path, x, y
img_path, x, y = image
img = get_image(img_path)
self.image_cache.append((img, x, y))
LOG.debug("Collecting TMX data...")
# Collect tmx_data and a surface
self.map_data = TiledMapData(self.tmx_data)
self.map_layer = BufferedRenderer(
self.map_data,
self.game_screen.get_size(),
clamp_camera=False,
background_color=self.map_data.background_color,
alpha=True,
)
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.scroll_group = PyscrollGroup(map_layer=self.map_layer,
default_layer=10)
if self.player1:
self.scroll_group.add(self.player1)
objects = self.custom_objects
for s_npc in objects["static_npcs"]:
if s_npc.image:
try:
self.scroll_group.add(s_npc)
except Exception:
LOG.exception("Cannot add static npc")
for npc in objects["npcs"]:
if npc.image:
try:
self.scroll_group.add(npc)
except Exception:
LOG.exception("Cannot add npc")
self.game_screen.fill((0, 0, 0))
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))
