def levelSelectionMenu():
"""
Fait fonctionner le menu de sélection d'un niveau enregistré.
"""
goInBlack()
levels = IO.getLevels("level")
levelSelected = 0
level = IO.loadLevel(level=levels[0])
game.initSelectionLevel(level)
moveRender(levels, levelSelected, IO.loadLevel)
while not evenement.event["game"] == 'return':
evenement.compute()
ui.logic(evenement.event["tk"])
if evenement.event["game"] == "right":
levelSelected = move(levelSelected, levels, 1, IO.loadLevel)
elif evenement.event["game"] == "left":
levelSelected = move(levelSelected, levels, -1, IO.loadLevel)
elif evenement.event["game"] == "play":
goInBlack()
game.play(levels[levelSelected], "s")
backInBlack(game.initSelectionLevel, [levels[levelSelected]])
moveRender(levels, levelSelected, IO.loadLevel)
elif evenement.event["game"] == "edit":
goInBlack()
editor.editor(levels[levelSelected])
backInBlack(game.initSelectionLevel, [levels[levelSelected]])
moveRender(levels, levelSelected, IO.loadLevel)
game.updateTime()
animation.update()
ui.render(game.getFps())
mise_a_jour()
backInBlack(game.initPlayMenu)
def levelSaveMenu():
"""
Fait fonctionner le menu de sélection d'une sauvegarde.
"""
goInBlack()
levels = IO.getLevels("save")
levelSelected = 0
level = IO.loadSave(levels[0])
game.initSaveLevel(level)
moveRender(levels, levelSelected, IO.loadSave)
while not evenement.event["game"] == 'return':
evenement.compute()
ui.logic(evenement.event["tk"])
if evenement.event["game"] == "right":
levelSelected = move(levelSelected, levels, 1, IO.loadSave)
elif evenement.event["game"] == "left":
levelSelected = move(levelSelected, levels, -1, IO.loadSave)
elif evenement.event["game"] == "play":
goInBlack()
game.play(levels[levelSelected], "l")
backInBlack(game.initSaveLevel, [levels[levelSelected]])
moveRender(levels, levelSelected, IO.loadSave)
game.updateTime()
animation.update()
ui.render(game.getFps())
mise_a_jour()
backInBlack(game.initPlayMenu)
def endGame(win):
ui.addText(WIDTH_WINDOW / 2,
HEIGHT_WINDOW / 2,
textSize=48,
text=("VOUS AVEZ GAGNE :)" if win else "VOUS AVEZ PERDU :("),
textColor=("green" if win else "red"),
ID="endText",
layer=2)
ui.render(getFps())
attente_clic_ou_touche()
def render(clickable_mouseover):
screen.blit(stage, (0, 0))
world.render()
ui.render()
if clickable_mouseover is not None:
if clickable_mouseover[3] is not None:
tooltip.display(clickable_mouseover[3], clickable_mouseover[4])
cursor_image = cursor[2]
cursor_rect = cursor_image.get_rect()
cursor_rect.center = pygame.mouse.get_pos()
screen.blit(cursor[2], cursor_rect)
pygame.display.flip()
def resetGame():
"""
Réinitialise la partie et les données associées à celle-ci.
"""
origin = data["origin"][:]
mode = data["mode"]
level = data["level"]
initData()
print(mode, origin)
if mode == "s":
data["map"] = origin[:]
else:
IO.loadLevel(data)
start(data)
data["level"] = level
data["mode"] = mode
render.update(data["map"][1::], "gameCanvas")
ui.render()
def status(data):
"""
verifie si la partie de Rockford est gagnée ou perdue
:param list rockford: rockford
"""
global GAME_STATUS
if data["time"]["remain"] <= 0:
GAME_STATUS = False
if GAME_STATUS is not None:
if GAME_STATUS:
timer.new(1, ID="endScoreUpdate",
permanent=True) # shadows the older timer /!\
vector = data["time"]["remain"] * 10
currentTime = data["time"]["remain"]
currentScore = data["score"]
while not timer.isOver("endScoreUpdate"):
currentVector = vector * (
timer.timers["endScoreUpdate"]["progression"] /
timer.timers["endScoreUpdate"]["size"])
data["score"] = currentScore + int(currentVector)
data["time"]["remain"] = currentTime + int(currentScore / 10)
updateStats(
data["time"]["remain"],
(data["diamonds"]["owned"], int(data["map"][0][1])),
data["score"])
updateTime()
ui.render(getFps())
mise_a_jour()
data["score"] = currentScore + vector
data["time"]["remain"] = 0
updateStats(data["time"]["remain"],
(data["diamonds"]["owned"], int(data["map"][0][1])),
data["score"])
ui.render(getFps())
if data["mode"] == "s":
updateScore(data["score"], getPlayer(), level=data["level"])
endGame(True)
ui.remObject("endText")
ui.render(getFps())
return True
else:
if data["mode"] == "s":
updateScore(data["score"], getPlayer(), level=data["level"])
endGame(False)
else:
updateScore(data["score"], getPlayer())
endGame(False)
ui.remObject("endText")
ui.render(getFps())
return False
def test_render_displays_all_characters(self):
board = chess.Board(chess.STARTING_FEN)
black_pieces = "♖♘♗♕♔♙"
white_pieces = "♜♞♝♛♚♟"
ranks = "12345678"
files = "abcdefgh"
display = render(board)
for char in black_pieces + white_pieces + ranks + files:
self.assertIn(char, display)
def test_render_displays_all_characters(self):
board = chess.Board(chess.STARTING_FEN)
black_pieces = '♖♘♗♕♔♙'
white_pieces = '♜♞♝♛♚♟'
ranks = '12345678'
files = 'abcdefgh'
display = render(board)
for char in black_pieces + white_pieces + ranks + files:
self.assertIn(char, display)
def choicePlaystyleMenu():
"""
Fait fonctionner le menu de sélection du mode de jeu.
"""
while not evenement.event["game"] == 'return':
evenement.compute()
ui.logic(evenement.event["tk"])
# home:play:selection
if evenement.event["game"] == 'selection':
levelSelectionMenu()
# home:play:save
if evenement.event["game"] == 'save':
levelSaveMenu()
# home:play:random
if evenement.event["game"] == 'play':
goInBlack()
game.play(mode="r")
backInBlack(game.initPlayMenu)
game.updateTime()
ui.render(game.getFps())
mise_a_jour()
def start(self):
if not self.simulation_mode:
cursor.hide()
World.disable_console_echo()
os.system("clear")
print()
try:
while True:
if not self.tick():
break
except KeyboardInterrupt:
if not self.simulation_mode:
os.system("clear")
print()
render(self)
if not self.simulation_mode:
cursor.show()
time.sleep(2)
os.system("clear")
else:
for snake in self.snakes:
print(snake.score, self.cycle)
def game_loop(word, found, bank, guess_count, parts):
while True:
if game_won(word, found):
print("Yay!")
sys.exit()
else:
ui.render(object='gallows', parts=0)
ui.render(object='game_state', word=our_word, found=found)
ui.render(object='bank', letters=bank)
def tick(self):
start_point = datetime.datetime.now()
if self.cycle > self.max_cycles:
return False
if not self.simulation_mode:
render(self)
new_snakes = []
for snake in self.snakes:
if self.is_dead(snake):
return False
continue
new_dir = self.agents[snake.snake_id].get_action(self)
fixed_dir = self.fix_action(snake, new_dir)
self.move_snake(snake, fixed_dir)
new_snakes.append(snake)
if len(new_snakes) == 0:
return False
self.snakes = new_snakes
self.update_table()
self.cycle = self.cycle + 1
max_score = max(map((lambda v: v[1][1]), self.team_score.items()))
if not self.simulation_mode:
diff = (datetime.datetime.now() - start_point)
diff = diff / datetime.timedelta(milliseconds=1)
if diff < (self.interval * 2):
time.sleep(((self.interval * 2) - diff) / 1000)
if max_score >= self.target_score:
if not self.simulation_mode:
render(self)
return False
return True
def scoresMenu():
scores = IO.loadScore()
levels = [key for key in scores["s"]]
selected = 0
game.initScores(scores)
while not evenement.event["game"] == 'return':
evenement.compute()
ui.logic(evenement.event["tk"])
if evenement.event["game"] == "up":
selected += 1
for i in range(4):
ui.setObject(
"ltext" + str(i + 1), {
"text":
levels[(selected + i) % len(levels)] + " - " +
str(scores["s"][levels[(selected + i) %
len(levels)]][0]) + "\n\t" +
scores["s"][levels[(selected + i) % len(levels)]][1]
})
elif evenement.event["game"] == "down":
selected -= 1
for i in range(4):
ui.setObject(
"ltext" + str(i + 1), {
"text":
levels[(selected + i) % len(levels)] + " - " +
str(scores["s"][levels[(selected + i) %
len(levels)]][0]) + "\n\t" +
scores["s"][levels[(selected + i) % len(levels)]][1]
})
game.updateTime()
animation.update()
ui.render(game.getFps())
mise_a_jour()
def game_loop(user, difficulty):
word = init_game(difficulty)
guess_count = difficulty_levels[difficulty]['guesses']
while True:
if game_won(word, FOUND_LETTERS):
print("Yay, {}!".format(user))
restart_game(word)
if len(WRONG_LETTERS) >= guess_count:
print("Oh, sad day, {}. You lost!".format(user))
restart_game(word)
ui.render(object='gallows', parts=len(WRONG_LETTERS))
ui.render(object='game_state', word=word, found=FOUND_LETTERS)
ui.render(object='bank', letters=WRONG_LETTERS)
guess_letter(word)
def editor(level=None):
"""
Lance et fait fonctionner l'éditeur de niveau.
:param list level: Niveau à charger
"""
ui.reset()
ui.setBackground("black")
initEditorUI()
blockMap=[
["W", "G"],
[".", "B"],
["D", "X"],
["R", "E"],
]
editorWidth = 20
editorHeight = 12
if level:
# squaresMap=[]
level=IO.loadLevel(level=level)
ui.setObject("timeLeftTextField", {"text": str(level[0][0])})
level=level[1:]
ydiff=editorHeight-len(level)
xdiff=editorWidth-len(level[0])
for y in range(len(level)):
level[y].extend(["." for x in range(xdiff)])
level.extend([["." for y in range(editorWidth)] for y in range(ydiff)])
else:
level=[["." for x in range(editorWidth)] for y in range(editorHeight)]
render.update(level, "editorCanvas")
render.update(blockMap, "blockCanvas")
onPressed=False
while not evenement.event["game"] == 'return':
evenement.compute()
ui.logic(evenement.event["tk"])
tkEvent=evenement.getTkEvent()
# print(type(ui.objects["blockCanvas"]["selected"]))
if ui.focus is None:
if ui.exclusiveLayer is None:
updateCursor(tkEvent, "editorCanvas", ui.objects["blockCanvas"]["squaresMap"][ui.objects["blockCanvas"]["selected"][0][1]][ui.objects["blockCanvas"]["selected"][0][0]], onPressed)
updateCursor(tkEvent, "blockCanvas")
# print(evenement.event["game"])
if evenement.event["game"] == "reset":
render.update([["." for x in range(editorWidth)] for y in range(editorHeight)], "editorCanvas")
# ui.render(game.getFps())
# continue
elif evenement.event["game"] == "save":
timer.factor = 0
if level:
IO.save(ui.objects["editorCanvas"]["squaresMap"], level[1])
else:
ui.newPrompt("Nom de la sauvegarde:", "Sauvegarder", success=lambda: IO.save(game.data, ui.objects["prompt_2"]["text"]), checker=IO.checkSaveName, anyway=lambda: timer.setFactor(1))
if type_evenement(tkEvent)=="Deplacement":
if "|" in str(tkEvent):
onPressed=True
else:
onPressed=False
game.updateTime()
ui.render(game.getFps())
mise_a_jour()
ui.reset()
animTile.sprite = sprite2.loadSpriteAnimation("player_idle")
animTile.play("player_idle")
_player = objects.getObjectsOfType(player.Player)[0]
_player.sprite = sprite2.loadSpriteAnimation("eggy")
_player.play("eggy")
#####
camera = Camera(15)
camera.setTarget(player.getPlayer())
fps_delay = 60 #Show fps every second
fps_delta = 0
while True:
inputcontrol.evaluate(pygame.event.get())
physics.solve(objects.getObjectsOfType(Entity))
camera.render(gameScreen)
ui.render(gameScreen)
scaled_display = pygame.transform.scale(gameScreen, (SCREENWIDTH * SCALEFACTOR, SCREENHEIGHT * SCALEFACTOR))
display.blit(scaled_display, (0, 0))
pygame.display.update()
clock.tick(60)
#Show FPS
if fps_delta >= fps_delay and DEBUGGING:
fps_delta = 0
print("%0.2f" % clock.get_fps() + " FPS")
fps_delta += 1
def play(level=None, mode="r"):
"""
Lance une partie.
:param string level: Nom du niveau à charger
:param string mode: Type de partie à jouer ("r": random "s": save "l":level)
"""
global data
ui.reset()
ui.setBackground("black")
initGameUI()
initData()
data["level"] = level
data["mode"] = mode
# data["origin"] = data["map"][1::]
if level and mode=="s":
IO.loadLevel(data, level)
elif level and mode=="l":
IO.loadSave(level, data)
else:
IO.loadLevel(data)
start(data)
render.update(data["map"][1::], "gameCanvas")
while True:
evenement.compute(inGame=True)
ui.logic(evenement.event["tk"])
#direction = (0, 0)
if ui.focus is None:
timer.start("game")
gameEvenement=evenement.event["game"]
if handleEvenement(gameEvenement):
if gameEvenement=="return":
break
continue
# if evenement.event["game"] == "reset" or ui.evenement == "reset":
# continue
# elif evenement.event["game"] == "move":
# elif evenement.event["game"] == "save":
# #fileName = IO.save(data)
# continue
# elif evenement.event["game"] == "load":
# continue
# elif evenement.event["game"] == 'return':
# break
# if evenement.event["game"] == "debug" or ui.evenement == "debug":
# debug = (False if debug else True)
# print("DEBUG ACTIVATED" if debug else "DEBUG DEACTIVATED")
# ui.evenement = None
# continue
logic.updatePhysic(data)
if data["fall"]["fallings"]:
render.update(data["map"][1::], "gameCanvas")
updateStats(data["time"]["remain"], (data["diamonds"]["owned"], int(data["map"][0][1])), data["score"])
updateTime()
data["time"]["remain"] = timer.getTimer("game", int, remain=True)
#print(timer.timers["game"]["progression"])
win = logic.status(data)
logic.updateGameStatus()
if win and data["mode"] == "s":
break
elif win:
IO.loadLevel(data)
start(data, keepScore=True)
render.update(data["map"][1::], "gameCanvas")
elif win==False:
break
ui.render(getFps())
mise_a_jour()
ui.reset()
initMenuUI()
def _render_uis(self, renderer):
for ui in self.uis:
ui.render(renderer.screen)
game.initMenuUI()
while not evenement.event["game"] == 'return':
# ev=donne_evenement()
# if ev[0]!='RAS':
# print(ev)
evenement.compute()
ui.logic(evenement.event["tk"])
# home:play
if evenement.event["game"] == 'play':
goInBlack(game.initPlayMenu)
choicePlaystyleMenu()
backInBlack(game.initMenuUI)
# home:editor
elif evenement.event["game"] == 'editor':
goInBlack()
editor.editor()
backInBlack(game.initMenuUI)
elif evenement.event["game"] == 'score':
goInBlack()
scoresMenu()
backInBlack(game.initMenuUI)
game.updateTime()
animation.update() # /!\ render.updateAnimations before ui.render
ui.render(game.getFps())
mise_a_jour()
###############################################################################
###############################################################################
