def initialize(self):
self.size = self.width, self.height = constants.width, constants.height
self.screen = pygame.display.set_mode(self.size)
self.clock = pygame.time.Clock()
# Initialize Background
self.background = sprites.Background('stars.png')
# Initialize Players
self.player1 = sprites.Player(1)
self.player2 = sprites.Player(2)
# Initialize Scoreboard
self.scoreboard1 = sprites.Scoreboard(1, constants.width / 4,
self.player1)
self.scoreboard2 = sprites.Scoreboard(2, 3 * constants.width / 4,
self.player2)
# Initialize Platforms
self.platforms = pygame.sprite.Group()
self.platform1 = sprites.Platform(constants.width / 2, 50,
self.player1)
self.platform2 = sprites.Platform(constants.width / 2,
constants.height - 50, self.player2)
self.platforms.add(self.platform1)
self.platforms.add(self.platform2)
# Initialize Balls
self.balls = pygame.sprite.Group()
self.ball1 = sprites.Ball(self.platform1)
self.ball2 = sprites.Ball(self.platform2)
self.ball1.other = self.ball2
self.ball2.other = self.ball1
self.balls.add(self.ball1)
self.balls.add(self.ball2)
def update(self):
"""
updating the parts of the game with the events input
"""
# if new players entered the game, insert them to the game
# future: players could only enter before battle started
if len(self._data_stream) > len(self.players) + 1:
players = self.players.sprites()
players.append(self._local_player)
backup = self._data_stream[:]
for player_data in backup:
check = filter(lambda x: x.identifier == player_data[0],
players)
if not check:
sprites.Player(self, *player_data)
self._data_stream.remove(player_data)
# update players
self.players.update(self._data_stream)
# update all objects
self.all_sprites.update()
# update point of view
self.camera.update(self._local_player)
# send local player data to (demy) net thread
# possible change: first send local player data, then update
try:
self._out_stream[0] = (self._local_player.identifier,
self._local_player.team,
(self._local_player.pos.x,
self._local_player.pos.y),
self._local_player.angle)
except IndexError:
self._out_stream.append(
(self._local_player.identifier, self._local_player.team,
(self._local_player.pos.x,
self._local_player.pos.y), self._local_player.angle))
def __init__(self, go, music):
self.time = 0
self.era = 1
self.score = 0
self.cause_of_death = None
self.player = sprites.Player()
self.player.rect.x = PLAYER_X
self.player.rect.y = LANE_START_Y + 1.5 * LANE_HEIGHT - PLAYER_SIZE[
1] + self.player.hitbox.height // 2
self.all_units = pygame.sprite.Group()
self.obstacles = sprites.Obstacles()
self.scroll_objects = sprites.ScrollObjects()
self.graphic = pygame.sprite.LayeredUpdates()
self.graphic.layers()
road1 = sprites.AnimationSprite(IMG_ROAD, (0, 0))
self.scroll_objects.add(road1)
self.all_units.add(road1, self.player)
self.graphic.add(road1, self.player)
self.graphic.change_layer(self.player, 2)
self.graphic.change_layer(road1, 0)
self.music = music
self.music.change(self.era)
self.running = True # True as long as the game should be running
self.game_over = go
self.reset = False
self.kill = set()
def make_player(self):
layer = self.tmx_renderer.get_layer('start_points')
for obj in layer:
if obj.name == self.previous:
player = s.Player(obj.x, obj.y, obj.properties['direction'])
return player
def new(self): #SPAWN DAS SPRITES
self.all_sprites = py.sprite.Group()
self.walls = py.sprite.Group()
self.colisao = py.sprite.Group()
for row, tiles in enumerate(self.map_data):
for col, tile in enumerate(tiles):
if tile == '1': #SPAWN DO MURO
sprites.Wall(self, col, row)
# if tile == 'L': #SPAWN DO PORTAL LARANJA DE CIMA
# sprites.Portal_L(self, col, row)
# if tile == 'l': #SPAWN DO PORTAL LARANJA DE BAIXO
# sprites.Portal_l(self, col, row)
#
# if tile == 'R': #SPAWN DO PORTAL ROXO DE CIMA
# sprites.Portal_R(self, col, row)
# if tile == 'r': #SPAWN DO PORTAL ROXO DE BAIXO
# sprites.Portal_r(self, col, row)
if tile == '!': #SPAWN DO PLAYER 1 / AZUL / ÁGUA
self.player_agua = sprites.Player(self, col, row)
self.players_agua = py.sprite.Group()
self.players_agua.add(self.player_agua)
if tile == '@': #SPAWN DO PLAYER 2 / AMARELO / FOGO
self.player_fogo = sprites.Player2(self, col, row)
self.players_fogo = py.sprite.Group()
self.players_fogo.add(self.player_fogo)
def __init__(self, address):
#init socket
self.sock = socket.socket()
self.sock.connect(address)
self.c = self.sock.recv(1024).decode()
#number of clients, size and pygame stuff
self.client_count = 0
self.size = (800, 600)
self.screen = pg.display.set_mode(self.size)
pg.display.set_caption("Multiplayer python game, bi-sh")
#player images
self.person_images = []
for i in range(6):
self.person_images.append(
pg.image.load(f"./res/player/sprite{i}.png"))
#all colours we might use
self.colours = {'r': (255, 0, 0), 'g': (0, 255, 0), 'b': (0, 0, 255)}
#player, clients , maps and groups
self.all_sprites = pg.sprite.Group()
self.clients = pg.sprite.Group()
self.walls = pg.sprite.Group()
self.level_map = tile_map.Map("res/levels/level1.txt")
self.camera = tile_map.Camera(self.level_map, self.size[0],
self.size[1])
self.init_map()
self.clock = pg.time.Clock()
self.player = sprites.Player(self, self.c, self.colours[self.c])
def __init__(self):
self.score = 0
self.loader = loader.Loader()
self.gamemode = fsm([('Playing', 'GameOver', lambda x: x == 'GameOver'),
('MainMenu', 'Playing', lambda x: x == 'NewGame', lambda x, y: self.newgame()),
('MainMenu', 'Playing', lambda x: x == 'Resume'),
('Playing', 'MainMenu', lambda x: x == 'MainMenu'),
('GameOver', 'Playing', lambda x: x == 'GameOver')])
self.gamemode.start('MainMenu')
self.menu = kezmenu.KezMenu(['SPACE ACE!', lambda: True],
['New Game', lambda: self.gamemode.event('NewGame')],
['Exit', lambda: pygame.event.post(pygame.event.Event(pygame.QUIT))])
self.menu.center = True # enable horizontal menu item centering
self.menu.color = WHITE
self.menu.focus_color = GREEN
self.menu.options[0]['focus_color'] = RED
self.menu.options[0]['color'] = RED
self.menu.options[0]['font'] = pygame.font.Font("fonts/OverdriveInline.ttf", 75)
self.menu._fixSize()
self.menu.center_at(SCREEN_CENTER) # center entire menu to screen
self.enemy_list = pygame.sprite.Group()
self.player_list = pygame.sprite.Group()
self.all_sprites_list = pygame.sprite.Group()
self.events = None
# Create the player
self.player = sprites.Player(self.loader.PLAYER_IMAGE)
self.all_sprites_list.add(self.player)
self.player_list.add(self.player)
def startup(self):
self.texts = []
strings = [
'NPC Escort Mission Demo', 'Move with WASD',
'Toggle Debug Mode with F12', ' ', ' ', 'Press any key to start'
]
for y, s in enumerate(strings):
font = self.game.fonts['default']
txt, txt_rect = font.render(s,
fgcolor=pg.Color('White'),
bgcolor=None)
txt_rect.centerx = self.game.screen_rect.centerx
txt_rect.centery = ((y + 1) * self.game.screen_rect.h /
(len(strings) + 2))
self.texts.append((txt, txt_rect))
player = spr.Player(self.game, {
'x': 0,
'y': 120,
'width': 16,
'height': 28
})
player.speed = 10
self.npc = spr.NPC(self.game, {
'x': -48,
'y': 120,
'width': 16,
'height': 28
})
self.npc.speed = 10
def new(self):
#Create a new game
self.score = 0
self.boost = 0
self.ground_tempo = 0
self.ground_count = 0
self.collide = False
#Creation of player
self.characters = pg.sprite.Group()
self.man = sprites.Player()
self.characters.add(self.man)
#Creation of ceil
self.platforms = pg.sprite.Group()
ceil = sprites.Platform(0, SPREAD, WIDTH)
self.platforms.add(ceil)
#Customize creation of first floor (to avoid hole below player at the beginning)
p1left = sprites.Platform(0, self.platforms.sprites()[-1].rect.y + SPREAD, WIDTH / 2)
p1right = sprites.Platform(WIDTH / 2 + HOLE_SIZE, self.platforms.sprites()[-1].rect.y + SPREAD, WIDTH / 2 - HOLE_SIZE)
self.platforms.add(p1left, p1right)
#Creation of 5 next floors
for i in range(1, 6):
self.create_floor()
self.render()
def player_attack(_player_state, target):
# If the player has the sword
if _player_state.hasSword:
# If the target is the goblin, the goblin is killed
if target == 'goblin' and _player_state.get_room() == (0, 2):
_player_state.room.remove_sprite(sprites.Goblin())
_player_state.killedGoblin = True
return "You showed no mercy to the goblin and collected its blood."
# If the target is the demon and the player has obtained the shield, it
# defeats the demon and the game is over
if target == 'demon' and _player_state.get_room() == (
1, 0) and _player_state.hasShield:
_player_state.room.remove_sprite(sprites.Boss())
return "You have killed the boss and saved the kingdom!"
# If the target is the demon and the player has not obtained the shield,
# it is defeated by the demon and the game is over
elif target == 'demon' and _player_state.get_room() == (
1, 0) and not (_player_state.hasShield):
_player_state.room.remove_sprite(sprites.Player())
_player_state.gameOver = True
return "Shoot! You were not strong enough to defeat the boss. Game Over! ..................."
# If the player tries to attack an invalid target
else:
return "You cannot attack that."
# If the player doesn't have the sword, they cannot attack
else:
return "You have nothing to attack with. "
def new(self):
self.all_sprites = pg.sprite.Group()
self.walls = pg.sprite.Group()
self.items = pg.sprite.Group()
self.ninjas = pg.sprite.Group()
#define onde sprites vão ser desenhados baseado no mapa tmx
for tile_object in self.map.tmxdata.objects:
obj_center = settings.vec(
4 * tile_object.x + 4 * tile_object.width / 2,
4 * tile_object.y + 4 * tile_object.height / 2)
if tile_object.name == 'player':
self.player = sprites.Player(
self, obj_center.x,
obj_center.y) #define spawn point do player
if tile_object.name == 'wall':
sprites.Obstacle(self, 4 * tile_object.x, 4 * tile_object.y,
4 * tile_object.width, 4 * tile_object.height
) #cria obstáculo das paredes pra colisão
if tile_object.name == 'ninja':
sprites.Ninja(self, obj_center.x, obj_center.y)
if tile_object.name in ['chest']:
sprites.Item(self, obj_center, tile_object.name)
sprites.Obstacle(self, 4 * tile_object.x, 4 * tile_object.y,
4 * tile_object.width, 4 * tile_object.height)
if tile_object.name in ['door']:
sprites.Item(self, obj_center, tile_object.name)
self.porta = sprites.Obstacle(self, 4 * tile_object.x,
4 * tile_object.y,
4 * tile_object.width,
4 * tile_object.height)
if tile_object.name == 'door_final':
sprites.Item(self, obj_center, tile_object.name)
self.porta2 = sprites.Obstacle(self, 4 * tile_object.x,
4 * tile_object.y,
4 * tile_object.width,
4 * tile_object.height)
if tile_object.name in ['key']:
sprites.Item(self, obj_center, tile_object.name)
self.key = sprites.Obstacle(self, 4 * tile_object.x,
4 * tile_object.y,
4 * tile_object.width,
4 * tile_object.height)
if tile_object.name in ['casaco']:
sprites.Item(self, obj_center, tile_object.name)
self.casaco = sprites.Obstacle(self, 4 * tile_object.x,
4 * tile_object.y,
4 * tile_object.width,
4 * tile_object.height)
# if tile_object.name in ['guarda_chuva']:
# sprites.Item(self,obj_center,tile_object.name)
# sprites.Obstacle(self, 4*tile_object.x, 4*tile_object.y, 4*tile_object.width, 4*tile_object.height)
if tile_object.name == 'book':
sprites.Item(self, obj_center, tile_object.name)
sprites.Obstacle(self, 4 * tile_object.x, 4 * tile_object.y,
4 * tile_object.width, 4 * tile_object.height)
self.camera = tilemap.Camera(self.map.width, self.map.height)
self.draw_debug = False
def __init__(self):
self.sprite = sprites.Player()
self.target = (250, 250)
self.top = 250
self.left = 250
self.item = ""
self.baby = 0
self.deliver = False
def player_cast(_player_state, _):
# Crosses the player over the river if in the correct room
if _player_state.get_room() == (2, 0):
# After the player crosses the river, their position is updated
_player_state.acrossRiver = not _player_state.acrossRiver
_player_state.room.remove_sprite(sprites.Player())
# Moves the sprite of the player depending on which side of the river
# they are on
if _player_state.acrossRiver:
_player_state.room.add_sprite(sprites.Player(200, 5))
else:
_player_state.room.add_sprite(sprites.Player(200, 400))
# Returns text explaining that the character has crossed the river
return "The magic of " + MAGIC_SPELL + " let you jump over the river!"
# If user is not in the room with the river
else:
# Informs the user that they gained the ability to jump
return "The magic of " + MAGIC_SPELL + " let you jump!"
def __init__(self, engine, **kwargs):
super().__init__(engine=engine,
background_color=(45, 30, 55),
**kwargs)
self.play_area = engine.display.get_rect()
self.run_time = 0
self.spawn = simple_enemies(1.5, 200)
self.next_spawn, self.next_x = next(self.spawn)
_ = self.groups[sprites.Bullet.group] # force setting the key.
sprites.Player(self)
def startup(self):
# TODO: overworld grid should consist of multiple maps
# TODO: the grid construction should be done from json data
maps = [
tilemaps.Map(self.game, self.game.map_files[2]),
tilemaps.Map(self.game, self.game.map_files[3]),
tilemaps.Map(self.game, self.game.map_files[4])
]
self.game.overworld_grid = tilemaps.Grid(self.game,
name='overworld',
width=2,
height=2)
self.game.overworld_grid.insert_grid(maps[0], 0, 0)
self.game.overworld_grid.insert_grid(maps[1], 1, 0)
self.game.overworld_grid.insert_grid(maps[2], 0, 1)
self.game.map = maps[0]
self.game.map.create_map()
# put the player somewhere on the map
self.game.player = spr.Player(self.game, {
'x': 182,
'y': 136,
'width': 16,
'height': 16
})
self.game.inventory = inter.Inventory(self.game)
self.game.inventory.active = True
# TODO: Testing
self.game.inventory.add_item(items.Sword, 0, 0)
self.game.inventory.add_item(items.Test, 0, 1)
self.game.camera = utils.Camera(self.game, self.game.map.size.x,
self.game.map.size.y, 'FOLLOW')
self.game.camera.update(self.game.player)
t = inter.Textbox(self.game, self.game.world_screen_rect.center,
self.game.texts['demo_dialog'],
lambda: self.game.change_state('InGame'))
#t.activate()
spr.Enemy(self.game, {'x': 300, 'y': 100, 'width': 16, 'height': 16})
self.game.select_menu = inter.Base_menu(self.game,
rect=None,
anchor_x='centerx')
e1 = inter.Menu_entry('Resume Game', self.game.select_menu.deactivate)
e2 = inter.Menu_entry('Go To Title Screen',
lambda: self.game.change_state('TitleScreen'))
e3 = inter.Menu_entry('Exit Program', self.game.exit_game)
self.game.select_menu.add_entries(e1, e2, e3)
self.done = True
def new(self):
self.all_sprites = pygame.sprite.Group()
self.platforms = pygame.sprite.Group()
self.player = sprites.Player()
for i in platform_list:
p = sprites.Platform(i[0], i[1], i[2], i[3])
self.platforms.add(p)
self.all_sprites.add(p)
self.all_sprites.add(self.player)
self.run()
def new(self):
self.all_sprites = py.sprite.Group()
self.walls = py.sprite.Group()
for row, tiles in enumerate(self.map_data):
for col, tile in enumerate(tiles):
if tile == '1':
sprites.Wall(self, col, row)
if tile == 'S':
self.player_agua = sprites.Player(self, col, row)
if tile == 'L':
self.player_fogo = sprites.Player2(self, col, row)
def main():
pygame.init()
size = width, height = 1152, 704
screen = pygame.display.set_mode(size)
pygame.display.set_caption('protoDiablo')
pygame.mouse.set_visible(False)
FPS = 30
running = [True]
board = PlayingBoard(screen, running, 'map.txt', FPS)
if not running[0]:
return
cursor = sprites.Cursor(screen, running, board)
player = sprites.Player(np.array([540, 2000], int), board)
board.set_ref(cursor, player)
interface = Interface(screen, running, board)
clock = pygame.time.Clock()
while running[0]:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running[0] = False
if event.type == pygame.MOUSEMOTION:
cursor.update_pos(event.pos)
if event.type == pygame.MOUSEBUTTONDOWN:
cursor.update('down')
if not interface.clicked(
cursor.get_pos()) and interface.state == 'ingame':
board.clicked()
if event.type == pygame.MOUSEBUTTONUP:
cursor.update('idle')
if event.type == pygame.KEYDOWN:
if interface.state == 'ingame':
if event.key == 27:
interface.set_state('pause')
elif event.key == 101:
board.player.heal()
else:
if event.key == 27:
interface.set_state('ingame')
if player.hp <= 0:
interface.set_state('death')
screen.fill((0, 255, 0))
if interface.state == 'ingame':
board.render()
interface.take_screen()
interface.draw()
cursor.draw()
pygame.display.flip()
clock.tick(FPS)
def new_game(self):
# vars
self.won = False
self.last_update = 0
self.current_frame = 0
# sakuras gathered
self.gathered = 0
# player instance
self.player = sprites.Player(self)
# create platforms and other objects
self.platsnobjs()
# run the game
self.run()
def place_player(level):
# Using global variables so the camera & player instances can be altered in the main loop.
global cameraInstance
global playerInstance
x = 0
y = 0
for row in level:
for column in row:
if column == "P":
cameraInstance = Camera(level)
playerInstance = s.Player(x, y, cameraInstance)
x += i.tileWidth
x = 0
y += i.tileHeight
def new(self):
# start a new game
pg.init()
self.score = 0
self.all_sprites = pg.sprite.Group()
self.platforms = pg.sprite.Group()
self.enemy = pg.sprite.Group()
self.player = sprites.Player(self)
self.all_sprites.add(self.player)
for plat in PLATFORM_LIST:
p = sprites.Platform(*plat)
self.all_sprites.add(p)
self.platforms.add(p)
pg.mixer.music.load(os.path.join(self.snd_dir, "ud.ogg"))
self.run()
def start_game(self):
spawn_pos = self.find_spawn_position()
self.player = spr.Player(self, spawn_pos.x, spawn_pos.y)
self.camera = fn.Camera(st.MAP_WIDTH, st.MAP_HEIGHT)
self.grid.manage_blocks_initial()
# quadtree stuff
self.qt_rect = pg.Rect(0, 0, 40 * st.TILESIZE, 60 * st.TILESIZE)
self.started = True
# ------- debugging!
self.player.inventory['dirt'] = 99
self.player.inventory['sand'] = 99
def new(self):
self.snd_background.play()
self.dia = 0
self.all_sprites = pg.sprite.Group()
self.walls = pg.sprite.Group()
self.bed = pg.sprite.Group()
self.beds = []
self.comida = pg.sprite.Group()
self.cordas = []
self.corda = pg.sprite.Group()
self.madeiras = []
self.madeira = pg.sprite.Group()
self.inimigo = pg.sprite.Group()
self.inimigos = []
self.comidas = []
for tile_object in self.map.tmxdata.objects:
if tile_object.name == 'player':
self.player = sprites.Player(self, tile_object.x,
tile_object.y)
if tile_object.name == 'madeira':
self.madeira = sprites.wood(self, tile_object.x, tile_object.y)
self.madeiras.append(self.madeira)
self.all_sprites.add(self.madeira)
if tile_object.name == 'comida':
self.comida = sprites.food(self, tile_object.x, tile_object.y,
4)
self.comidas.append(self.comida)
self.all_sprites.add(self.comida)
if tile_object.name == 'barreira':
self.obstacle = sprites.Obstacle(self, tile_object.x,
tile_object.y,
tile_object.width,
tile_object.height)
if tile_object.name == 'corda':
self.corda = sprites.rope(self, tile_object.x, tile_object.y)
self.cordas.append(self.corda)
self.all_sprites.add(self.corda)
if tile_object.name == 'bed':
self.bed = sprites.Bed(self, tile_object.x, tile_object.y)
self.beds.append(self.bed)
self.all_sprites.add(self.bed)
if tile_object.name == 'vitoria':
self.vitoriax = tile_object.x
self.vitoriay = tile_object.y
self.camera = tilemap.Camera(self.map.width, self.map.height)
def initGame():
# initialize sprites
global all_sprites
global snake
global enemies
global foods
all_sprites = pygame.sprite.Group()
foods = pygame.sprite.Group()
snake = sprites.Player()
all_sprites.add(snake)
food = sprites.Food()
foods.add(food)
all_sprites.add(food)
gameLoop()
def new(self):
# start new game, reset game
self.player = sprites.Player()
self.all_sprites = pygame.sprite.Group()
self.platforms = pygame.sprite.Group()
self.all_sprites.add(self.player)
platform1 = sprites.Platform(0, settings.window_height - 50,
settings.window_width, 40)
self.platforms.add(platform1)
self.all_sprites.add(platform1)
platform2 = sprites.Platform(settings.window_width / 2 - 50,
settings.window_height * 3 / 4, 100, 20)
self.all_sprites.add(platform2)
self.platforms.add(platform2)
game.run()
def initializeSurface(self):
fieldHeight = 40
goalHeight = 100
postHeight = 30
self.player = sprites.Player(self)
self.AI = sprites.AI(self, self.player)
self.ball = sprites.Ball(self)
self.field = sprites.Field(0, HEIGHT - fieldHeight, WIDTH, fieldHeight)
self.gP1 = sprites.Goalpost(0, HEIGHT - fieldHeight - goalHeight,
PLAYER_length * 2, goalHeight)
self.gP2 = sprites.Goalpost(WIDTH - PLAYER_length * 2,
HEIGHT - fieldHeight - goalHeight,
PLAYER_length * 2, goalHeight)
# self.gPframe1 = sprites.Wall(0, HEIGHT-fieldHeight-goalHeight-postHeight, PLAYER_length*5,postHeight)
# self.gPframe2 = sprites.Wall(WIDTH-PLAYER_length*5,HEIGHT-fieldHeight-goalHeight-postHeight,PLAYER_length*5,postHeight)
self.wall1 = sprites.Wall(0, -10000, PLAYER_length * 3 + 10,
HEIGHT - 140 + 10000)
self.wall2 = sprites.Wall(WIDTH - PLAYER_length * 3 - 10, -10000,
PLAYER_length * 3 + 10, HEIGHT - 140 + 10000)
def new(self, genomes, config):
self.all_sprites = pygame.sprite.LayeredUpdates()
# self.all_sprites = pygame.sprite.Group()
self.birds = pygame.sprite.Group()
self.mobs = pygame.sprite.Group()
self.pipes = pygame.sprite.Group()
self.bird_pool = {}
self.nets = {}
for genome_id, genome in genomes:
genome.fitness = 0
self.bird_pool[genome_id] = sprites.Player(self)
self.nets[genome_id] = FeedForwardNetwork.create(genome, config)
# self.player = sprites.Player(self)
self.pipes_pool = [
sprites.PipePair(self, WIDTH / 2),
sprites.PipePair(self, WIDTH + 50)
]
self.pipe_gen_time = pygame.time.get_ticks()
self.base_pool = [sprites.Base(self, 0), sprites.Base(self, 336)]
def __init__(self):
pygame.mixer.init()
pygame.init()
pygame.mixer.music.load(f'data/{CHARSET}_theme.wav')
pygame.mixer.music.play(-1)
self.fullscreen = False
self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("RPG Arena Pro: Rebirth")
pygame.display.set_icon(sprites.load_image(CHARSET + '_icon.png'))
self.clock = pygame.time.Clock()
self.lvl = 0
self.end = ''
self.bg_color = (105, random.randrange(150, 255, 15), 105)
self.all_sprites = pygame.sprite.Group()
self.player = sprites.Player(self)
self.loots = pygame.sprite.Group()
self.enemies = pygame.sprite.Group()
self.texts = ['You woke up.']
self.running = True
self.run()
def new(self):
#initialise game e.g. starting a new game
self.Score = -1
#initialise bg music
pygame.mixer.music.load(BG_MUSIC)
pygame.mixer.music.set_volume(0.5)
pygame.mixer.music.play(-1)
#initilise sprites
self.all_sprites = pygame.sprite.Group()
self.platform_sprites = pygame.sprite.Group()
self.player = sprites.Player(self)
self.all_sprites.add(self.player)
self.all_sprites.add(self.player.headBand)
for plat in PLATFORM_LIST:
p = Platform(*plat, self.pTile)
self.platform_sprites.add(p)
self.all_sprites.add(p)
self.run()
def new(self):
# start a new game
# initialise sprite groups
self.all_sprites = pg.sprite.LayeredUpdates()
self.walls = pg.sprite.Group()
# instantiate objects
# MEMO: GET RID OF THIS ROOM NUMBER AND USE THE INDEX INSTEAD!
self.dungeon = rooms.Dungeon(self, st.DUNGEON_SIZE)
self.room_number = self.dungeon.room_map[self.dungeon.room_index[0]][
self.dungeon.room_index[1]]
# pick a random tileset from all available tilesets
self.tileset = choice(self.tileset_list)
# create a background image from the tileset for the current room
self.background = fn.tileRoom(self, self.tileset, self.dungeon.room_index)
# spawn the player in the middle of the screen/room
self.player = spr.Player(self, (st.WIDTH // 2, st.HEIGHT // 2))
# spawn the wall objects (invisible)
self.walls = fn.transitRoom(self, self.walls, self.dungeon,
self.room_number)
self.run()
