def parse(self, data):
"""
Parses chapter from JS-like object.
"""
self.__levels = list(
Level.Level(self.__client, self, data["levels"][i]["id"],
data["levels"][i]["hash"])
for i in range(len(data["levels"])))
self.__bonus = list()
if "bonus_level" in data:
self.__bonus.append(
Level.Level(self.__client, self, data["bonus_level"]["id"],
data["bonus_level"]["hash"], True))
def __init__(self):
level1 = Level(3, 1, 11)
level1.setCote([2, 1, 0.5])
self.levels.append(level1)
self.nbLevel += 1
level2 = Level(5, 1, 20)
level2.setCote([2, 1, 0.75, 0.5, 0.25])
self.levels.append(level2)
self.nbLevel += 1
level3 = Level(7, 1, 30)
level3.setCote([2.5, 2, 1.5, 1, 0.75, 0.5, 0.25])
self.levels.append(level3)
self.nbLevel += 1
def OnSaveClick(self, event):
lvl = Level.Level()
lvl.setLevelNumber(1)
lvl.setLevelName("First Level")
lvl.setLevelHeight(self.staticBitmap.GetSize()[1] * 2)
for shape in sorted(self.staticBitmap.shapes,
key=lambda x:
(self.staticBitmap.GetSize()[1] * 2) -
(x.pos[1] * 2)):
if shape.spriteType == 1:
#enemy
newEnemy = Level.Enemy()
newEnemy.globalYPos = (self.staticBitmap.GetSize()[1] *
2) - (shape.pos[1] * 2)
newEnemy.xPos = shape.pos[0] * 2
newEnemy.type = shape.spriteSubType
lvl.addEnemy(newEnemy)
elif shape.spriteType == 2:
newEnv = Level.EnviornmentImage()
newEnv.globalYPos = (self.staticBitmap.GetSize()[1] *
2) - (shape.pos[1] * 2)
newEnv.xPos = shape.pos[0] * 2
newEnv.type = shape.spriteSubType
newEnv.movementY = 1
lvl.addImage(newEnv)
lvl.writeLevelData()
def __init__(self, kernel, gsm, levelName):
GameState.__init__(self, "Editor", kernel, gsm)
self.mLevelName = levelName
self.mLevel = Level(kernel, 650)
self.mEntityBox = pygame.Rect(650, 0, 150, 600)
self.mCurrentEntity = None
self.mGhostEntity = None
self.mSelectedEntity = None
self.mEntitySelects = []
self.mAvailableEntities = [
"Bee",
"Box",
"RedCap",
"BlueCap",
"GoldCap",
"Hive"
]
self.mSaveLevelImage, self.mSaveLevelRect = kernel.ImageManager().LoadImage("saveLevel.bmp", False)
self.mSaveLevelRect.topleft = (725 - (self.mSaveLevelRect.width / 2), 570)
self.mMainMenuImage, self.mMainMenuRect = kernel.ImageManager().LoadImage("mainmenu_ed.bmp", False)
self.mMainMenuRect.topleft = (725 - (self.mSaveLevelRect.width / 2), 540)
self.mGroundLevel = 570
self.mScrollDirection = 0
self.mFont = pygame.font.SysFont("Helvetica", 16, True)
def __init__(self):
self.window_width = 800
self.window_height = 600
self.window = pygame.display.set_mode(
(self.window_width, self.window_height))
self.running = True
self.top_color = (255, 225, 200)
self.bottom_color = (50, 0, 50)
self.clock = pygame.time.Clock()
self.audio_manager = AudioManager.AudioManager()
self.part_sys = ParticleSystem.ParticleSystem(self.top_color,
self.bottom_color)
self.top_player = Player.Player(self.window_width // 2 - 12, -50,
self.part_sys, self.audio_manager)
self.bottom_player = Player.Player(self.window_width // 2 - 12,
self.window_height, self.part_sys,
self.audio_manager)
self.immovable_num = 3
self.level_num = -1
self.max_level_num = 5
self.level = Level.Level()
self.camera = Camera.Camera(self.window)
self.game_state = GameState.MENU
self.credits = Credits.Credits(self.window_width, self.window_height,
self.top_color)
self.menu = Menu.Menu(self.window_width, self.window_height,
self.bottom_color, self.top_color)
self.next_state = None
self.transitioning = False
self.animator = Animator.Animator()
pygame.display.set_caption("Laws of Reflection")
self.bottom_player.inverse()
self.next_level()
def __init__(self,
playerProperties,
menu,
level,
sound,
sizeX=1920,
sizeY=1020,
settings=None):
#pygame.init()
pygame.display.set_caption("Space Battle")
loading = MapElement(0, 0, sizeX, sizeY, "loading.jpg")
surf = loading.draw()
menu.getScreen().blit(surf, (0, 0))
pygame.display.flip()
#time.sleep(1)
self.sounds = sound
self.runG = False
self.menu = menu
self.score = None
self.level = Level(playerProperties,
sizeX,
sizeY,
self,
menu.screen,
level,
settings=settings,
sounds=self.sounds)
def loadLevels(self):
# Container for all levels
levels = []
levelNr = 0
# Trying to read levels-file
try:
file = open('levels', mode='r')
# Reading lines in file/levels
for line in file:
# Not adding comments
if (line[:1] != '#'):
# Splitting line by whitespaces
settings = line.split()
# Only creating level by valid settings
if (len(settings) == 4):
try:
scale = float(settings[0])
balls = int(settings[1])
multiballs = int(settings[2])
pulses = int(settings[3])
levelNr += 1
# Adding to list
levels.append(
Level.Level(scale, balls, multiballs, pulses,
levelNr))
except ValueError:
pass
# Return all levels; error if no levels
if (len(levels) > 0):
return levels
else:
exit('Level error!')
except IOError:
exit('Level error!')
def main():
current_level = Level(images, Player)
Player.next_level(current_level)
while True:
clock.tick(60)
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
sys.exit()
if event.key == K_LEFT:
Player.move_x(-32)
if event.key == K_RIGHT:
Player.move_x(+32)
if event.key == K_UP:
Player.move_y(-32)
if event.key == K_DOWN:
Player.move_y(+32)
screen.fill((0, 0, 0))
current_level.update()
current_level.draw(screen)
pygame.display.flip()
def resetGame(self):
self.player = Player((Globals.window.screen_size[0] / 2, Globals.window.screen_size[1]))
self.level = Level(self)
self.score = 0
self.smooth_score = 0
self.all_sprites = pygame.sprite.Group()
self.all_sprites.add(self.player)
self.enemies = pygame.sprite.Group()
self.background = pygame.sprite.Group()
self.foreground = pygame.sprite.Group()
self.effects = pygame.sprite.Group()
self.powerups = pygame.sprite.Group()
self.enemy_bullets = pygame.sprite.Group()
self.player_bullets = pygame.sprite.Group()
# GUI
self.gui = pygame.sprite.Group()
self.hp_bar = GuiBar(pygame.Rect(5, 5, 128, 16))
self.score_text = GuiText(position=(5, 16+5+5), font_size=16)
self.gui.add(self.hp_bar)
self.gui.add(self.score_text)
self.level.Start()
def LoadLevel(self, levelName):
self.mLevel = Level(self.mKernel)
self.mLevel.Load(levelName)
self.mRects = self.mLevel.mCollisionRects
return
def Initialize(self):
self.mLevel = Level(self.mKernel, 800)
self.mLevel.LoadLevel("MainMenu.lvl")
startHeight = 300
offset = 75
count = 0
self.mHeading, self.mHeadingRect = self.mKernel.ImageManager().LoadImage("heading.bmp")
self.mHeadingRect.topleft = (400 - self.mHeadingRect.width / 2, 50)
self.mMenuImages["LevelSelect"], self.mMenuRects["LevelSelect"] = self.mKernel.ImageManager().LoadImage("newgame.bmp")
self.mMenuRects["LevelSelect"].topleft = (400 - self.mMenuRects["LevelSelect"].width / 2, startHeight + offset * count)
self.mMenuItems["LevelSelect"] = self.mMenuImages["LevelSelect"]
count += 1
self.mMenuImages["Tutorial"], self.mMenuRects["Tutorial"] = self.mKernel.ImageManager().LoadImage("tutorial.bmp")
self.mMenuRects["Tutorial"].topleft = (400 - self.mMenuRects["Tutorial"].width / 2, startHeight + offset * count)
self.mMenuItems["Tutorial"] = self.mMenuImages["Tutorial"]
count += 1
self.mMenuImages["EditorMenu"], self.mMenuRects["EditorMenu"] = self.mKernel.ImageManager().LoadImage("editor.bmp")
self.mMenuRects["EditorMenu"].topleft = (780 - self.mMenuRects["EditorMenu"].width, 550)
self.mMenuItems["EditorMenu"] = self.mMenuImages["EditorMenu"]
self.mMenuImages["HighScores"], self.mMenuRects["HighScores"] = self.mKernel.ImageManager().LoadImage("highscore_small.bmp")
self.mMenuRects["HighScores"].topleft = (20, 550)
self.mMenuItems["HighScores"] = self.mMenuImages["HighScores"]
self.mMenuImages["Exit"], self.mMenuRects["Exit"] = self.mKernel.ImageManager().LoadImage("exit.bmp")
self.mMenuRects["Exit"].topleft = (400 - self.mMenuRects["Exit"].width / 2, startHeight + offset * count)
self.mMenuItems["Exit"] = self.mMenuImages["Exit"]
count += 1
GS_MenuBase.Initialize(self)
def loadNewLevel(self, message):
'''load a level that the server said to load'''
''' pull the string out for the level '''
levelString = message[1][0]
''' load the model for the level'''
self.level = Level.Level(levelString)
self.level.getRoot().reparentTo(render)
def load_level_from_file(self, file_path):
data = json.loads(open(file_path).read())
self.current_level_file_path = file_path
self.frame_count = -1
# Background tiles
for index, layer in enumerate(data["bg_tile_layers"]):
for tile_key, tile_value in layer.items():
if tile_key != "name" and tile_value != False and "img" in tile_value:
decoded_img = self.code_to_img(tile_value["img"],
data["tile_codes"])
tile_value["img"] = decoded_img
self.add_image("images/" + tile_value["img"], alpha=True)
# Objects
for ob in data["obs"]:
decoded_type = self.code_to_img(ob["type"], data["ob_type_codes"])
ob["type"] = decoded_type
self.add_ob(globals()[ob["type"]](ob["values"]))
# Foreground tiles
for layer in data["fg_tile_layers"]:
for tile_key, tile_value in layer.items():
if tile_key != "name" and tile_value != False and "img" in tile_value:
decoded_img = self.code_to_img(tile_value["img"],
data["tile_codes"])
tile_value["img"] = decoded_img
self.add_image("images/" + tile_value["img"], alpha=True)
self.current_level = Level(data)
self.level_width = self.current_level.w * self.current_level.tile_w
self.level_height = self.current_level.h * self.current_level.tile_h
def start(surface, hasLog=False, notBeginning=False):
global running, dest_x, dest_y
running = True
background = Level.Level(
pygame.image.load(os.path.join("images", "forest_1.jpg")))
player = Sprite.Sprite(
pygame.image.load(os.path.join("images", "frank.png")))
fire = Sprite.Sprite(pygame.image.load(os.path.join("images", "fire.gif")))
cursor = POINT
TEXT = ""
isEnd = False
initializeSprites(player, fire)
addObjects(background)
if (notBeginning):
player_x, player_y = 647, 640
dest_x, dest_y = 647, 720
else:
player_x, player_y = 1050, 900
fire_thread = threading.Thread(target=changeFire, args=(fire, ))
frank_thread = threading.Thread(target=changeFrank, args=(player, ))
fire_thread.start()
frank_thread.start()
while (running):
m_x, m_y = pygame.mouse.get_pos()
handleEvents((m_x, m_y))
player_x, player_y = move(player_x, player_y, player, background)
if (background.doors["door"].collidepoint((m_x, m_y))):
cursor = ARROW
elif (background.grabs["fire"].collidepoint((m_x, m_y))):
cursor = GRAB
TEXT = "\"...I was in the greatest fear lest my fire should be extinguished.\""
else:
cursor = POINT
TEXT = ""
p_rect = pygame.Rect(player_x, player_y, player.width, player.height)
if (hasLog and p_rect.colliderect(background.grabs["fire"])
and background.grabs["fire"].collidepoint((dest_x, dest_y))):
fire.setY(100)
end_thread = threading.Thread(target=end)
end_thread.start()
if (p_rect.colliderect(background.doors["door"])
and background.doors["door"].collidepoint((dest_x, dest_y))):
running = False
return False
bottom_text = smallFont(TEXT, (255, 255, 255))
surface.blit(background.image, (0, 0))
if (player_y + player.height - player.y <= 825 + fire.height):
surface.blit(player.image, (player_x, player_y), (player.crop()))
surface.blit(fire.image, (300, 825), (fire.crop()))
else:
surface.blit(fire.image, (300, 825), (fire.crop()))
surface.blit(player.image, (player_x, player_y), (player.crop()))
surface.blit(bottom_text, ((1280 - bottom_text.get_width()),
(960 - bottom_text.get_height())))
surface.blit(cursor, (m_x + (cursor.get_width() / 2), m_y +
(cursor.get_height() / 2)))
pygame.display.flip()
return True
def setFirstLevel(self):
level_1 = Level.Level(4500, 1000, 0, 800)
level_1.platformsSet = platformsSets.PlatformSet1(self.character)
level_1.starsSet = starsSets.StarsSet1(self.character)
level_1.enemiesSet = enemiesSets.EnemiesSet1(self.character, level_1)
level_1.levelExit = levelExit.LevelExit(4185, 887)
level_1.nextLevelEntrance = nextLevelEntrance.NextLevelEntrance(
3600, 567)
return level_1
def setSecondLevel(self):
level_2 = Level.Level(5900, 1000, 0, 800)
level_2.platformsSet = platformsSets.PlatformSet2(self.character)
level_2.starsSet = starsSets.StarsSet2(self.character)
level_2.lifeSet = lifeSet.LifeSet2(self.character)
level_2.enemiesSet = enemiesSets.EnemiesSet2(self.character, level_2)
level_2.levelExit = levelExit.LevelExit(5585, 887)
level_2.levelExitCastle = levelExitCastle.LevelExitCastle(5400, 578)
return level_2
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
self.clock = pygame.time.Clock()
self.level = Level.Level()
self.cam = Camera.Camera(12.0, 2.250, 1, 0, 0.0, -0.66, self.level,
self.screen)
self.renderer = Screen.RenderScreen(self.level, self.cam)
self.running = True
pass
def newLevel(self):
dlg = DlgNewLevel(self)
code = dlg.exec()
if code == 1: # "Ok" has been pressed
level = Level.Level(dlg.GetName(), (0, 0),
(dlg.GetValueWidth(), dlg.GetValueHeight()))
self.controller.AddLevel(level)
self.rootItem.setExpanded(True)
self.displayMapArea.SetSelectedLevel(level)
self.displayMapArea.Update()
def main():
""" Our main function is going to do lots of setup from the setup module,
it will setup the level size and name, then pygame display information,
then it will draw everything to the screen and start the "game" loop.
"""
level_width, level_height = setup_level_size()
level_name = setup_level_name()
editor_screen = setup_pygame_display()
background = setup_background(editor_screen.get_size())
level = Level.Level(width=level_width, height=level_height)
level_editor = Editor.Editor(level)
# Editor draw position will be the center of the screen
level_editor.set_draw_pos(
background.get_width() / 2 -
level_editor.editor_surface.get_width() / 2,
background.get_height() / 2 -
level_editor.editor_surface.get_height() / 2)
background.blit(level_editor.editor_surface, level_editor.get_draw_pos())
editor_screen.blit(background, (0, 0))
# Main "game" loop, it handles input and renders the editor(as well as any changes that occur)
while level_editor.running:
for event in pygame.event.get():
if event.type == pygame.VIDEORESIZE:
editor_screen = setup_pygame_display(event.dict['size'])
background = setup_background(editor_screen.get_size())
level_editor.set_draw_pos(
background.get_width() / 2 -
level_editor.editor_surface.get_width() / 2,
background.get_height() / 2 -
level_editor.editor_surface.get_height() / 2)
elif event.type == pygame.QUIT:
level_editor.save_level(level_name)
level_editor.close()
else:
level_editor.handle_event(event)
level_editor.render()
background.blit(level_editor.editor_surface,
level_editor.get_draw_pos())
editor_screen.blit(background, (0, 0))
pygame.display.flip()
# Exit when we leave the main loop
sys.exit()
def __init__(self, game):
super(HighScoreScene, self).__init__(game)
self.__level = Level(game)
self.__level.load_highscores()
self.__balls = [
Ball((GameConstants.SCREEN_SIZE[0] * random.random(),
GameConstants.SCREEN_SIZE[1] * random.random()),
pygame.image.load(GameConstants.SPRITE_BALL), game),
Ball((GameConstants.SCREEN_SIZE[0] * random.random(),
GameConstants.SCREEN_SIZE[1] * random.random()),
pygame.image.load(GameConstants.SPRITE_BALL), game)
]
def __init__(self):
self.__lives = GameConstants.LIVES
self.__score = 0
self.__level = Level(self)
self.__level.load(0)
# self.__level.load_random()
self.__pad = Pad(
(GameConstants.SCREEN_SIZE[0] / 2 - GameConstants.PAD_SIZE[0] / 2,
GameConstants.SCREEN_SIZE[1] * 9 / 10),
pygame.image.load(GameConstants.SPRITE_PAD))
self.__balls = [
Ball((GameConstants.SCREEN_SIZE[0] / 2,
GameConstants.SCREEN_SIZE[1] * 2 / 3),
pygame.image.load(GameConstants.SPRITE_BALL), self)
]
pygame.init()
pygame.mixer.init()
pygame.display.set_caption("Breakout!")
self.__clock = pygame.time.Clock()
self.screen = pygame.display.set_mode(GameConstants.SCREEN_SIZE,
pygame.DOUBLEBUF,
32) #| pygame.FULLSCREEN, 32)
pygame.mouse.set_visible(False)
self.__scenes = [
PlayingGameScene(self),
GameOverScene(self),
HighScoreScene(self),
MenuScene(self)
]
self.__current_scene = GameConstants.MENU_SCENE
self.__sounds = (
pygame.mixer.Sound(GameConstants.SOUND_FILE_GAME_OVER),
pygame.mixer.Sound(GameConstants.SOUND_FILE_HIT_BRICK),
pygame.mixer.Sound(GameConstants.SOUND_FILE_HIT_BRICK_LIFE),
pygame.mixer.Sound(GameConstants.SOUND_FILE_HIT_BRICK_SPEED),
pygame.mixer.Sound(GameConstants.SOUND_FILE_HIT_WALL),
pygame.mixer.Sound(GameConstants.SOUND_FILE_HIT_PAD),
pygame.mixer.Sound(GameConstants.SOUND_FILE_NEW_GAME),
pygame.mixer.Sound(GameConstants.SOUND_FILE_NEXT_LEVEL),
pygame.mixer.Sound(GameConstants.SOUND_FILE_YOU_DIE),
pygame.mixer.Sound(GameConstants.SOUND_FILE_HIGH_SCORES),
pygame.mixer.Sound(GameConstants.SOUND_FILE_BREAKOUT),
pygame.mixer.Sound(GameConstants.SOUND_FILE_HIT_BRICK_BALL),
pygame.mixer.Sound(GameConstants.SOUND_FILE_MENU))
print(GameConstants.SCREEN_SIZE)
def getAllLevels(self):
'''
Returns a list of Levels in this game
'''
levels = []
for path in os.listdir(self.getLevelsDir()):
level = Level(path, self)
levels.append(level)
levels.sort()
return levels
def update(self):
if not self.curLevel or self.curLevel.dlvl != Kernel.instance.Dungeon.dlvl:
result = [level for level in self.levels if level.dlvl == Kernel.instance.Dungeon.dlvl]
if len(result) > 1:
Kernel.instance.die("Found several levels with current dlvl in same branch: %s. This shouldn't happen before I reach mines" % str(result))
if result:
self.curLevel = result[0]
else:
self.levels.append(Level(Kernel.instance.Dungeon.dlvl))
self.curLevel = self.levels[-1]
self.curLevel.update()
def mainLoop():
pygame.init()
init()
initHUD()
clock = pygame.time.Clock()
Indicator.HUDs["computer"].changeText(0)
Indicator.HUDs["player"].changeText(0)
bg = pygame.Surface(conf.resolution)
bg.fill(pygame.Color(conf.backGroundColor))
gameField = pygame.Surface((conf.resolution[0] - conf.gameFieldOffset[0],
conf.resolution[1] - conf.gameFieldOffset[1]))
gameField.fill(pygame.Color(Level.enumColor.fieldBackgroundColor))
lvl = Level.Level(gameField, conf.N)
logic = GameLogic.gameLogic(lvl)
machine = Player.MachinePlayer("base", lvl)
while True:
# event block
for e in pygame.event.get():
if e.type == pygame.QUIT:
sys.exit(0)
if e.type == pygame.MOUSEBUTTONDOWN:
if logic.activePlayer[0] == GameLogic.enumControlType.human:
pos = pygame.mouse.get_pos()
relativePos = (pos[0] - conf.gameFieldOffset[0],
pos[1] - conf.gameFieldOffset[1])
move = lvl.transformMousePosToCells(relativePos)
logic.makeMove(move)
# update block
Indicator.HUDs["move"].changeText(*logic.getInfo())
for key in logic.state["score"]:
Indicator.HUDs[key].changeText(logic.state["score"][key])
if logic.activePlayer[0] == GameLogic.enumControlType.machine:
move = machine.makeMove(logic.state["moves"])
logic.makeMove(move)
if logic.exitState[0]:
if logic.exitState[1] == GameLogic.enumPlayers.player2[1]:
machine.flushHistory()
machine.close()
return logic.exitState[1]
# show block
conf.screen.blit(bg, (0, 0))
conf.screen.blit(gameField, conf.gameFieldOffset)
lvl.drawLevel()
for hud in Indicator.HUDs.values():
hud.show()
pygame.display.update()
clock.tick(100)
def new_level(self):
self.print_log('SYSTEM', "generating level")
self.level = Level.Level()
self.level.set_tileset(self.tileset)
while not self.level.generate_level(2, 5, 18, 11, 6):
print 'retrying level generation'
self.set_game_window(self.game_w)
#self.print_log('GAME','press [enter] to start playing')
self.set_state(6)
self.launch_level()
def __init__(self, sense):
"""
Initialize the game world
:param sense The sense hat
"""
self.level = Level()
self.score = Score()
self.mappy = Map(0, 7)
self.snake = Snake(3, self.mappy)
self.candy = Candy(self.snake)
self.sense = sense
self.i = 0
print(self.snake)
self.sense.clear()
self.sense.show_message("Level: " + str(self.level.level),
text_colour=[180, 180, 180])
def setup(self):
curr_file = open(self.file_path, "r")
# Reads lines from LevelXX
for line in curr_file:
self.level_storage.append(line.strip())
# Close the file when finished
curr_file.close()
# Build Objects
self.buildGameWorld()
# Build Level
self.curr_level = Level(self.wall_list, self.entity_list)
return self.curr_level
def __init__(self, level, screen):
self.level = Level(level)
self.walls = WallController()
self.balls = []
self.balls.append(BallController())
self.bat = BatController()
self.balls[0].stickTo(self.bat)
self.screen = screen
self.allSpriteList = None
self.refreshAllSpriteList()
self.initWalls()
self.bat.setWalls(self.walls)
self.lives = 3
self.won = False
def handleEvent(self, event):
result = self.handler.handleEvent(event)
if (result == "UP"):
self.selectedUp()
elif (result == "DOWN"):
self.selectedDown()
elif (result == "ENTER"):
# Game
self.game.getCurrStateMgr().changeState(Level(self.game))
# Settings
# Quit
if (self.selected == 2):
self.game.getCurrStateMgr().changeState(None)
def loadNewLev(direction, levx, levy):
if direction == "up":
if levy >1:
levy-=1
elif direction == "down":
if levy <3:
levy+=1
elif direction == "left":
if levx >1:
levx-=1
elif direction == "right":
if levx <3:
levx+=1
for s in all.sprites():
s.kill()
levFile = "Levels/map" + str(levLayer) + str(levy) + str(levx)
level=Level(levFile)
return levx, levy
