def __init__(self, version) -> None:
self.FPS = 60
self.version = version
self.state = STATES["playing"]
self.screen = pygame.display.set_mode((800, 600), locals.RESIZABLE)
pygame.display.set_caption("Le trésor de Klah")
pygame.font.init()
self.pixel_verdana = pygame.font.Font("assets/fonts/PixelFJVerdana12pt.ttf", 12)
self.last_action = "nothing here :)"
# charger la carte
self.tmx_data = pytmx.util_pygame.load_pygame("assets/maps/spawn.tmx")
self.map_data = pyscroll.data.TiledMapData(self.tmx_data)
self.map_layer = pyscroll.orthographic.BufferedRenderer(self.map_data, self.screen.get_size())
self.map_layer.zoom = 2
self.map = "spawn"
# générer un joueur
player_position = self.tmx_data.get_object_by_name("playerspawn")
self.player = player.Player(player_position.x, player_position.y)
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer, default_layer=2)
self.group.add(self.player)
# liste de collisions + items
self.walls = []
self.items = []
for obj in self.tmx_data.objects:
if obj.type == "collision":
self.walls.append(pygame.Rect(obj.x, obj.y, obj.width, obj.height))
if obj.name == "coin":
coin = item.Item(obj.x, obj.y, 'purse', loot={
'coin': random.randint(5, 10),
'emerald': 0 if random.randint(1, 10) != 1 else random.randint(1, 5),
'mushroom': 0 if random.randint(1, 5) != 1 else random.randint(0, 10),
'bone': 0 if random.randint(1, 20) != 1 else random.randint(0, 1),
'cheese': 0 if random.randint(1, 100) != 1 else random.randint(0, 1)
}
)
self.group.add(coin)
self.items.append(coin)
elif obj.name == "apple":
apple = item.Item(obj.x, obj.y, 'food/redapple', loot={'apple': 1})
self.group.add(apple)
self.items.append(apple)
elif obj.name == "dictionary":
dictionary = item.Item(obj.x, obj.y, 'books/book14', loot={'dictionary': 1})
self.group.add(dictionary)
self.items.append(dictionary)
elif obj.name == "map":
dictionary = item.Item(obj.x, obj.y, 'parchment2', loot={'map': 1})
self.group.add(dictionary)
self.items.append(dictionary)
elif obj.name == "rock":
rock = item.Item(obj.x, obj.y, 'rock', loot={'rock': 1})
self.group.add(rock)
self.items.append(rock)
def __init__(self, event_manager, world):
"""
:param event_manager: event Manager
:type event_manager: events.EventManager
:param world: game world
:type world: gameWorld.GameWorld
"""
self.world = world
self.event_manager = event_manager
self.event_manager.register_listener(self)
#Set game screen
self.screen = world.screen
w, h = world.screen.get_size()
#Create new renderer (camera)
self.map_layer = pyscroll.BufferedRenderer(self.world.level.map_data,
(w, h),
clamp_camera=False)
#The sprite should to be on top of layer named "decoration behind"
#Find layer number of the layer named "decoration behind"
self.render_layer = 0
for layer_index in range(len(self.world.level.tmx_data.layers)):
if self.world.level.tmx_data.layers[layer_index].name == "decoration behind":
self.render_layer = layer_index
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer,
default_layer=self.render_layer)
def setup(self):
pygame.init()
init_spritesheet()
from src.spritesheet import RougeSheet
self.screen_size = (960, 600)
self.screen = pygame.display.set_mode(self.screen_size)
pygame.display.set_caption("Scroller Game")
self.clock = pygame.time.Clock()
self.map_data = load_map("map4")
self.map = pyscroll.TiledMapData(self.map_data)
self.map_layer = pyscroll.BufferedRenderer(self.map, self.screen_size)
self.map_layer.zoom = 3
self.walls = create_walls(self.map_data)
self.player = basic_player(self, RougeSheet)
self.enemies = pygame.sprite.Group()
add_mobs(self, self.map_data)
self.all_sprites = pyscroll.PyscrollGroup(map_layer=self.map_layer)
self.all_sprites.add(self.player)
self.all_sprites.add(self.enemies)
self.all_sprites.center(self.player.rect.center)
def switch_world(self):
tmx_data = pytmx.util_pygame.load_pygame('carte.tmx')
map_data = pyscroll.data.TiledMapData(tmx_data)
map_layer = pyscroll.orthographic.BufferedRenderer(
map_data, self.screen.get_size())
map_layer.zoom = 2
# liste collision
self.walls = []
for obj in tmx_data.objects:
if obj.type == "collision":
self.walls.append(
pygame.Rect(obj.x, obj.y, obj.width, obj.height))
# dessiner le groupe de calques
self.group = pyscroll.PyscrollGroup(map_layer=map_layer,
default_layer=7)
self.group.add(self.player)
# enter_house system
enter_house = tmx_data.get_object_by_name('enter_house')
self.enter_house_rect = pygame.Rect(enter_house.x, enter_house.y,
enter_house.width,
enter_house.height)
#recup le point de spawn devant maison
spawn_house_point = tmx_data.get_object_by_name('enter_house_exit')
self.player.position[0] = spawn_house_point.x
self.player.position[1] = spawn_house_point.y + 5
def __init__(self, mapfile):
self._move_queue = []
self.running = False
self.last_position_update = 0
map = load_pygame(mapfile)
self.layer = map.layers[1]
map_data = pyscroll.data.TiledMapData(map)
w, h = screen.get_size()
self.map_layer = pyscroll.BufferedRenderer(map_data,
screen.get_size(),
clamp_camera=True)
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer,
default_layer=2)
self.map_layer.zoom = .5
self.player = Player(PLAYER_IMAGE)
self.player.position = self.map_layer.map_rect.center
self.group.add(self.player)
self.mesh = Pathfinder(map)
def __init__(self,
mapName="WorldMap",
nameInZone="StartPointWorld",
screenSize=(SCREEN_WIDTH, SCREEN_HEIGHT)):
super().__init__()
# Beginning MAP DATA
self.nameMap = mapName
# A set-up to shut down the logger 'orthographic' in pyscroll
logger = logging.getLogger('orthographic')
logger.setLevel(logging.ERROR)
self.tmxData = pytmx.util_pygame.load_pygame(
self.reqImageName(self.nameMap))
self.tiledMapData = pyscroll.data.TiledMapData(self.tmxData)
self.cameraPlayer = pyscroll.BufferedRenderer(self.tiledMapData,
screenSize,
clamp_camera=True)
self.camera = pyscroll.PyscrollGroup(map_layer=self.cameraPlayer,
default_layer=SPRITE_LAYER)
# Spawn point of the player
valBool = False
for obj in self.tmxData.objects:
if obj.name == "InZone":
if obj.StartPoint == nameInZone:
self.spawmPointPlayerx = obj.x
self.spawmPointPlayery = obj.y
def __init__(self):
#céation fenetre
self.screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("JeuPython")
#charger la carte
tmx_data = pytmx.util_pygame.load_pygame('carte.tmx')
map_data = pyscroll.data.TiledMapData(tmx_data)
map_layer = pyscroll.orthographic.BufferedRenderer(
map_data, self.screen.get_size())
map_layer.zoom = 2
#generer un joueur
player_position = tmx_data.get_object_by_name("player")
self.player = Player(player_position.x, player_position.y)
#liste collision
self.walls = []
for obj in tmx_data.objects:
if obj.type == "collision":
self.walls.append(
pygame.Rect(obj.x, obj.y, obj.width, obj.height))
#dessiner le groupe de calques
self.group = pyscroll.PyscrollGroup(map_layer=map_layer,
default_layer=7)
self.group.add(self.player)
#enter_house system
self.map = 'world'
enter_house = tmx_data.get_object_by_name('enter_house')
self.enter_house_rect = pygame.Rect(enter_house.x, enter_house.y,
enter_house.width,
enter_house.height)
def __init__(self, filename, renderer):
# Load TMX data
self.tmx_data = load_pysdl2(filename=filename, renderer=renderer)
# Make data source for the map
self.map_data = pyscroll.TiledMapData(self.tmx_data)
# Make the scrolling layer
screen_size = (400, 400)
map_layer = pyscroll.BufferedRenderer(self.map_data, screen_size)
# make the pygame SpriteGroup with a scrolling map
group = pyscroll.PyscrollGroup(map_layer=map_layer)
# Add sprites to the group
group.add(sprite)
# Center the layer and sprites on a sprite
group.center(sprite.rect.center)
# Draw the layer
# If the map covers the entire screen, do not clear the screen:
# Clearing the screen is not needed since the map will clear it when drawn
# This map covers the screen, so no clearing!
group.draw(screen)
# adjust the zoom (out)
map_layer.zoom = .5
# adjust the zoom (in)
map_layer.zoom = 2.0
def switch_world(self):
# chargement de la carte tmx
tmx_data = pytmx.util_pygame.load_pygame('carte.tmx')
map_data = pyscroll.data.TiledMapData(tmx_data)
map_layer = pyscroll.orthographic.BufferedRenderer(
map_data, self.screen.get_size())
map_layer.zoom = 2
# liste des collisions
self.walls = []
for object in tmx_data.objects:
if object.type == 'collision':
self.walls.append(
pygame.Rect(object.x, object.y, object.width,
object.height))
# dessin du groupe de calques
self.group = pyscroll.PyscrollGroup(map_layer=map_layer,
default_layer=5)
self.group.add(self.player)
# collision pour entrer dans la maison
enter_house = tmx_data.get_object_by_name('enter_house')
self.enter_house_rect = pygame.Rect(enter_house.x, enter_house.y,
enter_house.width,
enter_house.height)
# récupérer le point de spawn devant la maison
spawn_house_point = tmx_data.get_object_by_name('enter_house_exit')
self.player.position[0] = spawn_house_point.x
self.player.position[1] = spawn_house_point.y + 20
def __init__(self, event_manager, world):
"""
:param event_manager: event Manager
:type event_manager: events.EventManager
:param world: game world
:type world: gameWorld.GameWorld
"""
self.world = world
self.event_manager = event_manager
self.event_manager.register_listener(self)
self.screen = world.screen
w, h = world.screen.get_size()
#Create new renderer/camera
self.map_layer = pyscroll.BufferedRenderer(self.world.level.map_data,
(w, h),
clamp_camera=False,
colorkey=None,
alpha=True)
#The player, enemies, items etc. should to be on top of
#layer named in TMX "decoration behind"
#Find layer number of the layer named "decoration behind"
self.render_layer = 0
for layer_index in range(len(self.world.level.tmx_data.layers)):
if self.world.level.tmx_data.layers[layer_index].name == "walls":
self.render_layer = layer_index #content will be drawn on top of walls layer
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer,
default_layer=self.render_layer)
#Players image position is actually camera position
player_image_position = self.world.appearance[self.world.player].rect
#Parallax background
self.star_field = parallaxStarfield.ParallaxStarfield(
w, h, player_image_position.x, player_image_position.y)
def __init__(self,
mapName="WorldMap",
nameInZone="StartPointWorld",
screenSize=(SCREEN_WIDTH, SCREEN_HEIGHT)):
self.nameMap = mapName
self.tmxData = pytmx.util_pygame.load_pygame(
self.reqImageName(self.nameMap))
self.tiledMapData = pyscroll.data.TiledMapData(self.tmxData)
self.cameraPlayer = pyscroll.BufferedRenderer(self.tiledMapData,
screenSize,
clamp_camera=True)
self.cameraPlayer
# self.soundController = soundPlayerController()
self.allSprites = pygame.sprite.Group()
self.enemyGroup = pygame.sprite.Group()
self.itemGroup = pygame.sprite.Group()
self.friendlyBullet = pygame.sprite.Group()
self.friendlyExplosion = pygame.sprite.Group()
self.enemyBullet = pygame.sprite.Group()
self.spritesHUD = pygame.sprite.Group()
eFactory = EnemyFactory()
iFactory = ItemFactory()
for obj in self.tmxData.objects:
if obj.type == "enemy":
enemy = eFactory.create(obj, self)
self.allSprites.add(enemy)
self.enemyGroup.add(enemy)
# if obj.type == "item":
# item = iFactory.create(obj)
# self.allSprites.add(item)
# self.itemGroup.add(item)
# Put camera in mapData
self.camera = pyscroll.PyscrollGroup(map_layer=self.cameraPlayer,
default_layer=SPRITE_LAYER)
self.camera.add(self.allSprites)
# Spawn point of the player
valBool = False
for obj in self.tmxData.objects:
if obj.name == "InZone":
if obj.StartPoint == nameInZone:
self.spawmPointPlayerx = obj.x
self.spawmPointPlayery = obj.y
valBool = True
else:
print('No starting point')
# The game is not complete?
if valBool == False:
quitGame()
def load_world_map(map_file, screen):
tmx_data = load_pygame(map_file)
map_data = pyscroll.data.TiledMapData(tmx_data)
w, h = screen.get_size()
map_renderer = pyscroll.BufferedRenderer(
map_data, (int(w * 0.65), int(h * 0.65))) # map renderer
map_group = pyscroll.PyscrollGroup(map_layer=map_renderer,
default_layer=5) # Sprite group for map
return tmx_data, map_renderer, map_group
def load_world(self, world: World):
w, h = self.screen.get_size()
self.map_layer = pyscroll.BufferedRenderer(world.map_data,
(w / SCREEN_SCALE, h / SCREEN_SCALE),
clamp_camera=True)
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer, default_layer=4)
self.group.add(world.player)
self.group.add(world.lemons)
self.group.add(world.juice, layer=5)
def __init__(self,
mapName="WorldMap",
nameInZone="StartPointWorld",
screenSize=(SCREEN_WIDTH, SCREEN_HEIGHT)):
self.nameMap = mapName
self.tmxData = pytmx.util_pygame.load_pygame(
self.reqImageName(self.nameMap))
self.tiledMapData = pyscroll.data.TiledMapData(self.tmxData)
self.cameraPlayer = pyscroll.BufferedRenderer(self.tiledMapData,
screenSize,
clamp_camera=True)
# self.soundController = soundPlayerController()
self.allSprites = pygame.sprite.Group()
self.enemyGroup = pygame.sprite.Group()
self.itemGroup = pygame.sprite.Group()
self.friendlyBullet = pygame.sprite.Group()
self.enemyBullet = pygame.sprite.Group()
self.spritesHUD = pygame.sprite.Group()
self.notifySet = weakref.WeakSet(
) #Set of all object that needs to be notified of events. Weak references are used to prevent this set from keeping objects alive
eFactory = EnemyFactory()
iFactory = ItemFactory()
for obj in self.tmxData.objects:
if obj.type == "enemy":
enemy = eFactory.create(obj, self)
if enemy is not None:
self.allSprites.add(enemy)
self.enemyGroup.add(enemy)
# if obj.type == "item":
# item = iFactory.create(obj)
# self.allSprites.add(item)
# self.itemGroup.add(item)
# Put camera in mapData
self.camera = pyscroll.PyscrollGroup(map_layer=self.cameraPlayer,
default_layer=SPRITE_LAYER)
self.camera.add(self.allSprites)
# Spawn point of the player
valBool = False
for obj in self.tmxData.objects:
if obj.name == "InZone":
if obj.StartPoint == nameInZone:
self.spawmPointPlayerx = obj.x
self.spawmPointPlayery = obj.y
valBool = True
# The game is not complete?
if valBool == False:
quitGame()
def __init__(self, game, filename):
self.game = game
self.tmx_data = load_pygame('assets/maps/' + filename)
self.map_data = pyscroll.TiledMapData(self.tmx_data)
self.size = [
self.map_data.map_size[0] * self.map_data.tile_size[0],
self.map_data.map_size[1] * self.map_data.tile_size[1]
]
self.map_layer = pyscroll.BufferedRenderer(self.map_data, self.size)
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer)
def __init__(self):
self.screen = pygame.display.set_mode((1080, 720))
pygame.display.set_caption("Hero Quest")
# chargement de la carte
tmx_data = pytmx.util_pygame.load_pygame("map jeu.tmx")
map_data = pyscroll.data.TiledMapData(tmx_data)
map_layer = pyscroll.orthographic.BufferedRenderer(
map_data, self.screen.get_size())
# chargement du groupe avec la map
self.group = pyscroll.PyscrollGroup(map_layer=map_layer,
default_layer=1)
#récupération de la position du spawn du joueur
self.spawn_point = tmx_data.get_object_by_name("player_spawn")
self.spawn_point_bis = tmx_data.get_object_by_name("spawn_2")
self.sortie = tmx_data.get_object_by_name("player_spawn2")
#chargement du joueur
self.player = Player(self.spawn_point.x, self.spawn_point.y)
self.group.add(self.player)
#Zoom de la map
map_layer.zoom = 2.5
#chargement de toutes les collisions
self.walls = []
self.void = []
self.exit = []
self.exit2 = []
#group des monstres
self.monster = pygame.sprite.Group()
for obj in tmx_data.objects:
if obj.name == "collision":
self.walls.append(
pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height))
for obj in tmx_data.objects:
if obj.name == "void":
self.void.append(
pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height))
for obj in tmx_data.objects:
if obj.name == "exit":
self.exit.append(
pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height))
for obj in tmx_data.objects:
if obj.name == "exit2":
self.exit2.append(
pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height))
for obj in tmx_data.objects:
if obj.name == "ennemy":
self.cobra = Cobra(obj.x, obj.y)
self.monster.add(self.cobra)
for obj in tmx_data.objects:
if obj.name == "pnj":
pnj = Pnj(obj.x, obj.y)
self.monster.add(pnj)
#chargement des monstres
self.group.add(self.monster)
def restart():
global group, enemy, obstacles, hero_group, heart, staminaa, pole, other, PILL_COUNTER
del group, enemy, obstacles, hero_group, heart, staminaa, pole, other, PILL_COUNTER
group = pyscroll.PyscrollGroup(map_layer=map_layer)
pole = pygame.sprite.Group()
enemy = pygame.sprite.Group()
other = pygame.sprite.Group()
PILL_COUNTER = 0
obstacles = pygame.sprite.Group()
hero_group = pygame.sprite.Group()
heart = pygame.sprite.Group()
staminaa = pygame.sprite.Group()
start_screen()
def init_graphics(self):
pygame.display.set_caption('Dinos äventyr')
self.screen = pygame.display.set_mode(self.size, pygame.RESIZABLE)
self.background = pygame.Surface(self.screen.get_size())
self.tmx_data = pytmx.load_pygame("real_map.tmx")
# Make data source for the map
self.map_data = pyscroll.TiledMapData(self.tmx_data)
# Make the scrolling layer
screen_size = (self.width, self.height)
self.map_layer = pyscroll.BufferedRenderer(self.map_data, screen_size, clamp_camera=True, tall_sprites=1)
self.map_layer.zoom = 2
# make the PyGame SpriteGroup with a scrolling map
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer)
def __init__(self):
Scene.__init__(self)
# Set window caption
pygame.display.set_caption(WINDOW_CAPTION)
# TODO: rewrite scenes class to allow resizing of screen globally.
# See end paragraph of this article:https://nerdparadise.com/programming/pygame/part7
screen_size = [SCREEN_WIDTH, SCREEN_HEIGHT]
# List variable for layers - 0 = background color; 1 = scenery; 2 = level; 3 = player; 4 = foreground
# Each layer is a seperate surface.
self.layers = [pygame.Surface(screen_size) for i in range(4)]
# Create a sprite group of active sprites, which are all rendered in draw() function
self.active_sprite_list = pygame.sprite.Group()
# Create instance of player
self.player_one = Player(150, 50, self)
# Add player to list of active sprites, so it gets rendered in draw() function
self.active_sprite_list.add(self.player_one)
# Time to load our TMX level map.
self.lvl1_tmx_data = pytmx.load_pygame(LEVEL_01_TMX)
# Create new data source for pyscroll
self.map_data = pyscroll.data.TiledMapData(self.lvl1_tmx_data)
# Create new renderer (camera)
# Clamp_camera is used to prevent the map from scrolling past the edge
# TODO: remove screen width/height constants once we get dynamic screen sizes figured out
self.map_layer = pyscroll.BufferedRenderer(self.map_data,
screen_size,
clamp_camera=True)
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer)
# TODO: Figure out how to center player in map.
# TODO: uncomment the following lines of code, and remove/rewrite active_sprite_list
# For that, see https://github.com/bitcraft/pyscroll/wiki/Tutorial-(WIP)
# Add our player to the group
self.group.add(self.player_one)
# Can be switched on with F10 key, for that see events()
self.debug_mode = False
self.jump_key_pressed = False
self.platforms = self.get_solid_platforms(
self.lvl1_tmx_data.get_layer_by_name("Collision Mask"))
def __init__(self, mapfile):
self._move_queue = []
self.running = False
self.last_position_update = 0
map = load_pygame(mapfile)
self.mapp = load_pygame(mapfile)
self.objectlist = list(self.mapp.get_tile_locations_by_gid(20))
self.objectlist2 = list(self.mapp.get_tile_locations_by_gid(20))
self.moveCounter = 0
self.layer = map.layers[1]
self.objectlayer = map.layers[3]
self.charizardLayer = map.layers[4]
self.blastoiseLayer = map.layers[5]
self.ironLayer = map.layers[6]
self.venusaurLayer = map.layers[7]
self.snorlaxLayer = map.layers[8]
self.blastoiseLayer.visible = 0
self.ironLayer.visible = 0
self.venusaurLayer.visible = 0
self.snorlaxLayer.visible = 0
self.objectType = ["pokemon", "item"]
self.rarity = [1, 2, 3, 4, 5, 6, 8]
self.type = ["fire", "grass", "water", "normal"]
self.itemType = ["heal", "upgrade"]
self.catchableOrShiny = ["y", "n"]
self.itemUseless = [0]
self.apdp = [10, 15, 20, 25, 30, 35, 40, 50]
self.hpOfPokemonAndPlayer = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
self.pokemonCounter = 0
self.itemCounter = 0
self.moveHelper = self.objectlist[0]
self.moveCounter2 = 0
self.itemActive = 0
self.screenHelper = 1
self.hpPlayer = 100
map_data = pyscroll.data.TiledMapData(map)
w, h = screen.get_size()
self.map_layer = pyscroll.BufferedRenderer(map_data, screen.get_size(), clamp_camera=True)
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer, default_layer=4)
self.map_layer.zoom = 1.5
self.player = Player(PLAYER_IMAGE)
self.player.position = self.map_layer.map_rect.center
self.group.add(self.player)
self.mesh = Pathfinder(map)
def set_up_map(self):
"""
Sets up the map and the scrolling
"""
GameMap.set_up_map()
pyscroll_map_data = pyscroll.data.TiledMapData(GameMap.map_data)
# Scrolling Layer
w, h = self.screen.get_size()
self.map_layer = pyscroll.orthographic.BufferedRenderer(
pyscroll_map_data, (w / 2, h / 2), clamp_camera=True)
# Make group with scrolling map
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer)
self.map_layer.zoom = 1.0
def switch_map(self, map_name='monestary', spawn=True):
"""
Switches to input map
"""
self.current_map = map_name
# Pyscroll
tm = pytmx.load_pygame(path.join(self.maps_folder,
'{}.tmx'.format(map_name)),
pixelalpha=True)
self.map_data = pyscroll.TiledMapData(tm)
screen_size = (WIDTH, HEIGHT)
self.map_layer = pyscroll.BufferedRenderer(self.map_data, screen_size)
# Instantiate all_sprites group
self.all_sprites = pyscroll.PyscrollGroup(map_layer=self.map_layer)
for tile_object in tm.objects:
obj_center = vector(tile_object.x + tile_object.width / 2,
tile_object.y + tile_object.height / 2)
if tile_object.name == 'player':
if spawn:
self.player = Player(self, obj_center.x, obj_center.y)
elif not spawn:
self.all_sprites.add(self.player)
if tile_object.name == 'mob':
Mob(self, obj_center.x, obj_center.y, tile_object.type)
if tile_object.name == 'npc':
Npc(self, obj_center.x, obj_center.y, tile_object.type)
if tile_object.name == 'wall':
Obstacle(self, tile_object.x, tile_object.y, tile_object.width,
tile_object.height)
if tile_object.name == 'portal':
Portal(self, obj_center.x, obj_center.y, tile_object.width,
tile_object.height, tile_object.type)
if tile_object.name == 'spawn':
Spawn(self, obj_center.x, obj_center.y, tile_object.width,
tile_object.height, tile_object.type)
if tile_object.name == 'readable':
Readable(self, obj_center.x, obj_center.y, tile_object.width,
tile_object.height, tile_object.type)
if tile_object.name in POTION_ITEMS:
Potion(self, obj_center, tile_object.name)
if tile_object.name in SPELL_ITEMS:
Spell(self, obj_center, tile_object.name)
self.paused = False
self.night = False
self.inventory = False
self.effect_sounds['level_start'].play()
def reload(self, filename, screen, music):
super().__init__(filename)
self.filename = filename
self.music = music
self.map_data = pyscroll.data.TiledMapData(self.tmx_data)
self.map_layer = pyscroll.BufferedRenderer(self.map_data, (screen.get_rect().width
, screen.get_rect().height), clamp_camera=True)
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer)
self.blockers = make_object(self, 'blocker') # 禁止角色横跨的位置
self.doors = make_object(self, 'door') # 通往其它地图的门
self.start_points = make_object(self, 'start point') # 角色在一张地图的起始点
self.sprites = make_object(self, 'sprite') # 精灵对象
self.nobattle_area = make_object(self, 'nobattle') # 非战斗区域
self.info = make_object(self, 'info')
self.image_sprites = [] # 储存精灵图片对象
self.screen = screen
self.create_sprite_object()
pygame.mixer.music.set_volume(const.BGM_VOL / 10)
def __init__(self):
self.screen = pygame.display.set_mode((1080, 720))
pygame.display.set_caption("HappyCakeQuest")
# charger la carte
tmx_data = pytmx.util_pygame.load_pygame('carte.tmx')
map_data = pyscroll.data.TiledMapData(tmx_data)
self.map_layer = pyscroll.orthographic.BufferedRenderer(
map_data, self.screen.get_size())
self.map_layer.zoom = 2.8
# le group avec la map
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer,
default_layer=3)
# recuperer le point de spawn du joueur
self.spawn_point = tmx_data.get_object_by_name('player_spawn')
self.monsters = pygame.sprite.Group()
win_point = tmx_data.get_object_by_name('win')
self.win_rect = pygame.Rect(win_point.x, win_point.y, win_point.width,
win_point.height)
# charger le joueur
self.player = Player(self.spawn_point.x, self.spawn_point.y)
self.group.add(self.player)
# charger les blocks de collisions
self.walls = []
self.void = []
for obj in tmx_data.objects:
if obj.type == "collision":
self.walls.append(
pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height))
if obj.type == "void":
self.void.append(
pygame.rect.Rect(obj.x, obj.y, obj.width, obj.height))
if obj.type == "monster":
scorpion = Scorpion(obj.x, obj.y)
self.monsters.add(scorpion)
self.group.add(self.monsters)
def __init__(self):
self.map = 'world'
# fenêtre du jeu
self.screen = pygame.display.set_mode((1280, 720))
pygame.display.set_caption("Pygame - Jeu 2D")
# chargement de la carte tmx
tmx_data = pytmx.util_pygame.load_pygame('carte.tmx')
map_data = pyscroll.data.TiledMapData(tmx_data)
map_layer = pyscroll.orthographic.BufferedRenderer(
map_data, self.screen.get_size())
map_layer.zoom = 2
# génération du joueur
player_position = tmx_data.get_object_by_name("player")
self.player = Player(player_position.x, player_position.y)
# liste des collisions
self.walls = []
for object in tmx_data.objects:
if object.type == 'collision':
self.walls.append(
pygame.Rect(object.x, object.y, object.width,
object.height))
# dessin du groupe de calques
self.group = pyscroll.PyscrollGroup(map_layer=map_layer,
default_layer=5)
self.group.add(self.player)
# collision pour entrer dans la maison
enter_house = tmx_data.get_object_by_name('enter_house')
self.enter_house_rect = pygame.Rect(enter_house.x, enter_house.y,
enter_house.width,
enter_house.height)
def load_map(self, map_name, spawn_point):
self.tmx_data = load_pygame(BASEDIR / "assets" / "maps" /
f"{map_name}.tmx")
self.map_data = pyscroll.TiledMapData(self.tmx_data)
self.map_layer = pyscroll.BufferedRenderer(self.map_data,
self.GAME_AREA_SIZE_PIXELS)
self.map_sprite_group = pyscroll.PyscrollGroup(
map_layer=self.map_layer, default_layer=3)
# Find first spawn point
spawns_layer = self.tmx_data.get_layer_by_name("spawns")
self.spawns = {
spawn.name: [spawn.x, spawn.y]
for spawn in spawns_layer
}
self.hero.position = self.spawns[spawn_point]
self.map_sprite_group.add(self.hero)
# Build impassable rect list
impassables_layer = self.tmx_data.get_layer_by_name("impassables")
self.impassables = [object_to_rect(o) for o in impassables_layer]
doors_layer = self.tmx_data.get_layer_by_name("doors")
self.doors = [(object_to_rect(o), o) for o in doors_layer]
def __init__(self):
# Init game parameters
pg.init()
pg.font.init()
self.screen = pg.display.set_mode(W_SIZE, pg.RESIZABLE)
self.tmp_surface = pg.Surface(W_SIZE).convert()
pg.display.set_caption("Zombie Mania - It's just a flesh wound!")
self.background = load_images("BACKGROUND")
# Load data from TMX-map
self.map_path = "../res/maps/map0.tmx"
self.tmx_data = load_pygame(self.map_path)
self.map_data = pyscroll.data.TiledMapData(self.tmx_data)
#self.misc_layer = self.tmx_data.layernames["Misc"]
# Add static obstacles to a dict for easy collision checking
self.obstacles = []
for obs in self.tmx_data.get_layer_by_name("Map"):
if obs[2] != 0:
pos = (obs[0] * BLOCK_SIZE, obs[1] * BLOCK_SIZE)
tmp_rect = pg.Rect(pos, (BLOCK_SIZE, BLOCK_SIZE))
self.obstacles.append(tmp_rect)
# Create renderer (camera)
# clamp_camera is used to prevent the map from scrolling past the edge
# TODO: Fix so that the renderer doesn't render the whole screen, only the visible
self.map_layer = pyscroll.BufferedRenderer(self.map_data,
W_SIZE,
clamp_camera=True,
alpha=True,
tall_sprites=1)
self.group = pyscroll.PyscrollGroup(map_layer=self.map_layer)
self.zombie = Zombie()
self.group.add(self.zombie)
(obj.x + obj.width, 0)]
for p in obj.points:
print(p)
# Make data source for the map
map_data = pyscroll.TiledMapData(tmx_data)
# Make the scrolling layer
for p in tmx_data.properties.keys():
print("%s: %s", p, tmx_data.properties[p])
map_layer = pyscroll.BufferedRenderer(map_data, screen_size, alpha=False)
# make the pygame SpriteGroup with a scrolling map
group = pyscroll.PyscrollGroup(map_layer=map_layer)
px, py = (map_layer.map_rect.width / 2, map_layer.map_rect.height / 2)
group.center((px, py))
# Add sprites to the group
#group.add(sprite)
# Center the layer and sprites on a sprite
# Draw the layer
# If the map covers the entire screen, do not clear the screen:
# Clearing the screen is not needed since the map will clear it when drawn
# This map covers the screen, so no clearing!
#bgimage = tmx_data.layers[1].image
#pygame.image.save(bgimage, "exit.jpg")
def game_loop():
clock=pygame.time.Clock()
recording=False
terrain=make_terrain()
terrain_d=TERRAIN_DIRTY()
objects=[]
map_layer = pyscroll.BufferedRenderer(MyData(terrain), (screen_w,screen_h))
group = pyscroll.PyscrollGroup(map_layer=map_layer)
macro=[]
mobs=[]
dwarves=[]
dw_index=0
position=TILE*2500,TILE*50
a_dwarf=Dwarf(2500*16,40*16,terrain,terrain_d,group,objects)
another_dwarf=Dwarf(2502*16,40*16,terrain,terrain_d,group,objects)
yet_another_dwarf=Dwarf(2505*16,40*16,terrain,terrain_d,group,objects)
fourth_dwarf=Dwarf(2507*16,40*16,terrain,terrain_d,group,objects)
dwarves.append(a_dwarf)
group.add(a_dwarf)
dwarves.append(another_dwarf)
group.add(another_dwarf)
dwarves.append(yet_another_dwarf)
group.add(yet_another_dwarf)
dwarves.append(fourth_dwarf)
group.add(fourth_dwarf)
a_hammer=Hammer()
a_pick=PickAxe()
a_sickle=Sickle()
a_ladder=Ladder()
group.add(a_hammer)
group.add(a_pick)
group.add(a_sickle)
group.add(a_ladder)
the_dwarf=dwarves[dw_index]
a_dwarf.inventory=a_pick
another_dwarf.inventory=a_ladder
yet_another_dwarf.inventory=a_sickle
fourth_dwarf.inventory=a_hammer
while True:
if android:
OuyaController.startOfFrame()
delta=clock.tick(30)
if android:
if android.check_pause():
android.wait_for_resume()
events = pygame.event.get()
keys = pygame.key.get_pressed()
mouse = pygame.mouse.get_pressed()
for e in events:
if e.type==pygame.QUIT:
return
if e.type==pygame.KEYDOWN and e.key==pygame.K_q:
return
if e.type==pygame.KEYDOWN and e.key==pygame.K_k:
if not recording:
dw_index=(dw_index+1)%len(dwarves)
if e.type==pygame.KEYDOWN and e.key==pygame.K_j:
if not recording:
dw_index=(dw_index-1)%len(dwarves)
if e.type==pygame.KEYDOWN and e.key==pygame.K_r:
if not recording:
macro=["LOOP"]
else:
program=the_dwarf.commands_behave(macro)
the_dwarf.behaviour=program
macro=[]
recording=not recording
the_dwarf=dwarves[dw_index]
the_dwarf.command=None
the_dwarf.parameter=None
if keys[pygame.K_c] and keys[pygame.K_RIGHT]:
if the_dwarf.inventory is not None:
the_dwarf.command="USE-RIGHT"
elif keys[pygame.K_c] and keys[pygame.K_LEFT]:
if the_dwarf.inventory is not None:
the_dwarf.command="USE-LEFT"
elif keys[pygame.K_c] and keys[pygame.K_DOWN]:
if the_dwarf.inventory is not None:
the_dwarf.command="USE-DOWN"
elif keys[pygame.K_c] and keys[pygame.K_UP]:
if the_dwarf.inventory is not None:
the_dwarf.command="USE-UP"
elif keys[pygame.K_c]:
if the_dwarf.inventory is not None:
the_dwarf.command="USE"
elif keys[pygame.K_UP]:
the_dwarf.command="UP"
elif keys[pygame.K_LEFT]:
the_dwarf.command="LEFT"
elif keys[pygame.K_RIGHT]:
the_dwarf.command="RIGHT"
elif keys[pygame.K_DOWN]:
the_dwarf.command="DOWN"
elif keys[pygame.K_s]:
if the_dwarf.inventory is not None:
the_dwarf.command="PUT"
elif keys[pygame.K_x]:
if the_dwarf.inventory is None:
the_dwarf.command="TAKE"
if recording and the_dwarf.command:
macro.append(the_dwarf.command)
if terrain_d.get():
map_layer.redraw()
group.update(delta)
group.center(the_dwarf.rect.center)
group.draw(screen)
if len(sys.argv)==2 and sys.argv[1]=="--big":
screen.blit(the_font.render("arrows-move, j/k-switch gnome",1,[255,255,255]),[5,23])
screen.blit(the_font.render("x/s-take/drop, c-use tool",1,[255,255,255]),[5,38])
off=53
else:
screen.blit(the_font.render("arrows-move, j/k-switch gnome, x/s-take/drop, c-use tool",1,[255,255,255]),[5,23])
off=38
for i,dwarf in enumerate(dwarves):
if dwarf.inventory is not None:
screen.blit(the_font.render(dwarf.inventory.name
+" "+str(dwarf.inventory.durability)
+" "+str(dwarf.food/50)
,1,(255,255,255)),(5,off+i*15))
else:
screen.blit(the_font.render("NOTHING"
+" "+str(dwarf.food/50)
,1,(255,255,255)),(5,off+i*15))
if recording:
screen.blit(rec,(0,0))
if len(sys.argv)==2 and sys.argv[1]=="--big":
pygame.transform.scale(screen,(800,600),screen_real)
pygame.display.flip()
def main():
os.chdir(os.path.dirname(sys.argv[0]))
icon = pygame.image.load("icon.png")
pygame.display.set_icon(icon)
DISPLAY = init_screen(WIDTH, HEIGHT, 0) ## not resizable in the beginning
pygame.mixer.music.load("Overworld.ogg")
pygame.mixer.music.play(-1)
ash = Ash(30, DISPLAY)
startingAnimation(DISPLAY, ash)
#DISPLAY = init_screen(WIDTH, HEIGHT)
ash.setDisplay(temp_surface)
global tmx_data, quad, map_layer, paused, onlyDirs, dir
tmx_data = pytmx.load_pygame("level1.tmx")
map_data = pyscroll.data.TiledMapData(tmx_data)
map_layer = pyscroll.BufferedRenderer(map_data, (WIDTH / 2, HEIGHT / 2),
clamp_camera=True)
group = pyscroll.PyscrollGroup(map_layer=map_layer)
hero = Protagonist("dudes//dude_right0.png")
start = tmx_data.get_object_by_name("Start")
end = tmx_data.get_object_by_name("End")
hero.setPoint(start.x, start.y)
group.add(hero)
quad = pyscroll.quadtree.FastQuadTree(getAllRects())
Environment.setDimensions(tmx_data.width * 16, tmx_data.height * 16)
env = Environment([hero], [
EnvironmentReference.applyGravity, EnvironmentReference.applyDrag,
EnvironmentReference.solidGround, EnvironmentReference.keepInWindow,
EnvironmentReference.collide
])
envSpring = Environment([hero], [
EnvironmentReference.solidGround, EnvironmentReference.keepInWindow,
EnvironmentReference.collide
])
envClimb = Environment([hero], [
EnvironmentReference.keepInWindow,
EnvironmentReference.stickToClimbable
])
dir = None
pointDir = "right"
jump = True
num = -1
springLoad = 0
lastSpring = None
startTime = None
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit(0)
#elif event.type == VIDEORESIZE:
# init_screen(event.w, event.h)
# map_layer.set_size((event.w / 2, event.h / 2))
elif event.type == KEYDOWN:
if event.key in [K_w, K_UP] and jump:
jump = False
if inAir(hero) and round(
math.degrees(hero.velocity.angle)
) > 45 and round(
math.degrees(hero.velocity.angle)
) < 135 and hero.velocity.speed > Environment.gravity.speed:
hero.addVector(Vector(270, 8))
else:
hero.addVector(Vector(270, 6))
hero.update()
dir = "up"
num = 0
elif event.type == KEYUP:
if event.key == K_F12:
if not paused:
pygame.mixer.music.pause()
else:
pygame.mixer.music.unpause()
paused = not paused
if event.key == K_SPACE and springLoad > 0 and dir != None and (
lastSpring == None
or lastSpring + timeBetweenSprings <= time.time()):
lastSpring = time.time()
num = 5
x, y = getDelta()
if (x, y) != (0, 0):
jump = True
hero.setImage("dudes//dude_{}{}.png".format(dir, num))
hero.velocity = Vector(0, 0)
for i in range(springLoad * SPRING):
hero.updateAbsolute(x, y)
group.draw(temp_surface)
envSpring.update()
ash.update()
pygame.transform.scale(temp_surface,
DISPLAY.get_size(), DISPLAY)
pygame.display.flip()
clock.tick(200)
springLoad = 0
hero.addVector(Environment.gravity)
if event.key in [K_LSHIFT, K_v] and startTime == None:
startTime = time.time()
## climbing
env, envClimb = envClimb, env
jump = False
pygame.display.update()
keysDown = pygame.key.get_pressed()
if keysDown[K_d] or keysDown[K_RIGHT] and "right" in onlyDirs and (
startTime == None or canMoveClimb(hero, "right")):
hero.updateAbsolute(DT, 0)
dir = "right"
pointDir = "right"
num = (num + 1) if num + 1 <= 4 else 1
elif keysDown[K_LEFT] or keysDown[K_a] and "left" in onlyDirs and (
startTime == None or canMoveClimb(hero, "left")):
hero.updateAbsolute(-DT, 0)
dir = "left"
pointDir = "left"
num = (num + 1) if num + 1 <= 4 else 1
elif (keysDown[K_s]
or keysDown[K_DOWN]) and inAir(hero) and "down" in onlyDirs and (
startTime == None or canMoveClimb(hero, "down")):
hero.updateAbsolute(0, DT)
dir = "down"
num = 0
elif (keysDown[K_w] or keysDown[K_UP]
) and "up" in onlyDirs and startTime != None and canMoveClimb(
hero, "up"):
hero.updateAbsolute(0, -DT)
dir = "up"
elif jump == True:
dir = None
num = -1
if keysDown[K_SPACE]:
if springLoad < 16 and startTime == None:
springLoad += 1
num = 6
if atGround(hero) and not jump:
jump = True
dir = None
num = -1
if startTime != None:
pass ## num = 9
if dir in ["right", "left"]:
hero.setImage("dudes//dude_{}{}.png".format(dir, num))
elif dir in ["down", "up"] and num in (0, 5):
hero.setImage("dudes//dude_{}{}.png".format(dir, num))
elif dir == None and num == -1:
hero.setImage("dudes//dude_{}0.png".format(pointDir))
elif dir == None and num == 6:
hero.setImage("dudes//dude_{}6.png".format(pointDir))
group.center(hero.rect.center)
group.draw(temp_surface)
env.update()
if springLoad > 0:
showLoad(temp_surface, springLoad, hero)
if startTime != None and startTime + climbMax <= time.time():
startTime = None
env, envClimb = envClimb, env
onlyDirs = ["up", "down", "left", "right", None]
elif startTime != None:
timeToStop = startTime + climbMax - time.time()
showClimbMeter(temp_surface, round(timeToStop * (16 // climbMax)),
hero)
for tile, props in getCollisions(hero).items():
if props != None and "Type" in props.keys():
if props["Type"] == "Kill":
if collideKill(hero, tile):
gameOverAnimation(DISPLAY, hero, ash)
hero.setPoint(start.x, start.y)
springLoad = 0
lastSpring = None
group.center(hero.rect.center)
group.draw(temp_surface)
pygame.transform.scale(temp_surface,
DISPLAY.get_size(), DISPLAY)
pygame.display.flip()
while pygame.mixer.music.get_busy() and not paused:
pass
if not paused:
pygame.mixer.music.load("Overworld.ogg")
pygame.mixer.music.play(-1)
elif props["Type"] == "Sign":
intro = tmx_data.get_object_by_name("Intro")
special = tmx_data.get_object_by_name("Special")
if tile[0] * 16 == intro.x:
text(DISPLAY, "Reach the other side", tile)
elif tile[0] * 16 == special.x:
text(DISPLAY, "Try out SPACE", tile)
else:
assert False, "There shouldn't be any other Signs"
if tile in endTiles(end):
winningAnimation(DISPLAY, ash)
ash.update()
pygame.transform.scale(temp_surface, DISPLAY.get_size(), DISPLAY)
pygame.display.flip()
clock.tick(FPS)
