def event_handler():
for event in pygame.event.get():
if event.type == QUIT:
Tools.OnExit()
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
Tools.OnExit()
if event.key == K_r:
# RàZ du jeu
Tools.GameInit()
if event.key == K_SPACE:
Config.Sounds['intro'].stop()
Config.Sounds['intro-2'].play()
# on lance les balles
Ball.Ballsmoving()
if Config.player.laserMode:
Config.player.laserFire()
if event.key == K_LEFT:
Config.player.moveLeft()
if event.key == K_RIGHT:
Config.player.moveRight()
if (event.key == K_PLUS
or event.key == K_KP_PLUS) and Config.godMode:
# cheat code, on change de niveau
Tools.NextLevel()
if (event.key == K_MINUS
or event.key == K_KP_MINUS) and Config.godMode:
# cheat code, on change de niveau
if Config.level > 1:
Config.level -= 1
else:
# on boucle
Config.level = Config.maxlevel
Level.LoadLevel(Config.level)
if Config.bossLevel:
# niveau d'un boss
Boss.doBossLevel()
else:
Tools.InitBG()
Bonus.initBonus()
Config.player.reset()
Ball.Ballsreset()
elif event.type == KEYUP:
if event.key == K_LEFT or event.key == K_RIGHT:
Config.player.state = "still"
elif event.type == USEREVENT:
# MàJ des fps toutes les secondes
pygame.display.set_caption(
Config.titre +
' (fps: {0:.0f})'.format(Config.clock.get_fps()))
elif event.type == (USEREVENT + 1):
# génération d'ennemis (toutes les 10s)
if not Config.Perdu and not Level.FinishedLevel():
Enemys.randomGen()
elif event.type == (USEREVENT + 2):
# génération des bombes et missiles du boss (déclenché toutes les 5s)
if Config.bossLevel:
Config.boss.attack()
def GameInit():
Config.Perdu = False
Config.life = Config.maxlife
Config.score = 0
Config.level = 1
Config.bossLevel = False
Bonus.initBonus()
Config.player.reset()
Ball.BallInit()
Level.LoadLevel(Config.level)
def NextLevel():
if not Config.testMode:
Config.level += 1
if Config.level > Config.maxlevel:
# on boucle
Config.level = 1
Level.LoadLevel(Config.level)
if Config.bossLevel:
# niveau d'un boss
Boss.doBossLevel()
else:
InitBG()
Bonus.initBonus()
Config.player.reset()
Ball.BallInit()
class GS_Editor(GameState):
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 Initialize(self):
self.mLevel.LoadLevel(self.mLevelName)
currentHeight = 10
for i in range(len(self.mAvailableEntities)):
module = __import__(self.mAvailableEntities[i])
_EntityClass = getattr(module, self.mAvailableEntities[i])
# Hacky passing in self.mKernel, but since it has Display surface, it works
entity = _EntityClass(self.mKernel, self.mKernel)
entity.SetPosition([ 725 - (entity.Rect().width / 2), currentHeight])
currentHeight += entity.Rect().height + 10
self.mEntitySelects.append(entity)
return GameState.Initialize(self)
def Destroy(self):
return GameState.Destroy(self)
def Pause(self):
return GameState.Pause(self)
def Unpause(self):
return GameState.Unpause(self)
def HandleEvent(self, event):
if (event.type == QUIT):
pygame.quit()
sys.exit()
elif (event.type == MOUSEBUTTONDOWN):
if (self.mEntityBox.collidepoint(event.pos)):
if (self.mSaveLevelRect.collidepoint(event.pos)):
self.mLevel.SaveLevel(self.mLevelName)
elif (self.mMainMenuRect.collidepoint(event.pos)):
self.mGameStateManager.SwitchState("MainMenu")
else:
for entity in self.mEntitySelects:
if (entity.Rect().collidepoint(event.pos)):
self.mSelectedEntity = entity
classname = self.mSelectedEntity.__class__.__name__
module = __import__(classname)
_Entity = getattr(module, classname)
self.mGhostEntity = _Entity(self.mKernel, self.mKernel)
self.mGhostEntity.SetPosition(list(event.pos))
return
self.mGhostEntity = None
self.mSelectedEntity = None
else:
if (self.mSelectedEntity):
classname = self.mSelectedEntity.__class__.__name__
module = __import__(classname)
_Entity = getattr(module, classname)
newEntity = _Entity(self.mKernel, self.mLevel)
self.mLevel.AddEntity(newEntity, self.mLevel.ScreenToLevelCoordinates(event.pos))
self.mLevel.CalcMaxScore()
elif (self.mCurrentEntity):
self.mCurrentEntity.SetPosition(list(self.mLevel.ScreenToLevelCoordinates(event.pos)))
self.mCurrentEntity = None
else:
self.mGhostEntity = None
self.mCurrentEntity = self.mLevel.EntityAt(event.pos)
elif (event.type == MOUSEMOTION):
if (self.mCurrentEntity and event.pos[0] < 576 and event.pos[0] > 0):
self.mCurrentEntity.SetPosition(list(self.mLevel.ScreenToLevelCoordinates(event.pos)))
elif (self.mSelectedEntity and event.pos[0] < 576 and event.pos[0] > 0):
if (not self.mGhostEntity):
classname = self.mSelectedEntity.__class__.__name__
module = __import__(classname)
_Entity = getattr(module, classname)
self.mGhostEntity = _Entity(self.mKernel, self.mKernel)
self.mGhostEntity.SetPosition(list(event.pos))
elif (event.type == KEYDOWN):
if (event.key == K_a):
self.mScrollDirection = -4
elif (event.key == K_d):
self.mScrollDirection = 4
elif (event.key == K_BACKSPACE and self.mCurrentEntity):
self.mLevel.RemoveEntity(self.mCurrentEntity)
self.mCurrentEntity = None
self.mLevel.CalcMaxScore()
elif (event.type == KEYUP):
if (event.key == K_a or event.key == K_d):
self.mScrollDirection = 0
return GameState.HandleEvent(self, event)
def Update(self, delta):
# Don't animate things
#self.mLevel.Update(delta)
self.mLevel.Scroll(self.mScrollDirection)
self.mLevel.Draw()
if (self.mCurrentEntity):
pygame.draw.rect(self.mLevel.DisplaySurface(), Colors.GREEN, self.mCurrentEntity.Rect(), 2)
self.mLevel.Blit()
if (self.mGhostEntity):
self.mGhostEntity.Draw()
pygame.draw.rect(self.mKernel.DisplaySurface(), Colors.RED, self.mGhostEntity.Rect(), 2)
pygame.draw.line(self.mKernel.DisplaySurface(), Colors.BLUE, (0, self.mGroundLevel), (800, self.mGroundLevel), 4)
pygame.draw.line(self.mKernel.DisplaySurface(), Colors.RED, (self.mLevel.mLevelLength - 1500 - self.mLevel.mCameraX, 0), (self.mLevel.mLevelLength - 1500 - self.mLevel.mCameraX, 600), 4)
pygame.draw.rect(self.mKernel.DisplaySurface(), Colors.LIGHT_GREY, self.mEntityBox)
for entity in self.mEntitySelects:
entity.Draw()
if (self.mSelectedEntity):
selectedRect = self.mSelectedEntity.Rect()
pygame.draw.rect(self.mKernel.DisplaySurface(), Colors.RED, self.mSelectedEntity.Rect(), 2)
self.mKernel.DisplaySurface().blit(self.mMainMenuImage, self.mMainMenuRect)
self.mKernel.DisplaySurface().blit(self.mSaveLevelImage, self.mSaveLevelRect)
textSurface = self.mFont.render("Max Score: " + str(self.mLevel.mMaxScore), True, Colors.WHITE)
self.mKernel.DisplaySurface().blit(textSurface, (40, 580, textSurface.get_rect().width, textSurface.get_rect().height))
return GameState.Update(self, delta)
class GS_EditorMenu(GS_MenuBase):
def __init__(self, kernel, gsm):
GS_MenuBase.__init__(self, "EditorMenu", kernel, gsm)
def Initialize(self):
self.mLevel = Level(self.mKernel, 800)
self.mLevel.LoadLevel("MainMenu.lvl")
self.mFont = pygame.font.SysFont('Arial', 24, True)
path = os.path.join("data", "levels")
filecount = 0
maxLevelNum = 0
for filename in os.listdir(path):
if ("lvl" in filename):
self.mMenuImages["Edit_" + filename] = self.mFont.render(
"Edit " + filename, True, Colors.WHITE)
self.mMenuRects["Edit_" + filename] = self.mMenuImages[
"Edit_" + filename].get_rect()
self.mMenuRects["Edit_" + filename].topleft = (100, 100 +
35 * filecount)
filecount += 1
if ("Level" in filename):
maxLevelNum = max(maxLevelNum, int(filename[5]) + 1)
self.mMenuImages["Edit_Level" + str(maxLevelNum) +
".lvl"] = self.mFont.render(
"New Level: Level" + str(maxLevelNum) + ".lvl",
True, Colors.WHITE)
self.mMenuRects["Edit_Level" + str(maxLevelNum) +
".lvl"] = self.mMenuImages["Edit_Level" +
str(maxLevelNum) +
".lvl"].get_rect()
self.mMenuRects["Edit_Level" + str(maxLevelNum) +
".lvl"].topleft = (100, 55)
self.mMenuImages["MainMenu"], self.mMenuRects[
"MainMenu"] = self.mKernel.ImageManager().LoadImage("mainmenu.bmp")
self.mMenuRects["MainMenu"].topleft = (
780 - self.mMenuRects["MainMenu"].width, 500)
GS_MenuBase.Initialize(self)
def HandleEvent(self, event):
if event.type == MOUSEBUTTONDOWN:
for item in self.mMenuRects:
if ("Edit_" in item
and self.mMenuRects[item].collidepoint(event.pos)):
levelName = item.split("_")[1]
if (self.mGameStateManager.GetState("Editor")):
self.mGameStateManager.DeregisterState("Editor")
self.mGameStateManager.RegisterState(
GS_Editor(self.mKernel, self.mGameStateManager,
levelName))
self.mGameStateManager.SwitchState("Editor")
return
GS_MenuBase.HandleEvent(self, event)
def Pause(self):
self.Destroy()
def Update(self, delta):
GS_MenuBase.Update(self, delta)
class GS_MainMenu(GS_MenuBase):
def __init__(self, kernel, gsm):
GS_MenuBase.__init__(self, "MainMenu", kernel, gsm)
kernel.ImageManager().LoadImage("resume.bmp")
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 Unpause(self):
if "Game" not in self.mMenuImages and self.mGameStateManager.GetState("Game").IsInitialized():
self.mMenuImages["Game"], self.mMenuRects["Game"] = self.mKernel.ImageManager().LoadImage("resume.bmp")
self.mMenuRects["Game"].topleft = (400 - self.mMenuRects["Game"].width / 2, 225)
self.mMenuItems["Game"] = self.mMenuImages["Game"]
GS_MenuBase.Unpause(self)
def HandleEvent(self, event):
# if (event.type == MOUSEBUTTONDOWN):
# if (self.mMenuRects["NewGame"].collidepoint(event.pos)):
# self.mGameStateManager.GetState("Game").Destroy()
# self.mGameStateManager.SwitchState("Game")
# return
return GS_MenuBase.HandleEvent(self, event)
def Update(self, delta):
#self.mLevel.Scroll(1)
self.mLevel.Draw()
self.mLevel.Blit()
GS_MenuBase.Update(self, delta)
class GS_Game(GameState):
def __init__(self, kernel, gsm):
GameState.__init__(self, "Game", kernel, gsm)
self.mLevelName = ""
self.mLevel = None
self.mGroundLevel = 570
self.mHighScores = {}
self.mScrollSpeed = 2
self.mPaused = 0
self.mHouse = None
self.mCurrentLevel = 1
self.mLevelComplete = False
self.mSoundState = 1
self.mMusic = self.mKernel.SoundManager().LoadSound("BGmusic_flyaway.wav")
self.mGameOverImage, self.mGameOverRect = self.mKernel.ImageManager().LoadImage("gameover.bmp")
self.mLevelCompleteImage, self.mLevelCompleteRect = self.mKernel.ImageManager().LoadImage("levelcomplete.bmp")
self.mMainMenuImage, self.mMainMenuRect = self.mKernel.ImageManager().LoadImage("mainmenu_small.bmp")
self.mNextLevelImage, self.mNextLevelRect = self.mKernel.ImageManager().LoadImage("nextlevel.bmp")
self.mHighScoreImage, self.mHighScoreRect = self.mKernel.ImageManager().LoadImage("highscore_alert.bmp")
self.mGameOverRect.topleft = (400 - self.mGameOverRect.width / 2, 150)
self.mLevelCompleteRect.topleft = (400 - self.mLevelCompleteRect.width / 2, 50)
self.mHighScoreRect.topleft = (400 - self.mHighScoreRect.width / 2, 225)
self.mNextLevelRect.topleft = (600 - self.mMainMenuRect.width / 2, 350)
self.mMainMenuRect.topleft = (400 - self.mMainMenuRect.width / 2, 350)
self.mFont = pygame.font.SysFont("Helvetica", 16, True)
self.mPreviousPop = False
self.mPreviousDead = 0
self.mCurrentLevel = 1
self.mNextLevelName = ""
def Initialize(self, levelName = ""):
self.mHighScores = {}
self.mScore = 0
self.mPaused = 0
if (levelName):
self.LoadLevel(levelName)
if (levelName[5].isdigit()):
self.mCurrentLevel = int(levelName[5])
else:
self.mCurrentLevel = -1
elif (self.mNextLevelName):
self.LoadLevel(self.mNextLevelName)
else:
self.LoadLevel("Level1")
self.LoadScores()
self.mLevelComplete = False
for entity in self.mLevel.mEntities:
entity.mSoundState = self.mSoundState
self.mBalloon.mSoundState = self.mSoundState
self.mPerson.mSoundState = self.mSoundState
self.mMusic.set_volume(.3 * self.mSoundState)
self.mMusic.stop()
self.mMusic.play(-1)
fullLevelName = os.path.join("data", "levels", "Level" + str(self.mCurrentLevel + 1) + ".lvl")
if os.path.isfile(fullLevelName):
self.mNextLevelName = "Level" + str(self.mCurrentLevel + 1)
self.mMainMenuRect.topleft = (200 - self.mMainMenuRect.width / 2, 350)
else:
self.mNextLevelName = ""
self.mMainMenuRect.topleft = (400 - self.mMainMenuRect.width / 2, 350)
return GameState.Initialize(self)
def LoadLevel(self, levelName):
self.mLevelName = levelName + ".lvl"
self.mLevel = Level(self.mKernel, 800)
self.mLevel.LoadLevel(self.mLevelName)
self.mLevel.mScrollSpeed = self.mScrollSpeed
self.mCordImage, self.mCordRect = self.mKernel.ImageManager().LoadImage("cord.bmp")
self.mCordRect.bottomleft = (0, self.mGroundLevel)
self.mPerson = Person(self.mKernel, self.mLevel)
self.mPerson.SetPosition([128, self.mGroundLevel])
self.mPerson.mScreenOffset = 128
self.mPerson.SetGroundLevel(self.mGroundLevel)
self.mPerson.SyncCollisionRect()
self.mHouse = House(self.mKernel, self.mLevel)
self.mHouse.SetPosition([ self.mLevel.mLevelLength - 512, self.mGroundLevel - 480 ])
self.mHouse.SyncCollisionRect()
self.SpawnBalloon()
def SpawnBalloon(self):
self.mBalloon = Balloon(self.mKernel, self.mLevel)
self.mBalloon.SetPosition([ self.mLevel.mCameraX + self.mPerson.mScreenOffset + 128, self.mGroundLevel - self.mBalloon.Rect().height - 128 ])
self.mBalloon.mGroundLevel = 500
def Destroy(self):
self.mMusic.stop()
self.mNextLevelName = ""
self.mCurrentLevel = 1
return GameState.Destroy(self)
def Pause(self):
self.mMusic.stop()
return GameState.Pause(self)
def Unpause(self):
self.mMusic.play(-1)
return GameState.Unpause(self)
def HandleEvent(self, event):
if (event.type == QUIT):
pygame.quit()
sys.exit()
elif (event.type == KEYDOWN):
if (event.key == K_UP):
self.mPerson.Jump()
elif (event.key == K_DOWN):
self.mPerson.Duck()
elif (event.key == K_SPACE):
self.mBalloon.mBlown = 1
elif (event.key == K_p):
self.mPaused = (self.mPaused + 1) % 2
elif (event.key == K_ESCAPE):
self.mGameStateManager.SwitchState('MainMenu')
elif (event.key == K_m):
for entity in self.mLevel.mEntities:
entity.mSoundState = (entity.mSoundState +1) % 2
self.mBalloon.mSoundState = (self.mBalloon.mSoundState +1) % 2
self.mPerson.mSoundState = (self.mBalloon.mSoundState + 1) % 2
self.mSoundState = (self.mSoundState +1) % 2
self.mMusic.set_volume(.3*self.mSoundState)
elif(event.type == KEYUP):
if (event.key == K_SPACE):
self.mBalloon.mBlown = 0
elif (event.key == K_DOWN):
self.mPerson.Run()
elif (event.type == MOUSEBUTTONDOWN):
if (self.mMainMenuRect.collidepoint(event.pos)):
self.Destroy()
self.mGameStateManager.SwitchState("MainMenu")
elif (self.mNextLevelRect.collidepoint(event.pos)):
self.mCurrentLevel += 1
self.Initialize()
return GameState.HandleEvent(self, event)
def Update(self, delta):
if (not self.mLevelComplete):
if self.mPerson.CheckCollision(self.mHouse):
self.mLevelComplete = True
self.SaveScore()
self.mPerson.Done()
if self.mLevel.mCameraX > (self.mLevel.mLevelLength - 1500):
self.mBalloon.mBlown = 0
if not self.mLevelComplete and self.mPaused == 0:
if (self.mPerson.mDead == 0 and self.mPerson.mLives > 0):
self.mLevel.Scroll(self.mScrollSpeed)
self.mLevel.Update(delta)
if (self.mPerson.mLives > 0):
self.mPerson.Update(delta)
if (self.mPerson.mDead == 0):# and self.mPerson.mLives > 0):
self.mBalloon.Update(delta)
if (self.mPerson.CheckCollision(self.mBalloon) and self.mBalloon.CheckCollision(self.mPerson)):
self.mPerson.OnCollision(self.mBalloon)
self.mBalloon.OnCollision(self.mPerson)
self.mLevel.CheckCollisions(self.mPerson)
self.mLevel.CheckCollisions(self.mBalloon)
if (self.mBalloon.mPopped):
if (not self.mPreviousPop):
self.mPerson.mLives -= 1
if (self.mBalloon.mPosition[0] < self.mLevel.mCameraX):
if (self.mPerson.mLives > 0):
self.SpawnBalloon()
if (self.mPerson.mResetting):
self.SpawnBalloon()
self.mPerson.mResetting = False
self.mLevel.Draw()
self.mHouse.DrawBack()
self.mCordRect.bottomright = self.mPerson.Rect().bottomleft
self.mLevel.DisplaySurface().blit(self.mCordImage, self.mCordRect)
self.mPerson.Draw()
self.mHouse.Draw()
self.mBalloon.Draw()
self.mLevel.Blit()
textSurface = self.mFont.render( str(self.mLevelName)[0:-4], True, Colors.WHITE)
self.mKernel.DisplaySurface().blit(textSurface, (30, 580, textSurface.get_rect().width, textSurface.get_rect().height))
textSurface = self.mFont.render("Score: " + str(self.mPerson.mScore), True, Colors.WHITE)
self.mKernel.DisplaySurface().blit(textSurface, (150, 580, textSurface.get_rect().width, textSurface.get_rect().height))
textSurface = self.mFont.render("Lives: " + str(self.mPerson.mLives), True, Colors.WHITE)
self.mKernel.DisplaySurface().blit(textSurface, (270, 580, textSurface.get_rect().width, textSurface.get_rect().height))
textSurface = self.mFont.render("In Basket: " + str(self.mBalloon.mValue), True, Colors.WHITE)
self.mKernel.DisplaySurface().blit(textSurface, (390, 580, textSurface.get_rect().width, textSurface.get_rect().height))
textSurface = self.mFont.render("Points Possible: " + str(self.mLevel.mMaxScore), True, Colors.WHITE)
self.mKernel.DisplaySurface().blit(textSurface, (540, 580, textSurface.get_rect().width, textSurface.get_rect().height))
if (self.mPerson.mLives == 0):
self.mKernel.DisplaySurface().blit(self.mGameOverImage, self.mGameOverRect)
self.mMainMenuRect.topleft = (400 - self.mMainMenuRect.width / 2, 350)
self.mKernel.DisplaySurface().blit(self.mMainMenuImage, self.mMainMenuRect)
if (self.mLevelComplete):
self.mKernel.DisplaySurface().blit(self.mLevelCompleteImage, self.mLevelCompleteRect)
self.mKernel.DisplaySurface().blit(self.mMainMenuImage, self.mMainMenuRect)
if (self.mHighScores[self.mLevelName] == self.mPerson.mScore):
self.mKernel.DisplaySurface().blit(self.mHighScoreImage, self.mHighScoreRect)
if (self.mNextLevelName != ""):
self.mKernel.DisplaySurface().blit(self.mNextLevelImage, self.mNextLevelRect)
self.mPreviousDead = self.mPerson.mDead
self.mPreviousPop = self.mBalloon.mPopped
return GameState.Update(self, delta)
def SaveScore(self):
if self.mLevelName in self.mHighScores:
if self.mPerson.mScore > self.mHighScores[self.mLevelName]:
self.mHighScores[self.mLevelName] = self.mPerson.mScore
else:
self.mHighScores[self.mLevelName] = self.mPerson.mScore
with open(os.path.join("data", "highscores.txt"), 'w') as file:
for level in self.mHighScores:
file.write(level + " " + str(self.mHighScores[level]) + "\n")
def LoadScores(self):
HighScoreFile = os.path.join("data", "highscores.txt")
if (os.path.isfile(HighScoreFile)):
with open(HighScoreFile) as highscores:
scoreList = highscores.read().splitlines()
for i in range(0, len(scoreList)):
parts = scoreList[i].split()
self.mHighScores[parts[0]] = int(parts[1])
def main():
# Initialisation de la fenêtre d'affichage
pygame.init()
Config.screen = pygame.display.set_mode(
(Config.screenWidth, Config.screenHeight), HWSURFACE | DOUBLEBUF)
pygame.display.set_caption(Config.titre)
# le son
pygame.mixer.init(44100, -16, 2, 4096)
# le logo d'hommage ^^
Config.logo, Config.logo_r = Tools.load_png('logo.png')
# les bords de la surface de jeu
Config.bords = Border.Border()
# le niveau
Level.LoadLevel(Config.level)
if Config.bossLevel:
# niveau d'un boss
Boss.doBossLevel()
else:
# le fond
Tools.InitBG()
Tools.ReadHighScore()
# la zone d'info
Config.zinfo = pygame.Surface([(Config.screenWidth - Config.bords.width),
Config.screenHeight])
Config.zinfo.fill(THECOLORS["black"])
# Le joueur (la raquette)
Config.player = Player.Bat('player-bat-02.png', 'player-bat-02-L.png',
'player-bat-02-S.png')
# La première balle
Ball.BallInit()
# les ennemis
Enemys.init()
# les sons
Tools.InitSounds()
pygame.mixer.music.set_volume((Config.Volume / 100))
# Affichage
Config.screen.blit(Config.bg, (0, 0))
Config.bords.draw()
Tools.MsgInfo()
Level.DrawLevel()
Config.player.draw()
Ball.Ballsdraw()
Enemys.draw()
pygame.display.flip()
# Initialisation de l'horloge
Config.clock = pygame.time.Clock()
# timer user pour la màj des fps (déclenché 1 fois/seconde)
pygame.time.set_timer(USEREVENT, 1000)
# timer pour la génération des ennemis (déclenché toutes les 10s)
pygame.time.set_timer((USEREVENT + 1), 10000)
# timer pour la génération des bombes et missiles du boss (déclenché toutes les 5s)
pygame.time.set_timer((USEREVENT + 2), 5000)
Config.Sounds['intro'].play()
# Boucle d'évènements
while True:
event_handler()
dt = Config.clock.tick(Config.FPS) / 1000
Ball.Ballsupdate()
if Config.Perdu:
Config.life -= 1
if Config.life > 0:
Tools.MsgCenter("Oops...", 28,
Config.zinfo.get_rect().centery, "cyan", True)
pygame.display.flip()
# petite tempo
pygame.time.wait(1500)
Config.Perdu = False
Bonus.initBonus()
Config.player.reset()
Ball.BallInit()
else:
# perdu...
Tools.GameOver()
else:
if Config.bossLevel:
if Config.boss.update():
Config.life -= 1
if Config.life <= 0:
# perdu...
Tools.GameOver()
Config.player.update()
Bonus.update()
Enemys.update()
if Config.bossLevel:
if Config.boss.isDead:
# niveau suivant
Tools.MsgCenter("!! Bravo !!", 28,
Config.zinfo.get_rect().centery, "blue", True)
pygame.display.flip()
# petite tempo
pygame.time.wait(5000)
Tools.NextLevel()
if Level.FinishedLevel():
# niveau suivant
Tools.MsgCenter("Level UP!", 28,
Config.zinfo.get_rect().centery, "green", True)
pygame.display.flip()
# petite tempo
pygame.time.wait(1500)
Tools.NextLevel()
# affichages
Config.screen.blit(Config.bg, (0, 0))
Config.bords.draw()
Tools.MsgInfo()
Level.DrawLevel()
Config.player.draw()
Ball.Ballsdraw()
Bonus.draw()
Bonus.drawAdds()
Enemys.draw()
pygame.display.flip()
