def main(self, screen):
clock = pygame.time.Clock()
self.jump = pygame.mixer.Sound('jump.wav')
self.shoot = pygame.mixer.Sound('shoot.wav')
self.explosion = pygame.mixer.Sound('explosion.wav')
self.tilemap = tmx.load('map.tmx', screen.get_size())
self.sprites = tmx.SpriteLayer()
start_cell = self.tilemap.layers['triggers'].find('player')[0]
self.player = Player((start_cell.px, start_cell.py), self.sprites)
self.tilemap.layers.append(self.sprites)
self.enemies = tmx.SpriteLayer()
for enemy in self.tilemap.layers['triggers'].find('enemy'):
Enemy((enemy.px, enemy.py), self.enemies)
self.tilemap.layers.append(self.enemies)
while True:
dt = clock.tick(30)
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
return
self.tilemap.update(dt / 1000., self)
screen.fill((200, 200, 200))
# screen.blit(background, (0, 0))
self.tilemap.draw(screen)
pygame.display.flip()
if self.player.is_dead:
print "YOU DIED"
return
def main(self, screen):
clock = pygame.time.Clock()
self.background = pygame.sprite.Group()
Background(self.background)
self.sounds = {}
for sound in ['jump', 'land', 'shoot']:
self.sounds[sound] = pygame.mixer.Sound('sounds/' + sound + '.wav')
self.tilemap = tmx.load('map.tmx', screen.get_size())
start_cell = self.tilemap.layers['triggers'].find('player')[0]
start_position = (start_cell.px, start_cell.py)
self.sprites = tmx.SpriteLayer()
self.player = Player(start_position, self.sprites)
self.tilemap.layers.append(self.sprites)
self.enemies = tmx.SpriteLayer()
for enemy in self.tilemap.layers['triggers'].find('enemy'):
Enemy((enemy.px, enemy.py), self.enemies)
self.tilemap.layers.append(self.enemies)
self.tilemap.set_focus(start_position[0], start_position[1])
while 1:
dt = clock.tick(30) / 1000.0
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
return
#screen.blit(background, (0, 0))
self.tilemap.update(dt, self)
self.tilemap.set_focus(
self.tilemap.fx + (self.player.rect.x - self.tilemap.fx) / 6.0,
self.tilemap.fy + (self.player.rect.y - self.tilemap.fy) / 6.0)
self.background.draw(screen)
self.tilemap.draw(screen)
pygame.display.flip()
if self.player.is_dead:
print 'YOU DIED'
return
def __init__(self, *, player_icon: pygame.Surface, **kwargs):
super().__init__(player_icon=player_icon, **kwargs)
self.sprites = tmx.SpriteLayer()
self.tilemap.layers.append(self.sprites)
start_cell = self.tilemap.layers['triggers'].find('player')[0]
self.player = Player(self.sprites, image=player_icon.convert(), location=(start_cell.px, start_cell.py), tilemap=self.tilemap)
self.tilemap.set_focus(start_cell.px, start_cell.py, force=True)
def main():
screen = init_screen()
tilemap = load_map(screen)
w = World(tilemap)
clock = pygame.time.Clock()
font = pygame.font.SysFont('Arial', 25)
sprite_layer = tmx.SpriteLayer()
sprite_layer.set_view(0, 0, *screen.get_size())
tilemap.layers.append(sprite_layer)
knight, zombie = init(w)
sprite_layer.add(knight, zombie)
knight.rect = knight.rect.move(300, 0)
while 1:
dt = clock.tick(30)
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
handle_knight_move(knight, event)
# handle_zombie_move(zombie, knight)
result = has_knight_won(zombie, knight)
if result is not None:
popup(screen, font, result)
time.sleep(1)
r = pygame.Rect(random.randint(0, 640), random.randint(0, 480),
zombie.rect.width, zombie.rect.height)
zombie.rect = r
# tilemap.update calls the update method on each layer in the map.
# The update method can be customized for each layer to include logic
# for animating sprite positions, and detecting collisions.
tilemap.update(dt)
# Fill the screen with an R,G,B color to erase the previous drawings.
screen.fill((0, 0, 0))
# Draw all layers of the tilemap to the screen.
tilemap.draw(screen)
# Refresh the display window.
pygame.display.flip()
def main():
screen = pygame.display.set_mode((800, 600))
map = tmx.load('driving-map.tmx', screen.get_size())
sprites = tmx.SpriteLayer()
map.layers.append(sprites)
car = CarSprite(sprites)
clock = pygame.time.Clock()
while True:
dt = clock.tick(30) / 1000.0
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
return
screen.fill((50,50,50))
map.update(dt)
map.set_focus(*car.rect.center)
map.draw(screen)
pygame.display.flip()
def main(self, screen):
clock = pygame.time.Clock()
players_name = 'mario'
dt = clock.tick(30)
self.tilemap = tmx.load('11.tmx', screen.get_size())
#self.tilemap = tmx.load('11.tmx', (360,240))
self.sprites = tmx.SpriteLayer()
start_cell = self.tilemap.layers['triggers'].find('player')[0]
self.player = Player((start_cell.px, start_cell.py), self.sprites)
self.tilemap.layers.append(self.sprites)
initial_blink_surface = self.tilemap.tilesets[4].surface.copy()
blink_level = 0
coin_blink = 0
self.player_lives = 3
self.player_coins = 0
self.player_score = 0
self.game_time = 400
self.game_world = 1
self.game_level = 1
self.enemy_list = []
for cell in self.tilemap.layers['enemies'].objects:
self.enemy_list.append(
Enemy((cell.px, cell.py), cell.properties, self.sprites))
font_size = 8
self.set_font_images(font_size)
self.css = spritesheet.spritesheet('coin_tileset.png')
coin_image_list = [
self.css.image_at((64, 0, 8, 8), colorkey=-1),
self.css.image_at((72, 0, 8, 8), colorkey=-1),
self.css.image_at((80, 0, 8, 8), colorkey=-1)
]
self.point_list = []
self.point_float = 40
self.bumpable_list = []
n = 0
while 1:
clock.tick(30)
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
return
################Blinking Question Blocks################
if n % 3 == 0:
if blink_level < 6:
if blink_level < 3:
blink_tile = 4 + blink_level
coin_blink = blink_level
elif blink_level == 3:
blink_tile = 5
coin_blink = 1
else:
blink_tile = 4
self.tilemap.tilesets[
4].surface = initial_blink_surface ##gotta do this for some reason
coin_blink = 0
for cell in self.tilemap.layers['changeables'].find(
'question_block'):
cell.tile.surface = self.tilemap.tilesets[
blink_tile].surface
blink_level += 1
else:
blink_level = 0
coin_blink = 0
########################################################
if n % 10 == 0 and not self.player.player_dead:
self.game_time -= 1
self.tilemap.update(dt / 1000., self)
screen.fill((92, 148, 252))
name_start_x = 8
score_start_x = name_start_x
time_title_start_x = 184
time_count_start_x = 192
lives_count_start_x = 88
world_title_start_x = 128
world_count_start_x = 144
for letter in players_name:
name_start_x += font_size
screen.blit(self.letter_image_dict[letter],
(name_start_x, font_size))
for number in str(self.player_score).zfill(6):
score_start_x += font_size
screen.blit(self.number_image_list[int(number)],
(score_start_x, font_size * 2))
for letter in 'time':
time_title_start_x += font_size
screen.blit(self.letter_image_dict[letter],
(time_title_start_x, font_size))
for number in str(self.game_time).zfill(3):
time_count_start_x += font_size
screen.blit(self.number_image_list[int(number)],
(time_count_start_x, font_size * 2))
screen.blit(coin_image_list[coin_blink], (80, 16))
screen.blit(self.letter_image_dict['by'],
(lives_count_start_x, 16))
for number in str(self.player_coins).zfill(2):
lives_count_start_x += font_size
screen.blit(self.number_image_list[int(number)],
(lives_count_start_x, font_size * 2))
for letter in 'world':
world_title_start_x += font_size
screen.blit(self.letter_image_dict[letter],
(world_title_start_x, font_size))
screen.blit(self.number_image_list[self.game_world],
(world_count_start_x, font_size * 2))
screen.blit(self.letter_image_dict['dash'],
(world_count_start_x + font_size, font_size * 2))
screen.blit(self.number_image_list[self.game_level],
(world_count_start_x + (font_size * 2), font_size * 2))
for point in self.point_list:
if point[2] < self.point_float:
n = 0
if point[1] == '1UP':
screen.blit(self.point_image_dict['1UP'],
(point[0][0] +
(n * 4), point[0][1] - point[2]))
n += 1
else:
for number in str(point[1]):
screen.blit(self.point_image_dict[int(number)],
(point[0][0] +
(n * 4), point[0][1] - point[2]))
n += 1
point[2] += 1
self.tilemap.draw(screen)
pygame.display.flip()
n += 1
def __init__(self, map_path, **kwargs):
"""
"""
super().__init__(
wait=False,
bg_image=resources.load_image("old-paper.jpg").convert(),
bg_size='cover',
layout_width=room.LayoutParams.FILL_PARENT,
layout_height=room.LayoutParams.FILL_PARENT,
**kwargs)
self.tilemap = tmx.load(map_path, self.rect.size, self.rect.topleft)
self.zoom = self.tilemap.zoom = 2
self.tw, self.th = (self.tilemap.tile_width, self.tilemap.tile_height)
self.w, self.h = self.tilemap.width, self.tilemap.height
self.terrains = {}
self.sprites = tmx.SpriteLayer()
yaml_units = utils.parse_yaml(resources.DATA_PATH / 'units.yml', unit)
yaml_weapons = utils.parse_yaml(resources.DATA_PATH / 'weapons.yml',
item)
teams = {}
for layer in self.tilemap.layers:
if isinstance(
layer,
tmx.ObjectLayer): # layer can be an ObjectLayer or a Layer
c = layer.color
layer.visible = False # don't draw squares
color = (int(c[1:3], base=16), int(c[3:5], base=16),
int(c[5:7], base=16)) # from '#RGB' to (R,G,B)
units = {}
for obj in layer.objects:
if obj.type == 'unit':
units[obj.name] = yaml_units[obj.name]
units[
obj.
name].coord = obj.px // self.tw, obj.py // self.th
weapon = obj.properties.get('weapon', None)
if weapon:
try:
units[obj.name].give_weapon(
yaml_weapons[weapon])
except KeyError:
logging.warning("Weapon %s not found", weapon)
relation = layer.properties['relation']
boss = yaml_units[layer.properties['boss']]
def get(key):
v = layer.properties.get(key, None)
return str(resources.MUSIC_PATH / v) if v else None
music = {
'map': get('map_music'),
'battle': get('battle_music')
}
if layer.properties.get('AI', None) is None:
teams[color] = unit.Team(layer.name, color, relation,
list(units.values()), boss, music)
else:
teams[color] = ai.AI(layer.name, color, relation,
list(units.values()), boss, music)
for layer in self.tilemap.layers:
if isinstance(layer, tmx.ObjectLayer):
for obj in layer.objects:
u = yaml_units[obj.name]
team = teams[u.team.color]
UnitSprite(self.tilemap, u, team, self.sprites)
self.units_manager = unit.UnitsManager(list(teams.values()))
for layer in reversed(self.tilemap.layers):
if isinstance(layer, tmx.Layer):
for cell in layer:
coord = cell.x, cell.y
units = self.units_manager.get_units(coord=coord)
_unit = units[0] if units else None
if coord not in self.terrains and cell.tile is not None:
self.terrains[coord] = Terrain(cell.tile, _unit)
cursor_layer = tmx.SpriteLayer()
self.cursor = Cursor(self.tilemap, resources.load_image('cursor.png'),
cursor_layer)
arrow_layer = tmx.SpriteLayer()
self.arrow = Arrow(self.tilemap, resources.load_image('arrow.png'),
arrow_layer)
highlight_layer = tmx.SpriteLayer()
self.highlight = CellHighlight(self.tilemap, highlight_layer)
self.tilemap.layers.append(highlight_layer)
self.tilemap.layers.append(self.sprites)
self.tilemap.layers.append(arrow_layer)
self.tilemap.layers.append(cursor_layer)
self.tilemap.set_focus(self.tilemap.view_w // 2,
self.tilemap.view_h // 2)
self.prev_sel: Union[None, Coord] = None
self.curr_sel: Union[None, Coord] = None
self.move_area: List[Coord] = []
self.attack_area: List[Coord] = []
# Scroll speed
self.vx, self.vy = 0, 0
self.path = Pathfinder(self)
self.return_path = None # stores the path to undo a move
def main(self, screen):
# define el reloj dentro del juego
clock = pygame.time.Clock()
# carga la imagen de fondo
background = Util.imagen("fondoJungla.png")
self.map_counter = 1
# carga los datos del mapa
self.tilemap = tmx.load("level" + str(self.map_counter) + ".tmx",
screen.get_size())
# carga los joysticks
self.joyst = False
joystick_count = pygame.joystick.get_count()
if joystick_count != 0:
self.joyst = True
pygame.joystick.Joystick(0).init()
# carga los datos de inicio del jugador
self.sprites = tmx.SpriteLayer()
start_cell = self.tilemap.layers["triggers"].find("player")[0]
self.player = Player((start_cell.px, start_cell.py), self.sprites)
self.tilemap.layers.append(self.sprites)
# carga los datos de inicio de los enemigos
self.enemies = tmx.SpriteLayer()
for enemy in self.tilemap.layers["triggers"].find("enemy"):
Enemy((enemy.px, enemy.py), self.enemies)
self.tilemap.layers.append(self.enemies)
# ciclo infinito del juego
while 1:
dt = clock.tick(30)
# verifica si el juego es quitado
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
return
# comienza a dibujar el mapa y a los personajes
self.tilemap.update(dt / 1000., self, screen)
screen.blit(background, (0, 0))
self.tilemap.draw(screen)
# muestra el numero de vidas del jugador
text(screen, "Lives: " + str(self.player.lifes), (255, 255, 0), 50,
20, 25)
# despliega la version del juego
text(screen, "alpha petunia 0.0.11", (0, 0, 0), 700, 580, 15)
pygame.display.flip()
self.player.changeY -= 3
# verifica si el jugador a llegado al final del nivel
if self.player.finish == True:
self.player.finish = False
self.map_counter += 1
self.tilemap = tmx.load(
"level" + str(self.map_counter) + ".tmx",
screen.get_size())
# carga los datos de inicio del jugador
self.sprites = tmx.SpriteLayer()
start_cell = self.tilemap.layers["triggers"].find("player")[0]
self.player = Player((start_cell.px, start_cell.py),
self.sprites)
self.tilemap.layers.append(self.sprites)
# carga los datos de inicio de los enemigos
self.enemies = tmx.SpriteLayer()
for enemy in self.tilemap.layers["triggers"].find("enemy"):
Enemy((enemy.px, enemy.py), self.enemies)
self.tilemap.layers.append(self.enemies)
# verifica si el jugador a perdido todas sus vidas
if self.player.lifes == 0:
text(screen, "YOU DIED", (0, 0, 0), (640 / 2), (180 / 2), 115)
pygame.display.update()
clock.tick(60)
return
