def setup(self):
self.player_list = arcade.SpriteList()
self.coin_list = arcade.SpriteList()
self.wall_list = arcade.SpriteList()
self.score = 0
self.player_sprite = arcade.Sprite("sprites/maincharacter/1 Woodcutter/Woodcutter.png", SPRITE_SCALING_PLAYER)
self.player_sprite.center_x = 64
self.player_sprite.center_y = 270
self.player_list.append(self.player_sprite)
platforms_layer_name = 'Platforms'
coins_layer_name = 'Coins'
map_name = 'map.tmx'
my_map = arcade.read_tiled_map(map_name, SPRITE_SCALING)
map_array = arcade.read_tiled_map(map_name, SPRITE_SCALING)
self.end_of_map = len(map_array[0] * GRID_PIXEL_SIZE)
self.wall_list = arcade.generate_sprites(my_map, platforms_layer_name, SPRITE_SCALING)
self.coin_list = arcade.generate_sprites(my_map, coins_layer_name, SPRITE_SCALING)
if my_map.backgroundcolor:
arcade.set_background_color(my_map.backgroundcolor)
##Set up walls
# for x in range(173, 650, 64):
# wall = arcade.Sprite("sprites/items/PNG/Tileset.png", SPRITE_SCALING)
# wall.center_x = x
# wall.center_y = 200
# self.wall_list.append(wall)
# for y in range(273, 500, 64):
# wall = arcade.Sprite("sprites/items/PNG/Tileset.png", SPRITE_SCALING)
# wall.center_x = x
# wall.center_y = 200
# self.wall_list.append(wall)
self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite, self.wall_list, gravity_constant=GRAVITY)
for i in range(COIN_COUNT):
coin = arcade.Sprite("sprites/items/PNG/shiny/1.png", SPRITE_SCALING_COIN)
coin.center_x = random.randrange(SCREEN_WIDTH)
coin.center_y = random.randrange(SCREEN_HEIGHT)
self.coin_list.append(coin)
self.view_left = 0
self.view_bottom = 0
self.game_over = False
def read_map(self, level):
platforms_layer_name = "Platforms"
map_name = f"map2_level_{level}.tmx"
my_map = arcade.read_tiled_map(map_name, TILE_SCALING)
map_array = my_map.layers_int_data[platforms_layer_name]
self.end_of_map = (len(map_array[0]) - 1) * GRID_PIXEL_SIZE
return my_map
def setup(self):
""" Set up the game and initialize the variables. """
# Sprite lists
self.all_sprites_list = arcade.SpriteList()
self.wall_list = arcade.SpriteList()
self.floor_list = arcade.SpriteList()
self.wood_list = arcade.SpriteList()
self.objects_list = arcade.SpriteList()
self.second_list = arcade.SpriteList()
# Set up the player
self.score = 0
self.player_sprite = arcade.Sprite("../images/character.png", 0.4)
self.player_sprite.center_x = 0
self.player_sprite.center_y = 0
self.all_sprites_list.append(self.player_sprite)
self.my_map = arcade.read_tiled_map(
'../Tiled/tiledTemplate_isometric.tmx')
read_sprite_list(self.my_map.layers["Floor"], self.floor_list)
# read_sprite_list(self.my_map.layers["Walls"], self.wall_list)
# read_sprite_list(self.my_map.layers["Wood"], self.wood_list)
# read_sprite_list(self.my_map.layers["Objects"], self.objects_list)
# read_sprite_list(self.my_map.layers["Second"], self.second_list)
# Set the background color
arcade.set_background_color(self.my_map.backgroundcolor)
# Set the viewport boundaries
# These numbers set where we have 'scrolled' to.
self.view_left = 0
self.view_bottom = 0
def load_level(self, level):
# Read in the tiled map
my_map = arcade.read_tiled_map(f"level_{level}.tmx", SPRITE_SCALING)
# --- Walls ---
# Grab the layer of items we can't move through
map_array = my_map.layers_int_data['Platforms']
# Calculate the right edge of the my_map in pixels
self.end_of_map = (len(map_array[0]) - 1) * GRID_PIXEL_SIZE
self.wall_list = arcade.generate_sprites(my_map, 'Platforms', SPRITE_SCALING)
self.physics_engine = arcade.PhysicsEnginePlatformer(self.player_sprite,
self.wall_list,
gravity_constant=GRAVITY)
# --- Other stuff
# Set the background color
if my_map.backgroundcolor:
arcade.set_background_color(my_map.backgroundcolor)
# Set the view port boundaries
# These numbers set where we have 'scrolled' to.
self.view_left = 0
self.view_bottom = 0
def setup(self):
""" Set up the game and initialize the variables. """
# Sprite lists
self.all_sprites_list = arcade.SpriteList()
self.platform_list = arcade.SpriteList()
self.plant_list = arcade.SpriteList()
self.water_background_list = arcade.SpriteList()
self.objects_list = arcade.SpriteList()
self.second_list = arcade.SpriteList()
# Set up the player
self.score = 0
self.player_sprite = arcade.Sprite("../images/character.png", 0.4)
self.player_sprite.center_x = 64
self.player_sprite.center_y = 270
self.all_sprites_list.append(self.player_sprite)
self.my_map = arcade.read_tiled_map('../Tiled/nauticalMap.tmx')
read_sprite_list(self.my_map.layers["plants"], self.plant_list)
read_sprite_list(self.my_map.layers["platforms"], self.platform_list)
read_sprite_list(self.my_map.layers["water_background"],
self.water_background_list)
# Set the background color
arcade.set_background_color(self.my_map.backgroundcolor)
# Set the viewport boundaries
# These numbers set where we have 'scrolled' to.
self.view_left = 0
self.view_bottom = 0
def load_level(self, level):
#nastavení barev pozadí pro jednotlivé levely
if self.level == 1:
arcade.set_background_color(arcade.csscolor.POWDER_BLUE)
elif self.level == 2:
arcade.set_background_color((0, 65, 106))
elif self.level == 3:
arcade.set_background_color((27, 27, 27))
#přidání mapy .tmx
my_map = arcade.read_tiled_map("levels\\level_" + str(level) + ".tmx", 1)
self.ground_list = arcade.generate_sprites(my_map, "ground", 1)
#nastavení gravitace a bariér na přidanou mapu
self.physics_engine = arcade.PhysicsEnginePlatformer(self.player, self.ground_list, gravity_constant=GRAVITATION)
#přidání odměn
self.coin = arcade.generate_sprites(my_map, "coins", 1)
#přidání domu
self.house = arcade.generate_sprites(my_map, "house", 1)
#přidání vody
self.water = arcade.generate_sprites(my_map, "water", 1)
#přidání soupeřů
self.rival = arcade.generate_sprites(my_map, "rival", 1)
#přidání dalších prvků
self.stars = arcade.generate_sprites(my_map, "other", 1)
self.view_bottom = 0
self.view_left = 0
def setup(self):
""" Set up the game and initialize the variables. """
# Sprite lists
self.player_list = arcade.SpriteList()
self.wall_list = arcade.SpriteList()
self.floor_list = arcade.SpriteList()
self.objects_list = arcade.SpriteList()
self.my_map = arcade.read_tiled_map('dungeon.tmx')
# Set up the player
self.player_sprite = arcade.Sprite("images/character.png", 0.4)
px, py = arcade.isometric_grid_to_screen(
self.my_map.width // 2, self.my_map.height // 2, self.my_map.width,
self.my_map.height, self.my_map.tilewidth, self.my_map.tileheight)
self.player_sprite.center_x = px * SPRITE_SCALING
self.player_sprite.center_y = py * SPRITE_SCALING
self.player_list.append(self.player_sprite)
read_sprite_list(self.my_map.layers["Floor"], self.floor_list)
read_sprite_list(self.my_map.layers["Walls"], self.wall_list)
read_sprite_list(self.my_map.layers["Furniture"], self.wall_list)
# Set the background color
if self.my_map.backgroundcolor is None:
arcade.set_background_color(arcade.color.BLACK)
else:
arcade.set_background_color(self.my_map.backgroundcolor)
# Set the viewport boundaries
# These numbers set where we have 'scrolled' to.
self.view_left = 0
self.view_bottom = 0
def setup(self):
self.player_list = arcade.SpriteList()
self.wall_list = arcade.SpriteList()
self.floor_list = arcade.SpriteList()
self.objects_list = arcade.SpriteList()
self.my_map = arcade.read_tiled_map('dungeon.tmx')
# Set up the player
self.player_sprite = arcade.Sprite("images/character.png", 0.4)
px, py = arcade.isometric_grid_to_screen(
self.my_map.width // 2, self.my_map.height // 2, self.my_map.width,
self.my_map.height, self.my_map.tilewidth, self.my_map.tileheight)
self.player_sprite.center_x = px * SPRITE_SCALING
self.player_sprite.center_y = py * SPRITE_SCALING
self.player_list.append(self.player_sprite)
read_sprite_list(self.my_map.layers["Floor"], self.floor_list)
# read_sprite_list(self.my_map.layers["Walls"], self.wall_list)
read_sprite_list(self.my_map.layers["Furniture"], self.wall_list)
# Set the background color
if self.my_map.backgroundcolor is None:
arcade.set_background_color(arcade.color.BLACK)
else:
arcade.set_background_color(self.my_map.backgroundcolor)
self.view_left = 0
self.view_bottom = 0
def setup(self):
""" Set up the game here. Call this function to restart the game. """
# Used to keep track of our scrolling
self.view_bottom = 0
self.view_left = 0
# Keep track of the score
self.score = 0
# Create the Sprite lists
self.player_list = arcade.SpriteList()
self.wall_list = arcade.SpriteList()
self.coin_list = arcade.SpriteList()
# Set up the player, specifically placing it at these coordinates.
self.player_sprite = arcade.Sprite("images/player_1/player_stand.png",
CHARACTER_SCALING)
self.player_sprite.center_x = 64
self.player_sprite.center_y = 96
self.player_list.append(self.player_sprite)
# --- Load in a map from the tiled editor ---
# Name of map file to load
map_name = "map.tmx"
# Name of the layer in the file that has our platforms/walls
platforms_layer_name = 'Platforms'
# Name of the layer that has items for pick-up
coins_layer_name = 'Coins'
# Read in the tiled map
my_map = arcade.read_tiled_map(map_name, TILE_SCALING)
# -- Walls
# Grab the layer of items we can't move through
map_array = my_map.layers_int_data[platforms_layer_name]
# Calculate the right edge of the my_map in pixels
self.end_of_map = len(map_array[0]) * GRID_PIXEL_SIZE
# -- Platforms
self.wall_list = arcade.generate_sprites(my_map, platforms_layer_name,
TILE_SCALING)
# -- Coins
self.coin_list = arcade.generate_sprites(my_map, coins_layer_name,
TILE_SCALING)
# --- Other stuff
# Set the background color
if my_map.backgroundcolor:
arcade.set_background_color(my_map.backgroundcolor)
# Create the 'physics engine'
self.physics_engine = arcade.PhysicsEnginePlatformer(
self.player_sprite, self.wall_list, GRAVITY)
def load_level(self):
"""Loads the next or previous chunk of data,
then re-initializes the platformer engine."""
self.my_map = arcade.read_tiled_map(
f'./Maps/level_{self.level:0>8}.tmx', 1)
self.wall_list = arcade.generate_sprites(self.my_map, 'Platforms', 1)
self.physics_engine = arcade.PhysicsEnginePlatformer(
self.player_sprite, self.wall_list, gravity_constant=GRAVITY)
self.physics_engine.enable_multi_jump(1)
def setup(self):
""" Set up the game and initialize the variables. """
# Sprite lists
self.player_list = arcade.SpriteList()
self.coin_list = arcade.SpriteList()
# Set up the player
self.player_sprite = arcade.Sprite("images/character.png",
SPRITE_SCALING)
# Starting position of the player
self.player_sprite.center_x = 64
self.player_sprite.center_y = 270
self.player_list.append(self.player_sprite)
platforms_layer_name = 'Platforms'
coins_layer_name = 'Coins'
map_name = "map.tmx"
# Read in the tiled map
# noinspection PyDeprecation
my_map = arcade.read_tiled_map(map_name, SPRITE_SCALING)
# --- Walls ---
# Grab the layer of items we can't move through
map_array = my_map.layers_int_data[platforms_layer_name]
# Calculate the right edge of the my_map in pixels
self.end_of_map = len(map_array[0]) * GRID_PIXEL_SIZE
# --- Platforms ---
self.wall_list = arcade.generate_sprites(my_map, platforms_layer_name,
SPRITE_SCALING)
# --- Coins ---
self.coin_list = arcade.generate_sprites(my_map, coins_layer_name,
SPRITE_SCALING)
# --- Other stuff
# Set the background color
if my_map.backgroundcolor:
arcade.set_background_color(my_map.backgroundcolor)
# Keep player from running through the wall_list layer
self.physics_engine = arcade.PhysicsEnginePlatformer(
self.player_sprite, self.wall_list, gravity_constant=GRAVITY)
# Set the view port boundaries
# These numbers set where we have 'scrolled' to.
self.view_left = 0
self.view_bottom = 0
self.game_over = False
def setup(self):
my_map = arcade.read_tiled_map("maps/my-map1.tmx", 1)
self.ground_list = arcade.generate_sprites(my_map, "ground", 1)
self.coins_list = arcade.generate_sprites(my_map, "coins", 1)
self.player_list = arcade.SpriteList()
self.player_sprite = arcade.Sprite("images/character.png", 1)
self.player_sprite.center_x = 640
self.player_sprite.center_y = 350
self.player_list.append(self.player_sprite)
self.physics_engine = arcade.PhysicsEnginePlatformer(self.player_sprite, self.ground_list, gravity_constant=GRAVITY)
def setup(self):
self.mapa = arcade.read_tiled_map("mapa/parque.tmx",1)
self.ground_list= arcade.generate_sprites(self.mapa,"Capa de patrones 1",2)
self.sprite1= arcade.Sprite("personaje/personaje.png",2)
self.disparos= arcade.SpriteList()
#self.enemigos= arcade.tilemap.process_layer(self.mapa,"enemigo_amarillo")
#for enemigo in self.enemigos:
# enemigo.change_x= 2
#Fisicasa
self.physics_engine = arcade.PhysicsEnginePlatformer(self.sprite1, self.ground_list, gravity_constant=GRAVEDAD)
self.sprite1.set_position(self.player_x, self.player_y)
def setup(self):
#Read the arcade documentation!
self.wall_list = arcade.SpriteList()
self.player_list = arcade.SpriteList()
self.bullet_list = arcade.SpriteList()
self.player = arcade.AnimatedWalkingSprite()
#AnimatedWalkingSprite needs four lists
self.player.stand_right_textures = []
self.player.stand_right_textures.append(
arcade.load_texture("Walk0.png"))
self.player.stand_left_textures = []
self.player.stand_left_textures.append(
arcade.load_texture("Walk0.png", mirrored=True))
self.player.walk_right_textures = []
self.player.walk_right_textures.append(
arcade.load_texture("Walk0.png"))
self.player.walk_right_textures.append(
arcade.load_texture("Walk1.png"))
self.player.walk_right_textures.append(
arcade.load_texture("Walk2.png"))
self.player.walk_right_textures.append(
arcade.load_texture("Walk3.png"))
self.player.walk_left_textures = []
self.player.walk_left_textures.append(
arcade.load_texture("Walk0.png", mirrored=True))
self.player.walk_left_textures.append(
arcade.load_texture("Walk1.png", mirrored=True))
self.player.walk_left_textures.append(
arcade.load_texture("Walk2.png", mirrored=True))
self.player.walk_left_textures.append(
arcade.load_texture("Walk3.png", mirrored=True))
#Needs to be placed carefully, where there aren't any objects. Otherwise physics engine will raise an exception
self.player.center_x = 70
self.player.center_y = 150
self.player_list.append(self.player)
#Create a .tmx file using the TILED software
my_map = arcade.read_tiled_map("Environment.tmx", 0.5)
self.ground_list = arcade.generate_sprites(my_map, "ground", 0.5)
self.physics_engine = arcade.PhysicsEnginePlatformer(
self.player, self.ground_list, gravity_constant=GRAVITY)
self.environment_list = arcade.generate_sprites(my_map, "envir", 0.5)
def load_level(self, level):
# Read in the tiled map lebel
my_map = arcade.read_tiled_map(f"level_{level}.tmx", TILE_SCALING)
# Name of the layer in the file that has our platforms/walls
platforms_layer_name = 'Platforms'
# Name of the layer that has items for pick-up
coins_layer_name = 'Coins'
# Name of the layer that has enemies
#(doesn;t really have enemies, just clears previous level's enemies from memory)
enemies_layer_name = 'Enemies'
# -- Walls
# Grab the layer of items we can't move through
map_array = my_map.layers_int_data[platforms_layer_name]
# Calculate the right edge of the my_map in pixels
self.end_of_map = len(map_array[0]) * GRID_PIXEL_SIZE
# -- Platforms
self.wall_list = arcade.generate_sprites(my_map, platforms_layer_name,
TILE_SCALING)
# -- Coins
self.coin_list = arcade.generate_sprites(my_map, coins_layer_name,
TILE_SCALING)
# -- Enemies
# Clear previous level enemies
self.enemy_list = arcade.generate_sprites(my_map, enemies_layer_name,
TILE_SCALING)
for i in self.enemy_list:
#This sets every single enemy's movement to 2
i.change_x = 2
# --- Other stuff
# Set the background color
if my_map.backgroundcolor:
arcade.set_background_color(my_map.backgroundcolor)
# Create the 'physics engine'
self.physics_engine = arcade.PhysicsEnginePlatformer(
self.player_sprite, self.wall_list, GRAVITY)
# Used to keep track of our scrolling
self.view_bottom = 0
self.view_left = 0
def setup(self):
""" Set up the game and initialize the variables. """
# Sprite lists
self.player_list = arcade.SpriteList(use_lights=True)
self.wall_list = arcade.SpriteList(use_lights=True)
self.coin_list = arcade.SpriteList(use_lights=True)
# Set up the player
self.player_sprite = arcade.Sprite("images/character.png",
SPRITE_SCALING)
# Starting position of the player
self.player_sprite.center_x = 64
self.player_sprite.center_y = 270
self.player_list.append(self.player_sprite)
# Read in the tiled map
map = arcade.read_tiled_map("map_with_custom_hitboxes.tmx")
# --- Walls ---
# Grab the layer of items we can't move through
map_array = map.layers_int_data['Obstructions']
# Calculate the right edge of the map in pixels
self.end_of_map = len(map_array[0]) * GRID_PIXEL_SIZE
self.generate_sprites(map, 'Obstructions', self.wall_list,
SPRITE_SCALING)
self.physics_engine = \
arcade.PhysicsEnginePlatformer(self.player_sprite,
self.wall_list,
gravity_constant=GRAVITY)
# --- Coins ---
self.generate_sprites(map, 'Coins', self.coin_list, SPRITE_SCALING)
# --- Other stuff
# Set the background color
if map.backgroundcolor:
arcade.set_background_color(map.backgroundcolor)
# Set the view port boundaries
# These numbers set where we have 'scrolled' to.
self.view_left = 0
self.view_bottom = 0
self.game_over = False
def setup(self): """Runs once on startup""" # create a list of tiles self.tile_list = a.SpriteList() self.score = 0 # self.zoom_levels = [1, 2, 3] # self.zoom = zoom_levels[2] # import the map map_name = "/Users/nitrox/Code/civ/assets/world.tmx" tile_layer_name = "Tile Layer 1" my_map = a.read_tiled_map(map_name, tile_scale) map_array = my_map.layers_int_data[tile_layer_name] self.end_of_map = len(map_array[0]) * grid_size - grid_size self.tile_list = a.generate_sprites(my_map, tile_layer_name, tile_scale)
def setup(self):
my_map = arcade.read_tiled_map("maps/my-map1.tmx", 1)
self.ground_list = arcade.generate_sprites(my_map, "ground", 1)
self.bones_list = arcade.generate_sprites(my_map, "bones", 1)
self.streettop_list = arcade.generate_sprites(my_map, "streettop", 1)
self.background = arcade.load_texture("images/sky.png")
self.player_list = arcade.SpriteList()
self.enemy_list = arcade.SpriteList()
self.enemy2_list = arcade.SpriteList()
self.enemy3_list = arcade.SpriteList()
self.enemy4_list = arcade.SpriteList()
# Set up player
self.player = PlayerCharacter()
self.player.center_x = 300
self.player.center_y = 500
self.player.scale = 1
self.player_list.append(self.player)
# Set up enemy
self.enemy = Motorcycle()
self.enemy.center_x = 3000
self.enemy.center_y = 260
self.enemy.scale = .5
self.enemy_list.append(self.enemy)
# Set up enemy 2
self.enemy2 = Motorcycle2()
self.enemy2.center_x = 5500
self.enemy2.center_y = 260
self.enemy2.scale = .5
self.enemy2_list.append(self.enemy2)
# Set up enemy 3
self.enemy3 = Motorcycle()
self.enemy3.center_x = 7500
self.enemy3.center_y = 260
self.enemy3.scale = .5
self.enemy3_list.append(self.enemy3)
# Set up enemy 4
self.enemy4 = Motorcycle2()
self.enemy4.center_x = 9500
self.enemy4.center_y = 260
self.enemy4.scale = .5
self.enemy4_list.append(self.enemy4)
self.physics_engine = arcade.PhysicsEnginePlatformer(self.player, self.ground_list, gravity_constant=GRAVITY)
self.enemy_physics_engine = arcade.PhysicsEnginePlatformer(self.enemy, self.ground_list, gravity_constant=GRAVITY)
self.enemy2_physics_engine = arcade.PhysicsEnginePlatformer(self.enemy2, self.ground_list, gravity_constant=GRAVITY)
self.enemy3_physics_engine = arcade.PhysicsEnginePlatformer(self.enemy3, self.ground_list, gravity_constant=GRAVITY)
self.enemy4_physics_engine = arcade.PhysicsEnginePlatformer(self.enemy4, self.ground_list, gravity_constant=GRAVITY)
self.player.change_x = MOVEMENT_SPEED
def setup(self):
""" Set up the game here. Call this function to restart the game. """
# --- Load in a map from the tiled editor ---
# Name of map file to load
map_name = "IsoMap.tmx"
# Name of the base layer
base_layer_name = 'Base Map'
road_layer_name = 'Roads'
tree_layer_name = 'Trees'
building_layer_name = 'Buildings'
self.base_list = arcade.SpriteList()
self.roads_list = arcade.SpriteList()
self.trees_list = arcade.SpriteList()
self.buildings_list = arcade.SpriteList()
# Read in the tiled map
# my_map = arcade.tilemap.read_tmx(map_name)
self.my_map = arcade.read_tiled_map(map_name, SPRITE_SCALING)
read_sprite_list(self.my_map.layers[road_layer_name], self.roads_list)
read_sprite_list(self.my_map.layers[tree_layer_name], self.roads_list)
read_sprite_list(self.my_map.layers[building_layer_name],
self.roads_list)
# --- Other stuff
# Set the background color
if self.my_map.backgroundcolor:
arcade.set_background_color(self.my_map.backgroundcolor)
# if self.my_map.backgroundcolor is None:
# arcade.set_background_color(arcade.color.BLACK)
arcade.set_viewport(75, 1685, 35, 885)
def setup(self, level):
# Reset Game Instance Variables
self.level = 1
self.score = 0
self.view_bottom = 0
self.view_left = 0
self.end_of_map = 0
# Create the Game Element lists
self.player_list = arcade.SpriteList()
self.coin_list = arcade.SpriteList()
self.wall_list = arcade.SpriteList()
self.foreground_list = arcade.SpriteList()
self.background_list = arcade.SpriteList()
# Set up the player, specifically placing it at the starting location
self.player_sprite = arcade.Sprite("images/player_1/player_stand.png",
CHARACTER_SCALING)
self.player_sprite.center_x = PLAYER_START_X
self.player_sprite.center_y = PLAYER_START_Y
self.player_list.append(self.player_sprite)
##########################
### LOAD CREATED MAP ###
##########################
# Name of the layer in the map file that has our platforms/walls
platforms_layer_name = 'Platforms'
# Name of the layer that has items for pick-up
coins_layer_name = 'Coins'
# Name of the layer that has items for foreground
foreground_layer_name = 'Foreground'
# Name of the layer that has items for background
background_layer_name = 'Background'
# Name of the layer that has items we shouldn't touch
dont_touch_layer_name = "Don't Touch"
# Map name
if self.level == 2:
map_name = f"map2_level_{level}.tmx"
else:
map_name = f"map.tmx"
# Read in the tiled map
my_map = arcade.read_tiled_map(map_name, TILE_SCALING)
# Walls
map_array = my_map.layers_int_data[platforms_layer_name]
# Foreground
self.foreground_list = arcade.generate_sprites(my_map,
foreground_layer_name,
TILE_SCALING)
# Background
self.background_list = arcade.generate_sprites(my_map,
background_layer_name,
TILE_SCALING)
# Platforms
self.wall_list = arcade.generate_sprites(my_map, platforms_layer_name,
TILE_SCALING)
# Coins
self.coin_list = arcade.generate_sprites(my_map, coins_layer_name,
TILE_SCALING)
# Don't Touch Layer
self.dont_touch_list = arcade.generate_sprites(my_map,
dont_touch_layer_name,
TILE_SCALING)
# Set the right boundry of map
self.end_of_map = (len(map_array[0]) - 1) * GRID_PIXEL_SIZE
# Set the background color
if my_map.backgroundcolor:
arcade.set_background_color(my_map.backgroundcolor)
# Create the 'physics engine'
self.physics_engine = arcade.PhysicsEnginePlatformer(
self.player_sprite, self.wall_list, GRAVITY)
def setup(self, level):
""" Set up the game here. Call this function to restart the game. """
self.winner = arcade.load_texture("images/winner.png")
self.gameover = arcade.load_texture("images/game_over.png")
self.background = arcade.load_texture("images/fondo1.png")
# Used to keep track of our scrolling
self.view_bottom = 0
self.view_left = 0
# Keep track of the score
self.score = 0
self.vida = 3
# Create the Sprite lists
self.player_list = arcade.SpriteList()
self.enemy_list = arcade.SpriteList()
self.foreground_list = arcade.SpriteList()
self.background_list = arcade.SpriteList()
self.wall_list = arcade.SpriteList()
self.coin_list = arcade.SpriteList()
#Creamos el jugador
self.player_sprite = arcade.AnimatedWalkingSprite()
self.player_sprite.stand_right_textures = []
self.player_sprite.stand_right_textures.append(
arcade.load_texture("images/player_1/protagonista1.png",
scale=CHARACTER_SCALING))
self.player_sprite.stand_left_textures = []
self.player_sprite.stand_left_textures.append(
arcade.load_texture("images/player_1/protagonista1.png",
scale=CHARACTER_SCALING,
mirrored=True))
self.player_sprite.walk_right_textures = []
self.player_sprite.walk_right_textures.append(
arcade.load_texture("images/player_1/protagonista3.png",
scale=CHARACTER_SCALING))
self.player_sprite.walk_right_textures.append(
arcade.load_texture("images/player_1/protagonista4.png",
scale=CHARACTER_SCALING))
#self.player_sprite.walk_right_textures.append(arcade.load_texture("images/player_1/protagonista3.png",
# scale=CHARACTER_SCALING))
#self.player_sprite.walk_right_textures.append(arcade.load_texture("images/player_1/protagonista4.png",
# scale=CHARACTER_SCALING))
self.player_sprite.walk_left_textures = []
#self.player_sprite.walk_left_textures.append(arcade.load_texture("images/player_1/protagonista1.png",
# scale=CHARACTER_SCALING, mirrored=True))
#self.player_sprite.walk_left_textures.append(arcade.load_texture("images/player_1/protagonista2.png",
# scale=CHARACTER_SCALING, mirrored=True))
self.player_sprite.walk_left_textures.append(
arcade.load_texture("images/player_1/protagonista3.png",
scale=CHARACTER_SCALING,
mirrored=True))
self.player_sprite.walk_left_textures.append(
arcade.load_texture("images/player_1/protagonista4.png",
scale=CHARACTER_SCALING,
mirrored=True))
self.player_sprite.walk_up_textures = []
self.player_sprite.walk_up_textures.append(
arcade.load_texture("images/player_1/protagonista5.png",
scale=CHARACTER_SCALING,
mirrored=True))
self.player_sprite.texture_change_distance = 20
# Set up the player, specifically placing it at these coordinates.
#self.player_sprite = arcade.Sprite("images/player_1/protagonista1.png", CHARACTER_SCALING)
self.player_sprite.center_x = PLAYER_START_X
self.player_sprite.center_y = PLAYER_START_Y
self.player_list.append(self.player_sprite)
# ---- Draw an enemy on the groud ---- #
# Creamos el jugador
self.enemy_sprite = arcade.AnimatedWalkingSprite()
self.enemy_sprite.stand_right_textures = []
self.enemy_sprite.stand_right_textures.append(
arcade.load_texture("images/enemies/pasti1.png",
scale=CHARACTER_SCALING,
mirrored=True))
self.enemy_sprite.stand_left_textures = []
self.enemy_sprite.stand_left_textures.append(
arcade.load_texture("images/enemies/pasti1.png",
scale=CHARACTER_SCALING))
self.enemy_sprite.walk_right_textures = []
self.enemy_sprite.walk_right_textures.append(
arcade.load_texture("images/enemies/pasti1.png",
scale=CHARACTER_SCALING,
mirrored=True))
self.enemy_sprite.walk_right_textures.append(
arcade.load_texture("images/enemies/pasti2.png",
scale=CHARACTER_SCALING,
mirrored=True))
self.enemy_sprite.walk_left_textures = []
self.enemy_sprite.walk_left_textures.append(
arcade.load_texture("images/enemies/pasti1.png",
scale=CHARACTER_SCALING))
self.enemy_sprite.walk_left_textures.append(
arcade.load_texture("images/enemies/pasti2.png",
scale=CHARACTER_SCALING))
self.enemy_sprite.texture_change_distance = 20
if self.level == 1:
# Posicion inicial del enemigo
self.enemy_sprite.center_x = PLAYER_START_X + 250
self.enemy_sprite.center_y = PLAYER_START_Y + 100
# Limite del enemigo
self.enemy_sprite.change_x = 2
self.enemy_sprite.boundary_left = 150
self.enemy_sprite.boundary_right = 400
self.enemy_list.append(self.enemy_sprite)
# --- Load in a map from the tiled editor ---
# Name of the layer in the file that has our platforms/walls
platforms_layer_name = 'plataforma'
# Name of the layer that has items for pick-up
coins_layer_name = 'monedas'
# Name of the layer that has items for foreground
foreground_layer_name = 'frente'
# Name of the layer that has items for background
background_layer_name = 'fondo'
# Name of the layer that has items we shouldn't touch
dont_touch_layer_name = "no tocar"
self.vida -= 1
# Map name
if level == -1:
map_name = 'game over.tmx'
map_name = f"nivel_{self.level}.tmx"
# Read in the tiled map
my_map = arcade.read_tiled_map(map_name, TILE_SCALING)
# -- Walls
# Grab the layer of items we can't move through
map_array = my_map.layers_int_data[platforms_layer_name]
# Calculate the right edge of the my_map in pixels
self.end_of_map = len(map_array[0]) * GRID_PIXEL_SIZE
# -- Background
self.background_list = arcade.generate_sprites(my_map,
background_layer_name,
TILE_SCALING)
# -- Foreground
self.foreground_list = arcade.generate_sprites(my_map,
foreground_layer_name,
TILE_SCALING)
# -- Platforms
self.wall_list = arcade.generate_sprites(my_map, platforms_layer_name,
TILE_SCALING)
# -- Platforms
self.wall_list = arcade.generate_sprites(my_map, platforms_layer_name,
TILE_SCALING)
# -- Coins
self.coin_list = arcade.generate_sprites(my_map, coins_layer_name,
TILE_SCALING)
# -- Don't Touch Layer
self.dont_touch_list = arcade.generate_sprites(my_map,
dont_touch_layer_name,
TILE_SCALING)
self.end_of_map = (len(map_array[0]) - 1) * GRID_PIXEL_SIZE
# --- Other stuff
# Set the background color
if my_map.backgroundcolor:
arcade.set_background_color(my_map.backgroundcolor)
# Create the 'physics engine'
self.physics_engine = arcade.PhysicsEnginePlatformer(
self.player_sprite, self.wall_list, GRAVITY)
self.physics__enemy_engine = arcade.PhysicsEnginePlatformer(
self.enemy_sprite, self.wall_list, GRAVITY)
def setup(self, level):
""" Set up the game here. Call this function to restart the game. """
# Used to keep track of our scrolling
self.view_bottom = 0
self.view_left = 0
# Keep track of the score
self.score = 0
self.signs = 0
self.text = ""
# Create the Sprite lists
self.player_list = arcade.SpriteList()
self.foreground_list = arcade.SpriteList()
self.background_list = arcade.SpriteList()
self.wall_list = arcade.SpriteList()
self.coin_list = arcade.SpriteList()
self.traffic_signs_list = arcade.SpriteList()
# Set up the player, specifically placing it at these coordinates.
self.player_sprite = arcade.Sprite("images/alien/alienBlue_walk1.png",
CHARACTER_SCALING)
self.player_sprite.center_x = PLAYER_START_X
self.player_sprite.center_y = PLAYER_START_Y
self.player_list.append(self.player_sprite)
# --- Load in a map from the tiled editor ---
# Name of the layer in the file that has our platforms/walls
platforms_layer_name = 'Platforms'
# Name of the layer that has items for pick-up
coins_layer_name = 'Coins'
# Name of the layer that has items for foreground
foreground_layer_name = 'Foreground'
# Name of the layer that has items for background
background_layer_name = 'Background'
# Name of the layer that has items we shouldn't touch
dont_touch_layer_name = "Don't Touch"
traffic_signs_layer_name = 'traffic signs'
# Map name
map_name = f"map2_level_{level}.tmx"
# Read in the tiled map
my_map = arcade.read_tiled_map(map_name, TILE_SCALING)
# -- Walls
# Grab the layer of items we can't move through
map_array = my_map.layers_int_data[platforms_layer_name]
# Calculate the right edge of the my_map in pixels
self.end_of_map = len(map_array[0]) * GRID_PIXEL_SIZE
# -- Background
self.background_list = arcade.generate_sprites(my_map,
background_layer_name,
TILE_SCALING)
# -- Foreground
self.foreground_list = arcade.generate_sprites(my_map,
foreground_layer_name,
TILE_SCALING)
# -- Platforms
self.wall_list = arcade.generate_sprites(my_map, platforms_layer_name,
TILE_SCALING)
# -- Platforms
self.traffic_signs_list = arcade.generate_sprites(
my_map, traffic_signs_layer_name, TILE_SCALING)
# -- Coins
self.coin_list = arcade.generate_sprites(my_map, coins_layer_name,
TILE_SCALING)
# -- Don't Touch Layer
self.dont_touch_list = arcade.generate_sprites(my_map,
dont_touch_layer_name,
TILE_SCALING)
self.end_of_map = (len(map_array[0]) - 1) * GRID_PIXEL_SIZE
# --- Other stuff
# Set the background color
if my_map.backgroundcolor:
arcade.set_background_color(my_map.backgroundcolor)
# Create the 'physics engine'
self.physics_engine = arcade.PhysicsEnginePlatformer(
self.player_sprite, self.wall_list, GRAVITY)
def setup(self):
""" Set up the game and initialize the variables. """
# Sprite lists
self.player_list = arcade.SpriteList()
self.decorations_list = arcade.SpriteList()
self.champagne_list = arcade.SpriteList()
self.text_list = arcade.SpriteList()
self.background_list = arcade.SpriteList()
self.cloud_sprite_list = arcade.SpriteList()
self.champagne_sprite_list = arcade.SpriteList()
# Set up the players
self.char_list = [
arcade.Sprite("res/philip.png", SPRITE_SCALING),
arcade.Sprite("res/heleen.png", SPRITE_SCALING),
arcade.Sprite("res/alexandra.png", SPRITE_SCALING),
arcade.Sprite("res/bart.png", SPRITE_SCALING),
arcade.Sprite("res/jessica.png", SPRITE_SCALING),
]
# Create the clouds
for i in range(CLOUD_COUNT):
# Create the cloud instance
cloud = Cloud("res/cloud.png", SPRITE_SCALING)
doublecloud = Cloud("res/doublecloud.png", SPRITE_SCALING)
# Position the cloud
cloud.center_x = random.randrange(-200, 2200)
cloud.center_y = random.randrange(SCREEN_HEIGHT - 50,
SCREEN_HEIGHT + 300)
doublecloud.center_x = random.randrange(-200, 2200)
doublecloud.center_y = random.randrange(SCREEN_HEIGHT - 50,
SCREEN_HEIGHT + 300)
# Add the cloud to the lists
self.cloud_sprite_list.append(cloud)
self.cloud_sprite_list.append(doublecloud)
# Create the Champagne
champagne = Champagne("res/champagne-closed.png", SPRITE_SCALING)
# Position the champagne bottle
champagne.center_x = 1728
champagne.bottom = 864
# Add the champagne bottle to the lists
self.champagne_sprite_list.append(champagne)
# Read in the tiled map
my_map = arcade.read_tiled_map('mount.tmx', SPRITE_SCALING)
# --- Background ---
self.background_list = arcade.generate_sprites(my_map, 'Background',
SPRITE_SCALING)
# --- Decorations ---
self.decorations_list = arcade.generate_sprites(
my_map, 'Decorations', SPRITE_SCALING)
# --- Platforms ---
self.wall_list = arcade.generate_sprites(my_map, 'Platforms',
SPRITE_SCALING)
# --- Text ---
self.text_list = arcade.generate_sprites(my_map, 'Text',
SPRITE_SCALING)
# --- Champagne ---
self.champagne_list = arcade.generate_sprites(my_map, 'Champagne',
SPRITE_SCALING)
# --- Set the background color
if my_map.backgroundcolor:
arcade.set_background_color(my_map.backgroundcolor)
# --- Players ---
# --- Choose Player and save position of current player
global CURRENT_PLAYER
self.choose_player(CURRENT_PLAYER, CHOSEN_PLAYER)
CURRENT_PLAYER = CHOSEN_PLAYER # Update current player
# --- Starting position of the players
i = 0
for char in self.char_list:
char.center_x = POSITION_DATA.at[i, 'x']
char.bottom = POSITION_DATA.at[i, 'y']
self.player_list.append(char)
i += 1
# Keep player from running through the wall_list layer
self.physics_engine = arcade.PhysicsEnginePlatformer(
self.player_sprite, self.wall_list, gravity_constant=GRAVITY)
import arcade
import config
from arcade.tiled import read_tiled_map
class MyTestWindow(arcade.Window):
def __init__(self, width, height, title):
super().__init__(width, height, title)
self.map = arcade.generate_sprites(my_map, "Tile Layer 1", 1,
"./assets/")
def on_draw(self):
arcade.start_render()
self.map.draw()
MAP_NAME = 'assets/tiled_test_4.tmx'
my_map = arcade.read_tiled_map(config.MAP_NAME, 1)
for row in my_map.layers["Tile Layer 1"]:
for grid_object in row:
print(grid_object)
print(
f"{grid_object.tile.local_id}, {grid_object.center_x}, {grid_object.center_y}"
)
test = MyTestWindow(640, 800, "meme")
test.test()
test.close()
def setup(self):
""" Fill out the things we initialized """
# Sprite list
self.wall_list = arcade.SpriteList()
self.bullet_list = arcade.SpriteList()
self.player_list = arcade.SpriteList()
self.target_list = arcade.SpriteList()
self.speed_power_up_list = arcade.SpriteList()
self.health_power_up_list = arcade.SpriteList()
self.bullet_upgrade_list = arcade.SpriteList()
self.fuel_power_up_list = arcade.SpriteList()
map = arcade.read_tiled_map("map2.tmx")
self.wall_list = arcade.generate_sprites(
map,
"wall_layer",
1,
)
self.target_list = arcade.generate_sprites(map, "target_layer", 1)
# Loads in the background
# self.background = arcade.load_texture("Grass.jpg")
# Set up the player sprites
self.player_sprite = Player(
"topdowntanks\\PNG\\Tanks\\tankGreen_outline.png", TANK_SCALING)
self.player_sprite.center_x = 400
self.player_sprite.center_y = 300
# Setting up the barrel sprite
self.barrel_sprite = arcade.Sprite(
"topdowntanks\\PNG\\Tanks\\barrelGreenExtended.png")
self.barrel_sprite.position = self.player_sprite.position
# Setting up the sprite
self.speed_sprite = arcade.Sprite(
"shooting-gallery-pack\\PNG\\Objects\\shot_blue_large.png")
self.speed_sprite.center_x = 600
self.speed_sprite.center_y = 100
self.health_sprite = arcade.Sprite(
"shooting-gallery-pack\\PNG\\Objects\\shot_yellow_large.png")
self.health_sprite.center_x = 200
self.health_sprite.center_y = 100
self.bullet_upgrade_sprite = arcade.Sprite(
"topdowntanks\\PNG\\Bullets\\bulletRed_outline.png")
self.bullet_upgrade_sprite.center_x = 400
self.bullet_upgrade_sprite.center_y = 100
self.fuel_sprite = arcade.Sprite(
"shooting-gallery-pack\\PNG\\Objects\\target_red2.png")
self.fuel_sprite.center_x = 400
self.fuel_sprite.center_y = 600
x_start = 100
for _ in range(7):
duck = arcade.Sprite(
"shooting-gallery-pack\\PNG\\Objects\\duck_target_yellow.png",
TARGET_SCALING)
duck.center_x = x_start
duck.center_y = 400
self.target_list.append(duck)
x_start += 100
# Create rows of boxes
"""for x in range(5):
wall = arcade.Sprite("shooting-gallery-pack\\PNG\\Stall\\bg_wood.png", TARGET_SCALING)
wall.center_x = x * 125
wall.center_y = 500
self.wall_list.append(wall)
# Create collum of boxes
for y in range(3):
wall = arcade.Sprite("shooting-gallery-pack\\PNG\\Stall\\bg_wood.png", TARGET_SCALING)
wall.center_x = 500
wall.center_y = y * 125
self.wall_list.append(wall)"""
# Physics collision engine
self.physics_engine = arcade.PhysicsEngineSimple(
self.player_sprite, self.wall_list)
self.player_list.append(self.player_sprite)
self.player_list.append(self.barrel_sprite)
self.speed_power_up_list.append(self.speed_sprite)
self.health_power_up_list.append(self.health_sprite)
self.bullet_upgrade_list.append(self.bullet_upgrade_sprite)
self.fuel_power_up_list.append(self.fuel_sprite)
arcade.set_background_color(arcade.color.BLACK)
def game_setup(self, level): # 게임 화면 초기화(init) #초기값 설정
""" Set up the game here. Call this function to restart the game. """
# Used to keep track of our scrolling
self.view_bottom = 0
self.view_left = 0
#몬스터 리셋
for i in range(len(self.monster)):
del self.monster[0]
del self.monster_sprite[0]
del self.monster_physics_engine[0]
#움직이는 플랫폼 리셋
for i in range(len(self.platform)):
del self.platform[0]
del self.platform_sprite[0]
del self.platform_physics_engine[0]
# Create the Sprite lists
self.player_list = arcade.SpriteList()
self.button_list = arcade.SpriteList()
self.foreground_list = arcade.SpriteList()
self.background_list = arcade.SpriteList()
self.wall_list = arcade.SpriteList()
self.coin_list = arcade.SpriteList()
self.monster_list = arcade.SpriteList()
self.platform_list = arcade.SpriteList()
self.ladder_list = None # 사다리 리스트
level_list = {
1: self.map_level_1,
2: self.map_level_2,
3: self.map_level_3,
4: self.map_level_4,
5: self.map_level_5,
6: self.map_level_6,
}
#레벨함수 호출 (레벨마다의 설정)
level_list[self.level]()
#라이프가 초기화 되지 않게
if self.bool_life == True:
self.life = 10
self.bool_life = False
#캐릭터
self.player_sprite = PlayerCharacter()
self.player_sprite.center_x = PLAYER_START_X
self.player_sprite.center_y = PLAYER_START_Y
self.player_list.append(self.player_sprite)
# --- Load in a map from the tiled editor ---
# Name of the layer in the file that has our platforms/walls
platforms_layer_name = 'Platforms'
# Name of the layer that has items for pick-up
coins_layer_name = 'Coins'
# Name of the layer that has items for foreground
foreground_layer_name = 'Foreground'
# Name of the layer that has items for background
background_layer_name = 'Background'
# Name of the layer that has items we shouldn't touch
dont_touch_layer_name = "Don't Touch"
#사다리 레이어
ladders_layer_name = "Ladders"
#맵 이름
map_name = f"map2_level_{level}.tmx"
# Read in the tiled map
my_map = arcade.read_tiled_map(map_name, TILE_SCALING)
# -- Walls
# Grab the layer of items we can't move through
map_array = my_map.layers_int_data[platforms_layer_name]
#맵에서 오른 쪽 끝자리를 계산 (다음 맵으로)
self.end_of_map = len(map_array[0]) * GRID_PIXEL_SIZE - 120
# -- Background(my_map, "background", 0.5)
self.background_list = arcade.generate_sprites(my_map,
background_layer_name,
TILE_SCALING)
# -- Foreground
self.foreground_list = arcade.generate_sprites(my_map,
foreground_layer_name,
TILE_SCALING)
# -- Platforms
self.wall_list = arcade.generate_sprites(my_map, platforms_layer_name,
TILE_SCALING)
# -- Coins
self.coin_list = arcade.generate_sprites(my_map, coins_layer_name,
TILE_SCALING)
# -- Don't Touch Layer
#여기서 맵.tmx파일이랑 연동?
self.dont_touch_list = arcade.generate_sprites(my_map,
dont_touch_layer_name,
TILE_SCALING)
# --- Other stuff
# Set the background color
if my_map.backgroundcolor:
arcade.set_background_color(my_map.backgroundcolor)
# #사다리가 있는 4번 맵
# #플레이어의 움직임
self.ladder_list = arcade.generate_sprites(my_map, ladders_layer_name,
TILE_SCALING)
self.player_physics_engine = arcade.PhysicsEnginePlatformer(
self.player_sprite,
self.wall_list,
gravity_constant=GRAVITY,
ladders=self.ladder_list)
print(self.player_physics_engine)
#몬스터들은 중력에 영향이 없음
for i in range(len(self.monster)):
self.monster_physics_engine.append(
arcade.PhysicsEnginePlatformer(self.monster_sprite[i],
self.wall_list, 0))
#플랫폼들은 중력에 영향이 없음(wall_list랑은 다름)
for i in range(len(self.platform)):
self.platform_physics_engine.append(
arcade.PhysicsEnginePlatformer(self.platform_sprite[i],
self.wall_list, 0))
def setup(self):
""" Set up the game and initialize the variables. """
# Sprite lists
# do not use is_static=True for animated sprites
self.player_list = arcade.SpriteList()
self.npc_list = arcade.SpriteList()
self.wall_list = arcade.SpriteList(is_static=True)
self.platform_list = arcade.SpriteList(is_static=True)
self.background_list = arcade.SpriteList(is_static=True)
self.coin_list = arcade.SpriteList()
self.ice_list = arcade.SpriteList()
self.laser_list = arcade.SpriteList()
# Set up the player
self.score = 0
self.player = arcade.AnimatedWalkingSprite()
character_scale = .5
self.player.stand_right_textures = []
self.player.stand_right_textures.append(
arcade.load_texture("images/rock_stand_right.png",
scale=character_scale))
self.player.stand_left_textures = []
self.player.stand_left_textures.append(
arcade.load_texture("images/rock_stand_left.png",
scale=character_scale))
self.player.walk_right_textures = []
self.player.walk_right_textures.append(
arcade.load_texture("images/rock_walk_right_001.png",
scale=character_scale))
self.player.walk_right_textures.append(
arcade.load_texture("images/rock_walk_right_002.png",
scale=character_scale))
self.player.walk_right_textures.append(
arcade.load_texture("images/rock_walk_right_003.png",
scale=character_scale))
self.player.walk_right_textures.append(
arcade.load_texture("images/rock_walk_right_004.png",
scale=character_scale))
self.player.walk_right_textures.append(
arcade.load_texture("images/rock_walk_right_005.png",
scale=character_scale))
self.player.walk_right_textures.append(
arcade.load_texture("images/rock_walk_right_006.png",
scale=character_scale))
self.player.walk_right_textures.append(
arcade.load_texture("images/rock_walk_right_007.png",
scale=character_scale))
self.player.walk_right_textures.append(
arcade.load_texture("images/rock_walk_right_008.png",
scale=character_scale))
self.player.walk_right_textures.append(
arcade.load_texture("images/rock_walk_right_009.png",
scale=character_scale))
self.player.walk_left_textures = []
self.player.walk_left_textures.append(
arcade.load_texture("images/rock_walk_left_001.png",
scale=character_scale))
self.player.walk_left_textures.append(
arcade.load_texture("images/rock_walk_left_002.png",
scale=character_scale))
self.player.walk_left_textures.append(
arcade.load_texture("images/rock_walk_left_003.png",
scale=character_scale))
self.player.walk_left_textures.append(
arcade.load_texture("images/rock_walk_left_004.png",
scale=character_scale))
self.player.walk_left_textures.append(
arcade.load_texture("images/rock_walk_left_005.png",
scale=character_scale))
self.player.walk_left_textures.append(
arcade.load_texture("images/rock_walk_left_006.png",
scale=character_scale))
self.player.walk_left_textures.append(
arcade.load_texture("images/rock_walk_left_007.png",
scale=character_scale))
self.player.walk_left_textures.append(
arcade.load_texture("images/rock_walk_left_008.png",
scale=character_scale))
self.player.walk_left_textures.append(
arcade.load_texture("images/rock_walk_left_009.png",
scale=character_scale))
self.player.texture_change_distance = 20
# Read in the tiled map
map_name = "NLA-testLvL5.tmx"
self.my_map = arcade.read_tiled_map(map_name, SPRITE_SCALING)
# Grab the layer of items we can't move through
map_array = self.my_map.layers_int_data["Walls"]
# Calculate the right edge of the my_map in pixels
self.end_of_map = len(map_array[0]) * GRID_PIXEL_SIZE
self.player.boundary_left = 128
self.player.boundary_right = self.end_of_map - 128
# Starting position of the player
self.player.center_x = 384
self.player.center_y = 768
self.player.scale = 0.5
self.player_list.append(self.player)
# --- Background ---
read_sprite_list(self.my_map.layers["Background"],
self.background_list)
# --- Walls ---
read_sprite_list(self.my_map.layers["Walls"], self.wall_list)
# --- Platforms ---
read_sprite_list(self.my_map.layers["Platforms"], self.platform_list)
# --- Static NPC's ---
read_sprite_list(self.my_map.layers["NPC"], self.npc_list)
# --- Ice ---
read_sprite_list(self.my_map.layers["Ice"], self.ice_list)
# --- Coins ---
read_sprite_list(self.my_map.layers["Coins"], self.coin_list)
for coin in self.coin_list:
coin.angle = 0
coin.change_angle = 5
# --- Other stuff
# Set the background color
if self.my_map.backgroundcolor:
arcade.set_background_color(self.my_map.backgroundcolor)
# Set the image to be used for the texture of the menu/map overlay
self.menu_mask = arcade.load_texture("images/background_mask3.png")
# Set the image to be used for the texture of the menu/map overlay
self.paused_mask = arcade.load_texture("images/paused_mask.png")
# Apply gravity/ physics to sprites
self.physics_engine = arcade.PhysicsEnginePlatformer(
self.player, self.platform_list, gravity_constant=GRAVITY)
# Set the view port boundaries
# These numbers set where we have 'scrolled' to.
self.view_left = 0
self.view_bottom = 0
self.game_over = False
# Background sounds (MUSIC)
self.music_player = pyglet.media.Player()
self.level_music = pyglet.media.load("sounds/music.wav")
self.pause_menu_music = pyglet.media.load("sounds/paused.wav")
self.game_over_music = pyglet.media.load("sounds/gameover1.wav")
# Game sounds (SFX)
self.collect_coin_sound = arcade.load_sound("sounds/coin1.wav")
self.jump_sound = arcade.load_sound("sounds/jump1.wav")
self.wall_hit_sound = arcade.load_sound("sounds/hit4.wav")
self.ice_hit_sound = arcade.load_sound("sounds/hit2.wav")
self.gun_sound = arcade.sound.load_sound("sounds/laser1.wav")
