def _start(self):
"""
Init and start new game scene
:return: None
"""
self.tileset = self.manager.get_image("tileset.png")
self.main_theme_music = self.manager.get_music("main-theme.ogg")
self.explosion_sound = self.manager.get_sound("boom.ogg")
self.width, self.height = pygame.display.get_surface().get_size()
self.track = Track()
self.obstacle = Obstacle(self.track)
self.player = Player(self.track)
self.player.attach()
self.explosion_sprite_size = 192
self.explosion_speed = 4
self.explosion = Animation(self.manager.get_image("explosion.png"),
self.explosion_sprite_size,
self.explosion_sprite_size,
self.explosion_speed)
self.is_explosion_started = False
self.settings = Settings()
self.font = pygame.font.SysFont("Monospace",
40,
bold=False,
italic=False)
self.calculate_tile_size()
self.make_threads()
def __init__(self, l):
'''
Constructeur de la class LoadScene
'''
self.width = pygame.display.get_surface().get_width()
self.height = pygame.display.get_surface().get_height()
self.loader = l
self.action = 0
self.actionCallBack = False
self.nt = False
self.tour = 1
self.pioche = Pioche()
deckPlayer1 = Deck("deck1", self.pioche.getDecks("deck1"))
deckPlayer2 = Deck("deck2", self.pioche.getDecks("deck2"))
self.player1 = Player(1, "Egor", deckPlayer1)
self.player2 = Player(2, "Quentin", deckPlayer2)
self.lastAnimCard = None
l.clearAnimation()
l.addAnimationByPath('bg', '../img/background.jpg')
l.addAnimationByPath('showCard', '../img/card/spellCard.jpg', self.width / 2 - 75, self.height / 2 - 105, level=4)
l.addAnimationByPath('pioche1', '../img/card/backSpellCard.jpg', level=1)
l.addAnimationByPath('pioche2', '../img/card/backSpellCard.jpg', level=1)
l.addAnimationByPath('passerTourJoueur', '../img/passer.png', self.width / 2 - 140, self.height / 2 - 50, level=1)
self.btnPasser = Button('passerTourJoueur', '../img/passer.png', '../img/passer_select.png', self.partieSolo)
self.btnPasser.loadButton(self.width / 2 - 140, self.height / 2 - 50, 280, 50, self.width, self.height)
selection = l.getAnimation('pioche1')
if len(selection) > 0:
selection[0].newPos(self.width - 200, self.height / 2 - 105 - 110, 75, 105, 0, None)
selection = l.getAnimation('pioche2')
if len(selection) > 0:
selection[0].newPos(self.width - 200, self.height / 2 + 105, 75, 105, 0, None)
self.levelMaxPlayer = 3
self.levelMaxEnemy = 3
self.cardPlayer = []
for i in range(5, 8):
self.cardPlayer.append(CardInfo(l, self.player1.deck.getCarte(), i))
self.cardEnemy = []
for i in range(5, 8):
self.cardEnemy.append(CardInfo(l, self.player2.deck.getCarte(), i))
self.resizeWindow(l, self.width, self.height)
self.ReturnScene = self
self.changeText(l, "INFO")
def __init__(self, namePlayer1, namePlayer2):
'''
Constructor
@param namePlayer1: Nom du joueur 1
@param namePlayer2: Nom du joueur 2
'''
self.tour = 1
self.pioche = Pioche()
deckPlayer1 = Deck("deck1", self.pioche.getDecks("deck1"))
deckPlayer2 = Deck("deck1", self.pioche.getDecks("deck2"))
self.player1 = Player(1, namePlayer1, deckPlayer1)
self.player2 = Player(2, namePlayer2, deckPlayer2)
def __init__(self):
self.player = Player()
self.gameWindow = tk.Tk()
self.jokerFrame = tk.Frame(self.gameWindow)
self.halfJoker = tk.Button(self.jokerFrame, text="50/50")
self.audienceJoker = tk.Button(self.jokerFrame, text="Publikum")
self.startBtn = tk.Button(self.gameWindow,
text="START",
bg="gray",
command=self.start)
# self.question = tk.Label(self.gameWindow)
# self.score = tk.Label(self.gameWindow, text=self.player.getLevel())
self.question = QuestionDisplayPanel(self.gameWindow)
self.halfJoker.pack(side=tk.RIGHT)
self.audienceJoker.pack(side=tk.RIGHT)
self.gameWindow.title("Wer wird Millionär ?")
self.gameWindow.geometry("500x500")
self.startBtn.pack(fill=tk.X, side=tk.TOP)
self.jokerFrame.pack(side=tk.TOP)
# self.score.pack(fill=tk.X, side=tk.TOP)
# self.answerD.pack(fill=tk.X, side=tk.BOTTOM)
# self.answerC.pack(fill=tk.X, side=tk.BOTTOM)
# self.answerB.pack(fill=tk.X, side=tk.BOTTOM)
# self.answerA.pack(fill=tk.X, side=tk.BOTTOM)
self.question.pack(fill=tk.X, side=tk.BOTTOM)
self.gameWindow.mainloop()
def Setup(self, message="", callback=None, time=None): # create our main player with id 0 self.player = Player(self, 0, [0, 0, 11.0 / gfx.width, 12.0 / gfx.width], active=True) self.camera = BitCamera([0, 0, 1.0 / config.zoom, float(gfx.height) / gfx.width / config.zoom], tracking=self.player) if message: self.AddMessage(message, callback, time)
class Core(Game, EventMonitor, LevelManager, ConnectionListener):
def __init__(self, server="mccormick.cx"):
self.serverhost = server
config.zoom = 5
self.bgColor = (255, 255, 255)
gfx.Caption('Infinite 8-bit Platformer')
gfx.SetSize([800, 450])
gfx.LoadFont("freaky_fonts_ca", 16.0 / gfx.width, "default")
gfx.LoadFont("FreeSans", 18.0 / gfx.width, "chat")
gfx.LoadFont("FreeSansBold", 12.0 / gfx.width, "speech")
#gfx.LoadFont("FreeSans", 8.0 / gfx.width, "tiny")
sfx.LoadSound("item")
sfx.LoadSound("portal")
sfx.LoadSound("die")
sfx.LoadSound("jump")
self.level = None
Game.__init__(self)
EventMonitor.__init__(self)
# connection to the network
self.net = NetMonitor(self)
# The editLayer user interface (hud for editing levels)
self.editLayer = EditLayer(self)
# The other hud stuff
self.hud = Hud(self)
# progress bar should go above everything else
self.progress = Progress()
# Create player and camera and put some text on the screen
# Give us the methods for manipulating level collections
self.players = PlayerManager(self)
# splash screen rock
self.splash = None
if not config.debugmode:
self.splash = Splash(self)
self.Add(self.splash)
else:
self.StartGame()
def StartGame(self):
# get rid of the splash screen
if self.splash:
self.Remove(self.splash)
del self.splash
# get the player and camera into the game
self.Setup()
# add the network management code
self.Add(self.net)
# global tooltip singleton
self.Add(tooltip)
# add the layer for editing levels
self.Add(self.editLayer)
# add the game's heads-up-display
self.Add(self.hud)
# add the progress meter for loading etc.
self.Add(self.progress)
# initialise the level manager
LevelManager.__init__(self)
# connect to the server
self.net.Connect()
def Setup(self, message="", callback=None, time=None):
# create our main player with id 0
self.player = Player(self, 0, [0, 0, 11.0 / gfx.width, 12.0 / gfx.width], active=True)
self.camera = BitCamera([0, 0, 1.0 / config.zoom, float(gfx.height) / gfx.width / config.zoom], tracking=self.player)
if message:
self.AddMessage(message, callback, time)
def AddMessage(self, messagetxt, callback=None, time=None):
# why do i have to do this? the first notification does not appear if I don't delay for 1 frame
self.QueueLater(1, self.Add, Notification(self, messagetxt, callback=callback, time=time))
def RemoveMessage(self, message):
self.Remove(message)
def Quit(self):
Game.Quit(self)
###
### Concurrency
###
def Pump(self):
ConnectionListener.Pump(self)
self.players.Pump()
Game.Pump(self)
EventMonitor.Pump(self)
def Run(self):
if not self.level:
gfx.SetBackgroundColor(self.bgColor)
Game.Run(self)
gfx.Flip()
def Update(self):
Concurrent.Update(self)
###
### Platformer events
###
def PlayerDied(self):
# if they don't have a last platform them pick the first platform on the level
destination = self.player.lastplatform and self.player.lastplatform.id or self.levels[self.level].layer.platforms[0].id
self.QueueLater(100, self.JoinLevel, self.level, destination)
self.LeaveLevel()
self.Setup("oops!")
def Teleport(self, portal):
parts = portal.destination.split(":")
if len(parts) == 2:
self.SetLevel(portal=portal, *parts)
return True
def TeleportToLevel(self, displayName):
if self.levels.get(displayName):
levelname = self.levels[displayName].name
else:
levelname = displayName[len("level"):]
self.SetLevel("level" + levelname, "start")
def Back(self):
LevelManager.Back(self)
def DoChatBox(self, text):
if text.startswith("/help"):
webbrowser.open("http://infiniteplatformer.com/info/help")
elif text.startswith("/teleport"):
bits = text.split(" ")
# TODO: support x,y locations and named portals
destination = " ".join(bits[1:])
matches = [l for l in self.levels if self.levels[l].displayName == destination]
if len(matches):
self.TeleportToLevel(matches[0])
elif self.net.serverconnection == 1:
self.net.SendWithID({"action": "findlevel", "name": destination})
else:
self.AddMessage("You are offline", None, 5.0)
elif text.startswith("/new"):
self.edit_layer.NewLevel()
elif text.startswith("/quit"):
self.Quit()
elif text.startswith("/back"):
self.Back()
else:
self.player.Chat(text)
self.hud.chatBox.ClearText()
self.hud.chatBox.Hide()
###
### Interface events
###
def KeyDown(self, e):
#print e
pass
def KeyDown_escape(self, e):
self.Quit()
###
### Network events
###
def Network_foundlevel(self, data):
if data['level']:
self.TeleportToLevel(data['level'])
else:
self.AddMessage('No such level "%s"' % data['name'], time=1)
class GameScene(Scene):
'''
Une scene pour le chargement des données
'''
def __init__(self, l):
'''
Constructeur de la class LoadScene
'''
self.width = pygame.display.get_surface().get_width()
self.height = pygame.display.get_surface().get_height()
self.loader = l
self.action = 0
self.actionCallBack = False
self.nt = False
self.tour = 1
self.pioche = Pioche()
deckPlayer1 = Deck("deck1", self.pioche.getDecks("deck1"))
deckPlayer2 = Deck("deck2", self.pioche.getDecks("deck2"))
self.player1 = Player(1, "Egor", deckPlayer1)
self.player2 = Player(2, "Quentin", deckPlayer2)
self.lastAnimCard = None
l.clearAnimation()
l.addAnimationByPath('bg', '../img/background.jpg')
l.addAnimationByPath('showCard', '../img/card/spellCard.jpg', self.width / 2 - 75, self.height / 2 - 105, level=4)
l.addAnimationByPath('pioche1', '../img/card/backSpellCard.jpg', level=1)
l.addAnimationByPath('pioche2', '../img/card/backSpellCard.jpg', level=1)
l.addAnimationByPath('passerTourJoueur', '../img/passer.png', self.width / 2 - 140, self.height / 2 - 50, level=1)
self.btnPasser = Button('passerTourJoueur', '../img/passer.png', '../img/passer_select.png', self.partieSolo)
self.btnPasser.loadButton(self.width / 2 - 140, self.height / 2 - 50, 280, 50, self.width, self.height)
selection = l.getAnimation('pioche1')
if len(selection) > 0:
selection[0].newPos(self.width - 200, self.height / 2 - 105 - 110, 75, 105, 0, None)
selection = l.getAnimation('pioche2')
if len(selection) > 0:
selection[0].newPos(self.width - 200, self.height / 2 + 105, 75, 105, 0, None)
self.levelMaxPlayer = 3
self.levelMaxEnemy = 3
self.cardPlayer = []
for i in range(5, 8):
self.cardPlayer.append(CardInfo(l, self.player1.deck.getCarte(), i))
self.cardEnemy = []
for i in range(5, 8):
self.cardEnemy.append(CardInfo(l, self.player2.deck.getCarte(), i))
self.resizeWindow(l, self.width, self.height)
self.ReturnScene = self
self.changeText(l, "INFO")
def asyncAnimDeckPlayerFinal(self, anim):
if not (self.lastAnimCard == None):
self.actionCallBack = False
self.lastAnimCard = None
def asyncAnimDeckPlayer(self, anim):
if not (self.lastAnimCard == None):
self.lastAnimCard.setResize(self.width - 5 - (80 * len(self.cardPlayer)), self.height - 115, 75, 105, 40, self.asyncAnimDeckPlayerFinal)
def animDeckPlayer(self):
self.levelMaxPlayer += 1
card = CardInfo(self.loader, self.player1.deck.getCarte(), self.levelMaxPlayer)
card.setResize(self.width - 163 , self.height / 2 + 152, 0, 0, 0, None)
card.setResize(self.width - 200, self.height / 2 + 105, 75, 105, 20, self.asyncAnimDeckPlayer)
self.cardPlayer.append(card)
self.lastAnimCard = card
def asyncAnimDeckEnemyFinal(self, anim):
if not (self.lastAnimCard == None):
self.actionCallBack = False
self.lastAnimCard = None
def asyncAnimDeckEnemy(self, anim):
if not (self.lastAnimCard == None):
self.lastAnimCard.setResize(-70 + (80 * len(self.cardPlayer)), 10, 75, 105, 40, self.asyncAnimDeckEnemyFinal)
def animDeckEnemy(self):
self.levelMaxPlayer += 1
card = CardInfo(self.loader, self.player2.deck.getCarte(), self.levelMaxPlayer)
card.setResize(self.width - 163 , self.height / 2 - 53 - 110, 0, 0, 0, None)
card.setResize(self.width - 200, self.height / 2 - 105 - 110, 75, 105, 20, self.asyncAnimDeckEnemy)
self.cardEnemy.append(card)
self.lastAnimCard = card
def asyncChangeText(self, anim):
anim.newPos((self.width / 2), (self.height / 2), 0, 0, 50, None)
self.actionCallBack = False
def changeText(self, l, message):
texts = l.getFont('mainTitle')
if len(texts) > 0:
sprite = Sprite(texts[0].render(message, 1, (255, 255, 0)))
animation = Animation(sprite)
animation.newPos((self.width / 2 - sprite.w / 2), (self.height / 2 - sprite.h / 2) + 60, sprite.w, sprite.h, 0)
animation.newPos((self.width / 2 - sprite.w / 2), (self.height / 2 - sprite.h / 2) + 60, sprite.w, sprite.h, 50, self.asyncChangeText)
l.removeAnimation('info')
l.addAnimation('info', animation)
def partieSolo(self, e):
self.nt = True
def statusText(self, l):
texts = l.getFont('mainTitle')
# PLayer 1 ( Down )
if len(texts) > 0:
sprite = Sprite(texts[0].render("VIE: " + str(self.player1.health) + "/30", 1, (255, 255, 0)))
spriteBis = Sprite(texts[0].render("MANA: " + str(self.player1.mana) + "/10", 1, (255, 255, 0)))
spriteTer = Sprite(texts[0].render("" + str(self.player1.name) + "", 1, (255, 255, 0)))
animation = Animation(sprite)
animationBis = Animation(spriteBis)
animationTer = Animation(spriteTer)
animation.newPos(self.width - (sprite.w / 2) - 10, (self.height / 2 - sprite.h / 2) - 10 - (sprite.h / 2), sprite.w / 2, sprite.h / 2, 0)
animationBis.newPos(self.width - (sprite.w / 2) - 10, (self.height / 2 - sprite.h / 2), sprite.w / 2, sprite.h / 2, 0)
animationTer.newPos(self.width - (sprite.w / 2) - 10, (self.height / 2 - sprite.h / 2) - (10 - (sprite.h / 2) * 2), sprite.w / 2, sprite.h / 2, 0)
l.removeAnimation('infoVieP1')
l.addAnimation('infoVieP1', animation, level=5)
l.removeAnimation('infoManaP1')
l.addAnimation('infoManaP1', animationBis, level=5)
l.removeAnimation('infoNameP1')
l.addAnimation('infoNameP1', animationTer, level=5)
# PLayer 1 ( UP )
if len(texts) > 0:
sprite = Sprite(texts[0].render("VIE: " + str(self.player2.health) + "/30", 1, (255, 255, 0)))
spriteBis = Sprite(texts[0].render("MANA: " + str(self.player2.mana) + "/10", 1, (255, 255, 0)))
spriteTer = Sprite(texts[0].render("" + str(self.player2.name) + "", 1, (255, 255, 0)))
animation = Animation(sprite)
animationBis = Animation(spriteBis)
animationTer = Animation(spriteTer)
animation.newPos(10, (self.height / 2 - sprite.h / 2) - 10 - (sprite.h / 2), sprite.w / 2, sprite.h / 2, 0)
animationBis.newPos(10, (self.height / 2 - sprite.h / 2), sprite.w / 2, sprite.h / 2, 0)
animationTer.newPos(10, (self.height / 2 - sprite.h / 2) - (10 - (sprite.h / 2) * 2), sprite.w / 2, sprite.h / 2, 0)
l.removeAnimation('infoVieP2')
l.addAnimation('infoVieP2', animation, level=5)
l.removeAnimation('infoManaP2')
l.addAnimation('infoManaP2', animationBis, level=5)
l.removeAnimation('infoNameP2')
l.addAnimation('infoNameP2', animationTer, level=5)
selection = l.getAnimation('pioche1')
if len(selection) > 0:
selection[0].newPos(self.width - 200, self.height / 2 - 105 - 110, 75, 105, 0, None)
selection = l.getAnimation('pioche2')
if len(selection) > 0:
selection[0].newPos(self.width - 200, self.height / 2 + 105, 75, 105, 0, None)
def quitterCallBack(self, nom):
self.ReturnScene = None
def retourCallBack(self, nom):
from scene.MainScene import MainScene
self.ReturnScene = MainScene(self.loader)
def updateMain(self, e, l):
x = 10
y = 10
for cardUpdateEnemy in self.cardEnemy:
if self.lastAnimCard != cardUpdateEnemy:
cardUpdateEnemy.update(e, l)
cardUpdateEnemy.updateResize(self.width, self.height)
cardUpdateEnemy.setPosition(x, y, 0)
x += cardUpdateEnemy.width + 5
x = self.width - 85
y = self.height - 115
for cardUpdatePlayer in self.cardPlayer:
if self.lastAnimCard != cardUpdatePlayer:
cardUpdatePlayer.update(e, l)
cardUpdatePlayer.updateResize(self.width, self.height)
cardUpdatePlayer.setPosition(x, y, 0)
x -= cardUpdatePlayer.width + 5
self.statusText(l)
def update(self, e, l):
'''
@param e: le gestionnaire d'événement
@param l: le gestionnaire d'image
@return: Scene à renvoyer
'''
self.btnPasser.update(e, l)
if (e.keyboard[pygame.K_ESCAPE]):
e.keyboard[pygame.K_ESCAPE] = False
self.retourCallBack('')
self.loader.clearFont()
if self.action == 0:
#Get name and random begin
print("Choix du nom ...")
print("Choix du joueur commençant ...")
self.changeText(l, "" + self.player1.name + " à vous !")
self.actionCallBack = True
self.action = 1
elif self.action == 1:
if self.actionCallBack == False:
self.animDeckPlayer()
self.action = 2
self.actionCallBack = True
elif self.action == 2:
if self.actionCallBack == False:
self.action = 10
elif self.action == 10:
# Joueur 1 sur joueur 2
if e.keyboard[pygame.K_v] or self.nt:
self.nt = False
e.keyboard[pygame.K_v] = False
self.changeText(l, "" + self.player2.name + " à vous !")
self.action = 11
self.actionCallBack = True
elif self.action == 11:
if self.actionCallBack == False:
self.animDeckEnemy()
self.action = 12
self.actionCallBack = True
elif self.action == 12:
if self.actionCallBack == False:
self.action = 20
elif self.action == 20:
# Joueur 2 sur joueur 1
if e.keyboard[pygame.K_v] or self.nt:
self.nt = False
e.keyboard[pygame.K_v] = False
self.changeText(l, "" + self.player1.name + " à vous !")
self.actionCallBack = True
self.action = 30
elif self.action == 30:
# reset
self.tour += 1
print("Tour passé : " + str(self.tour))
self.player1.nextTour(self.tour)
self.player2.nextTour(self.tour)
self.changeText(l, "" + self.player1.name + " à vous !")
self.actionCallBack = True
self.action = 1
elif self.action == 40:
# Fin de partie
pass
elif self.action == 50:
self.retourCallBack('')
self.updateMain(e, l)
if (e.quit):
e.quit = True
self.retourCallBack('')
self.loader.clearFont()
return self.ReturnScene
def resizeWindow(self, l, w, h):
self.width = w
self.height = h
backgrounds = l.getAnimation('bg')
if len(backgrounds) > 0:
backgrounds[0].newPos(0, 0, self.width, self.height, 0)
self.btnPasser.resizeWindow(l, w, h)
animation = l.getAnimation('title')
if len(animation) > 0:
animation[0].newPos((self.width / 2 - animation[0].sprite.w / 2), 30, animation[0].sprite.w, animation[0].sprite.h, 0)
self.updateMain(None, l)
class GameScene(Scene):
def _start(self):
"""
Init and start new game scene
:return: None
"""
self.tileset = self.manager.get_image("tileset.png")
self.main_theme_music = self.manager.get_music("main-theme.ogg")
self.explosion_sound = self.manager.get_sound("boom.ogg")
self.width, self.height = pygame.display.get_surface().get_size()
self.track = Track()
self.obstacle = Obstacle(self.track)
self.player = Player(self.track)
self.player.attach()
self.explosion_sprite_size = 192
self.explosion_speed = 4
self.explosion = Animation(self.manager.get_image("explosion.png"),
self.explosion_sprite_size,
self.explosion_sprite_size,
self.explosion_speed)
self.is_explosion_started = False
self.settings = Settings()
self.font = pygame.font.SysFont("Monospace",
40,
bold=False,
italic=False)
self.calculate_tile_size()
self.make_threads()
def make_threads(self):
"""
Start threads to change game state
:return: None
"""
threading.Thread(target=self.update_track).start()
threading.Thread(target=self.update_move).start()
if self.settings['music']:
self.main_theme_music.play()
def update_track(self):
"""
Updating track for next game state
:return: None
"""
while not self.is_end():
if not self.obstacle.wait:
self.obstacle.attach()
self.obstacle.wait = OBSTACLE_WAIT_FOR_NEXT if not self.obstacle.wait else self.obstacle.wait - 1
if self.player.is_dead:
ScoreScene.save(self.player.score)
self.is_explosion_started = True
self.player.detach()
self.explosion.start()
if self.settings['music']:
self.explosion_sound.play()
break
self.player.detach()
self.track.move()
self.player.attach()
self.player.score += 1
if self.player.score % (SPEED_INCREASE_SCORE *
self.track.level) == 0:
self.track.speed += 1
if self.player.score % (LEVEL_INCREASE_SCORE *
self.track.level) == 0:
self.track.level += 1
self.player.lives_count = int(self.player.lives_count *
PLAYER_LIVES_INCREASE)
self.track.speed = self.track.level
track_sleep_time = TRACK_MOVE_SLEEP_TIME / self.track.get_speed()
time.sleep(track_sleep_time)
def update_move(self):
"""
Update player move, handles player position on track
:return: None
"""
while not self.is_end():
if self.player.is_dead:
break
self.player.move()
time.sleep(PLAYER_MOVE_SLEEP_TIME)
def _event(self, event):
"""
Make event handle
:param event: any occurred event
:return: None
"""
for e in event.get():
if e.type == pygame.KEYDOWN:
if e.key == pygame.K_p:
self.set_next_scene("pause")
self.the_end()
elif e.key == pygame.K_ESCAPE:
ScoreScene.save(self.player.score)
self.set_next_scene("menu")
self.the_end()
elif e.key == pygame.K_LEFT:
self.player.direction = "left"
self.player.move()
elif e.key == pygame.K_RIGHT:
self.player.direction = "right"
self.player.move()
elif e.key == pygame.K_UP:
self.track.speed += 1
elif e.key == pygame.K_DOWN:
self.track.speed -= 1
elif e.type == pygame.KEYUP:
self.player.direction = None
def _update(self, dt):
"""
Update scene by time
:param dt: time interval pass from previous call
:return: None
"""
if self.is_explosion_started:
self.explosion.update(dt)
if not self.explosion.is_start() and self.player.is_dead:
self.set_next_scene("game_over")
self.the_end()
def _draw(self, dt):
"""
Redraw game by current status
:param dt: time interval pass from previous call
:return: None
"""
self.display.fill(BACKGROUND_COLOR)
self.draw_field()
self.draw_score()
if self.explosion.is_start():
player_center = [
x - int(self.explosion_sprite_size / 2)
for x in self.player.get_center(self.tile_size)
]
self.display.blit(self.explosion.sprite, player_center,
self.explosion.get_coords())
def the_end(self):
self.main_theme_music.stop()
super().the_end()
def calculate_tile_size(self):
field_width = self.width / 2
field_height = self.height
tile_height = field_height / self.track.tiles_y
tile_width = field_width / self.track.tiles_x
self.tile_size = int(
tile_width if tile_height > tile_width else tile_height)
self.scaled_tile = pygame.transform.scale(
self.tileset, (self.tile_size * TILES_COUNT, self.tile_size))
def draw_field(self):
margin = 1
for x in range(self.track.tiles_x):
for y in range(self.track.tiles_y):
# Draw tile in (x,y)
# get rect() area; select tile from tileset
destination = Rect(x * self.tile_size, y * self.tile_size,
self.tile_size, self.tile_size)
src = Rect(self.track.tiles[x][y] * self.tile_size, 0,
self.tile_size - margin, self.tile_size - margin)
self.display.blit(self.scaled_tile, destination, src)
def draw_score(self):
x = self.width / 2 + self.tile_size
y = self.tile_size
self.display.blit(
self.font.render("Счёт: " + str(self.player.score), True,
(0, 0, 0)), (x, y))
self.display.blit(
self.font.render("Скорость: " + str(self.track.speed), True,
(0, 0, 0)), (x, y * 2))
self.display.blit(
self.font.render("Жизней: " + str(self.player.lives_count), True,
(0, 0, 0)), (x, y * 3))
self.display.blit(
self.font.render("Уровень: " + str(self.track.level), True,
(0, 0, 0)), (x, y * 4))
class Area(object):
'''
Terrain du jeux
'''
def __init__(self, namePlayer1, namePlayer2):
'''
Constructor
@param namePlayer1: Nom du joueur 1
@param namePlayer2: Nom du joueur 2
'''
self.tour = 1
self.pioche = Pioche()
deckPlayer1 = Deck("deck1", self.pioche.getDecks("deck1"))
deckPlayer2 = Deck("deck1", self.pioche.getDecks("deck2"))
self.player1 = Player(1, namePlayer1, deckPlayer1)
self.player2 = Player(2, namePlayer2, deckPlayer2)
def inputAction(self, message):
'''
Demande de saisie utilisateur
@param message: prompt
@return: int
'''
ID = -1
try:
ID = input(message + "[int]# ")
ID = int(ID)
except EOFError:
print("Saisie incorrecte EOFError=")
ID = -1
except NameError:
print("Saisie incorrecte NameError")
ID = -1
except ValueError:
print("Saisie incorrecte ValueError")
ID = -1
return ID
def gameLoop(self):
'''
Boucle du jeux
'''
stop = False
while stop == False:
if self.player1.health <= 0:
print(self.player1.name + " a perdu et " + self.player2.name + " a GAGNER !!!!")
stop = True
if self.player2.health <= 0:
print(self.player2.name + " a perdu et " + self.player1.name + " a GAGNER !!!!")
stop = True
self.playerTurn_v2(self.player1, self.player2)
self.playerTurn_v2(self.player2, self.player1)
self.tour = self.tour + 1
self.player1.nextTour(self.tour)
self.player2.nextTour(self.tour)
print("Tous le monde Pioche une carte")
try:
self.player1.piocheCarte()
except GameException as e:
print(self.player1.name + " " + str(e))
try:
self.player2.piocheCarte()
except GameException as e:
print(self.player2.name + " " + str(e))
def gameLoopNetworkHost(self, host, conn):
'''
Boucle du jeux en réseau pour l'host
'''
stop = False
while stop == False:
if self.player1.health <= 0:
print(self.player1.name + " a perdu et " + self.player2.name + " a GAGNER !!!!")
stop = True
if self.player2.health <= 0:
print(self.player2.name + " a perdu et " + self.player1.name + " a GAGNER !!!!")
stop = True
self.playerTurn_v2(self.player1, self.player2)
self = host.run(self, conn)
self.tour = self.tour + 1
self.player1.nextTour(self.tour)
self.player2.nextTour(self.tour)
print("Tous le monde Pioche une carte")
try:
self.player1.piocheCarte()
except GameException as e:
print(self.player1.name + " " + str(e))
try:
self.player2.piocheCarte()
except GameException as e:
print(self.player2.name + " " + str(e))
host.close(conn)
def gameLoopNetworkClient(self):
self.playerTurn_v2(self.player2, self.player1)
return self
def playerTurn_v2(self, player, ennemy):
'''
Les interaction du joueur pendant le tour
@param player: Joueur
@param ennemy: Joueur adverse
'''
validator = True
while validator:
print(self)
try:
ID_attack = random.randint(1,len(self.player.hand))
if player.isCarteServant(ID_attack):
# Si c'est une carte d'invocation des serviteur
player.invoke(ID_attack)
validator = self.verifActionJoueur(player)
else:
#Si ce n'est pas une carte sort
ID_target = random.randint(1,len(self.enemy.fields))
player.war(ID_attack, ID_target, ennemy)
validator = self.verifActionJoueur(player)
except GameException as e:
print(e)
def playerTurn(self, player, ennemy):
'''
Action du joueur
@param player: Joueur
@param ennemy: Joueur adverse
'''
validator = True
while validator:
print(self.toString())
ID = random.randint(1,len(self.player.hand))
elif self.isPlayer(ID):
# Si le joueur a choisie lui meme
if int(player.mana) >= 2:
ID_target = random.randint(1,len(self.enemy.fields))
player.fight(ID_target, ennemy)
validator = self.verifActionJoueur(player)
else:
print(player.name + " : Je n'ai pas suffisamment de mana")
elif self.isSpell(ID):
# Si le joueur choisie un sort
try:
ID_target = random.randint(1,len(self.enemy.fields))
player.useCarteSpell(ID, ID_target, ennemy)
validator = self.verifActionJoueur(player)
except GameException as e:
print(e)
elif player.isCarteServant(ID):
# Si le joueur a choisie d'invoquer un serviteur
try:
player.invoke(ID)
validator = self.verifActionJoueur(player)
except GameException as e:
print(e)
if input == "d": debug.set_trace()
elif input == "f": slow = False
if not result is False: return result
except:
debug.set_trace()
dump = replaydump.ReplayDump(replayfile, False)
sserver = dump.read()
seed = dump.read()
player1_name = dump.read()
my_deck = dump.read()
player2_name = dump.read()
other_deck = dump.read()
player1 = Player(player1_name, my_deck)
player2 = Player(player2_name, other_deck)
player1.dirty_input = userinput
player2.dirty_input = userinput
# Choose starting player
random.seed(seed)
dispatcher.reset()
Keeper.init([player1, player2])
# This is hacky
replaydump.players = dict([(player.name,player) for player in [player1, player2]])
replaydump.stack = Keeper.stack
msg = Keeper.start()
seed = dump_to_replay.read()
player1 = dump_to_replay.read()
my_deck = dump_to_replay.read()
player2 = dump_to_replay.read()
other_deck = dump_to_replay.read()
input = replayInput
else:
dump_to_replay = replaydump.ReplayDump(filename=replay_file, save=True)
seed = time.time()
player1 = conf.get("main", "playername")
player2 = conf.get("solitaire", "playername")
my_deck, sideboard = read_deckfile(conf.get("main", "deckfile"))
other_deck, other_sideboard = read_deckfile(
conf.get("solitaire", "deckfile"))
input = playerInput
dump_to_replay.write(True)
dump_to_replay.write(seed)
for name, deck in [(player1, my_deck), (player2, other_deck)]:
dump_to_replay.write(name)
dump_to_replay.write(deck)
players = [Player(player1, my_deck), Player(player2, other_deck)]
random.seed(seed)
for player in players:
player.dirty_input = input
replaydump.players[player.name] = player
Keeper.init(players)
Keeper.start()
def __init__(self):
self.player = Player()
self.oldText = ""
self.editWindow = tk.Tk()
self.editWindow.title = "Who Gets The Million - EDITOR"
self.menuFrame = tk.Frame(self.editWindow)
self.openButton = tk.Button(self.menuFrame, text="OPEN")
self.saveButton = tk.Button(self.menuFrame, text="SAVE")
self.newButton = tk.Button(self.menuFrame, text="NEW COLLECTION")
self.poolFrame = tk.Frame(self.editWindow)
self.currentPool = tk.StringVar(self.editWindow)
self.currentPool.set("Create new")
self.currentPool.trace("w", self.changedPool)
self.poolDropdownList = list(self.player.getPools())
self.poolDropdownList.append("Create new")
self.poolOptions = tk.OptionMenu(self.poolFrame, self.currentPool,
*self.poolDropdownList)
self.questionList = tk.Listbox(self.poolFrame)
self.newQuestionButton = tk.Button(self.poolFrame,
text="New Question",
command=self.appenQuestion)
self.editQuestionButton = tk.Button(self.poolFrame,
text="EDIT",
command=self.loadQuestion)
self.editPanel = QuestionEditPanel(self.editWindow, "OK", "50/50")
# self.questionFrame = tk.Frame(self.editWindow)
# self.currentText = tk.StringVar()
# self.textLabel = tk.Label(self.questionFrame, text="Text:")
# self.textField = tk.Entry(self.questionFrame, textvariable=self.currentText)
# self.currentAText = tk.StringVar()
# self.answerALabel = tk.Label(self.questionFrame, text="A:")
# self.answerAField = tk.Entry(self.questionFrame, textvariable=self.currentAText)
# self.answerACorrect = tk.Checkbutton(self.questionFrame, text=corr)
# self.answerAFifty = tk.Checkbutton(self.questionFrame, text=ff)
#
# self.currentBText = tk.StringVar()
# self.answerBLabel = tk.Label(self.questionFrame, text="B:")
# self.answerBField = tk.Entry(self.questionFrame, textvariable=self.currentBText)
# self.answerBCorrect = tk.Checkbutton(self.questionFrame, text=corr)
# self.answerBFifty = tk.Checkbutton(self.questionFrame, text=ff)
#
# self.currentCText = tk.StringVar()
# self.answerCLabel = tk.Label(self.questionFrame, text="C:")
# self.answerCField = tk.Entry(self.questionFrame, textvariable=self.currentCText)
# self.answerCCorrect = tk.Checkbutton(self.questionFrame, text=corr)
# self.answerCFifty = tk.Checkbutton(self.questionFrame, text=ff)
#
# self.currentDText = tk.StringVar()
# self.answerDLabel = tk.Label(self.questionFrame, text="D:")
# self.answerDField = tk.Entry(self.questionFrame, textvariable=self.currentDText)
# self.answerDCorrect = tk.Checkbutton(self.questionFrame, text=corr)
# self.answerDFifty = tk.Checkbutton(self.questionFrame, text=ff)
#
# self.buttonFrame = tk.Frame(self.questionFrame)
# self.applyButton = tk.Button(self.buttonFrame, text="APPLY", command=self.applyQuestion)
# self.deleteButton = tk.Button(self.buttonFrame, text="DELETE")
# Setup window
self.newButton.pack(side=tk.LEFT)
self.openButton.pack(side=tk.LEFT)
self.saveButton.pack(side=tk.LEFT)
self.menuFrame.pack(side=tk.TOP, anchor=tk.W)
self.poolOptions.pack(side=tk.TOP, fill=tk.X)
self.questionList.pack(side=tk.TOP, fill=tk.X)
self.newQuestionButton.pack(side=tk.LEFT, anchor=tk.SW, fill=tk.X)
self.editQuestionButton.pack(side=tk.RIGHT, anchor=tk.SE, fill=tk.X)
self.poolFrame.pack(side=tk.LEFT)
# self.textLabel.grid(row=0)
# self.answerALabel.grid(row=1)
# self.answerBLabel.grid(row=2)
# self.answerCLabel.grid(row=3)
# self.answerDLabel.grid(row=4)
# # self.textField.grid(row=0, column=1)
# self.answerAField.grid(row=1, column=1)
# self.answerBField.grid(row=2, column=1)
# self.answerCField.grid(row=3, column=1)
# self.answerDField.grid(row=4, column=1)
# self.answerACorrect.grid(row=1, column=2)
# self.answerBCorrect.grid(row=2, column=2)
# self.answerCCorrect.grid(row=3, column=2)
# self.answerDCorrect.grid(row=4, column=2)
# self.answerAFifty.grid(row=1, column=3)
# self.answerBFifty.grid(row=2, column=3)
# self.answerCFifty.grid(row=3, column=3)
# self.answerDFifty.grid(row=4, column=3)
#
# self.applyButton.pack(side=tk.LEFT, anchor=tk.W, fill=tk.X)
# self.deleteButton.pack(side=tk.RIGHT, anchor=tk.E, fill=tk.X)
# self.buttonFrame.grid(row=5, columnspan=4)
#
# self.questionFrame.pack(side=tk.RIGHT, anchor=tk.NW)
# start looping
self.editWindow.mainloop()
class EditorUi:
def __init__(self):
self.player = Player()
self.oldText = ""
self.editWindow = tk.Tk()
self.editWindow.title = "Who Gets The Million - EDITOR"
self.menuFrame = tk.Frame(self.editWindow)
self.openButton = tk.Button(self.menuFrame, text="OPEN")
self.saveButton = tk.Button(self.menuFrame, text="SAVE")
self.newButton = tk.Button(self.menuFrame, text="NEW COLLECTION")
self.poolFrame = tk.Frame(self.editWindow)
self.currentPool = tk.StringVar(self.editWindow)
self.currentPool.set("Create new")
self.currentPool.trace("w", self.changedPool)
self.poolDropdownList = list(self.player.getPools())
self.poolDropdownList.append("Create new")
self.poolOptions = tk.OptionMenu(self.poolFrame, self.currentPool,
*self.poolDropdownList)
self.questionList = tk.Listbox(self.poolFrame)
self.newQuestionButton = tk.Button(self.poolFrame,
text="New Question",
command=self.appenQuestion)
self.editQuestionButton = tk.Button(self.poolFrame,
text="EDIT",
command=self.loadQuestion)
self.editPanel = QuestionEditPanel(self.editWindow, "OK", "50/50")
# self.questionFrame = tk.Frame(self.editWindow)
# self.currentText = tk.StringVar()
# self.textLabel = tk.Label(self.questionFrame, text="Text:")
# self.textField = tk.Entry(self.questionFrame, textvariable=self.currentText)
# self.currentAText = tk.StringVar()
# self.answerALabel = tk.Label(self.questionFrame, text="A:")
# self.answerAField = tk.Entry(self.questionFrame, textvariable=self.currentAText)
# self.answerACorrect = tk.Checkbutton(self.questionFrame, text=corr)
# self.answerAFifty = tk.Checkbutton(self.questionFrame, text=ff)
#
# self.currentBText = tk.StringVar()
# self.answerBLabel = tk.Label(self.questionFrame, text="B:")
# self.answerBField = tk.Entry(self.questionFrame, textvariable=self.currentBText)
# self.answerBCorrect = tk.Checkbutton(self.questionFrame, text=corr)
# self.answerBFifty = tk.Checkbutton(self.questionFrame, text=ff)
#
# self.currentCText = tk.StringVar()
# self.answerCLabel = tk.Label(self.questionFrame, text="C:")
# self.answerCField = tk.Entry(self.questionFrame, textvariable=self.currentCText)
# self.answerCCorrect = tk.Checkbutton(self.questionFrame, text=corr)
# self.answerCFifty = tk.Checkbutton(self.questionFrame, text=ff)
#
# self.currentDText = tk.StringVar()
# self.answerDLabel = tk.Label(self.questionFrame, text="D:")
# self.answerDField = tk.Entry(self.questionFrame, textvariable=self.currentDText)
# self.answerDCorrect = tk.Checkbutton(self.questionFrame, text=corr)
# self.answerDFifty = tk.Checkbutton(self.questionFrame, text=ff)
#
# self.buttonFrame = tk.Frame(self.questionFrame)
# self.applyButton = tk.Button(self.buttonFrame, text="APPLY", command=self.applyQuestion)
# self.deleteButton = tk.Button(self.buttonFrame, text="DELETE")
# Setup window
self.newButton.pack(side=tk.LEFT)
self.openButton.pack(side=tk.LEFT)
self.saveButton.pack(side=tk.LEFT)
self.menuFrame.pack(side=tk.TOP, anchor=tk.W)
self.poolOptions.pack(side=tk.TOP, fill=tk.X)
self.questionList.pack(side=tk.TOP, fill=tk.X)
self.newQuestionButton.pack(side=tk.LEFT, anchor=tk.SW, fill=tk.X)
self.editQuestionButton.pack(side=tk.RIGHT, anchor=tk.SE, fill=tk.X)
self.poolFrame.pack(side=tk.LEFT)
# self.textLabel.grid(row=0)
# self.answerALabel.grid(row=1)
# self.answerBLabel.grid(row=2)
# self.answerCLabel.grid(row=3)
# self.answerDLabel.grid(row=4)
# # self.textField.grid(row=0, column=1)
# self.answerAField.grid(row=1, column=1)
# self.answerBField.grid(row=2, column=1)
# self.answerCField.grid(row=3, column=1)
# self.answerDField.grid(row=4, column=1)
# self.answerACorrect.grid(row=1, column=2)
# self.answerBCorrect.grid(row=2, column=2)
# self.answerCCorrect.grid(row=3, column=2)
# self.answerDCorrect.grid(row=4, column=2)
# self.answerAFifty.grid(row=1, column=3)
# self.answerBFifty.grid(row=2, column=3)
# self.answerCFifty.grid(row=3, column=3)
# self.answerDFifty.grid(row=4, column=3)
#
# self.applyButton.pack(side=tk.LEFT, anchor=tk.W, fill=tk.X)
# self.deleteButton.pack(side=tk.RIGHT, anchor=tk.E, fill=tk.X)
# self.buttonFrame.grid(row=5, columnspan=4)
#
# self.questionFrame.pack(side=tk.RIGHT, anchor=tk.NW)
# start looping
self.editWindow.mainloop()
def loadQuestionList(self, difficultie=0):
self.questionList.delete(0, tk.END)
questions = self.player.collection.getQuestions(difficultie)
for i, e in enumerate(questions):
self.questionList.insert(i, e["text"])
def changedPool(self, *args):
print(self.currentPool.get())
if self.currentPool.get() == "Create new":
self.poolDropdownList.append(str(len(self.poolDropdownList) - 1))
self.currentPool.set(str(len(self.poolDropdownList) - 2))
self.updateDropdown()
else:
pass
# self.loadQuestionList(int(self.currentPool.get()))
def updateDropdown(self):
menu = self.poolOptions["menu"]
menu.delete(0, tk.END)
# print(self.poolDropdownList)
for i in self.poolDropdownList:
# print("Set {}".format(i))
menu.add_command(
label=str(i),
command=lambda value=str(i): self.currentPool.set(value))
def appenQuestion(self):
self.player.collection.append(int(self.currentPool.get()),
"New question")
self.loadQuestionList(int(self.currentPool.get()))
def loadQuestion(self):
q = self.player.collection.getQuestionByText(
int(self.currentPool.get()),
self.questionList.get(self.questionList.curselection()))
# print("q = {}".format(q))
self.oldText = q["text"]
self.currentText.set(q["text"])
self.currentAText.set(q["a"])
self.currentBText.set(q["b"])
self.currentCText.set(q["c"])
self.currentDText.set(q["d"])
def applyQuestion(self):
self.player.collection.editQuestionByText(self.oldText,
self.currentText.get(),
self.currentAText.get(),
self.currentBText.get(),
self.currentCText.get(),
self.currentDText.get(),
self.mkCorrect(),
self.mkFiftyFifty())
def mkCorrect(self):
pass
def mkFiftyFifty(self):
pass
class Area(object):
'''
Terrain du jeux
'''
def __init__(self, namePlayer1, namePlayer2):
'''
Constructor
@param namePlayer1: Nom du joueur 1
@param namePlayer2: Nom du joueur 2
'''
self.tour = 1
self.pioche = Pioche()
deckPlayer1 = Deck("deck1", self.pioche.getDecks("deck1"))
deckPlayer2 = Deck("deck1", self.pioche.getDecks("deck2"))
self.player1 = Player(1, namePlayer1, deckPlayer1)
self.player2 = Player(2, namePlayer2, deckPlayer2)
def inputAction(self, message):
'''
Demande de saisie utilisateur
@param message: prompt
@return: int
'''
ID = -1
try:
ID = input(message + "[int]# ")
ID = int(ID)
except EOFError:
print("Saisie incorrecte EOFError=")
ID = -1
except NameError:
print("Saisie incorrecte NameError")
ID = -1
except ValueError:
print("Saisie incorrecte ValueError")
ID = -1
return ID
def gameLoop(self):
'''
Boucle du jeux
'''
stop = False
while stop == False:
if self.player1.health <= 0:
print(self.player1.name + " a perdu et " + self.player2.name + " a GAGNER !!!!")
stop = True
if self.player2.health <= 0:
print(self.player2.name + " a perdu et " + self.player1.name + " a GAGNER !!!!")
stop = True
self.playerTurn_v2(self.player1, self.player2)
#self.playerTurnIA(self.player2, self.player1)
self.playerTurnIA(self.player2, self.player1)
self.tour = self.tour + 1
self.player1.nextTour(self.tour)
self.player2.nextTour(self.tour)
print("Tous le monde Pioche une carte")
try:
self.player1.piocheCarte()
except GameException as e:
print(self.player1.name + " " + str(e))
try:
self.player2.piocheCarte()
except GameException as e:
print(self.player2.name + " " + str(e))
def gameLoopNetworkHost(self, host, conn):
'''
Boucle du jeux en réseau pour l'host
'''
stop = False
while stop == False:
if self.player1.health <= 0:
print(self.player1.name + " a perdu et " + self.player2.name + " a GAGNER !!!!")
stop = True
if self.player2.health <= 0:
print(self.player2.name + " a perdu et " + self.player1.name + " a GAGNER !!!!")
stop = True
self.playerTurn_v2(self.player1, self.player2)
self = host.run(self, conn)
self.tour = self.tour + 1
self.player1.nextTour(self.tour)
self.player2.nextTour(self.tour)
print("Tous le monde Pioche une carte")
try:
self.player1.piocheCarte()
except GameException as e:
print(self.player1.name + " " + str(e))
try:
self.player2.piocheCarte()
except GameException as e:
print(self.player2.name + " " + str(e))
host.close(conn)
def gameLoopNetworkClient(self):
self.playerTurn_v2(self.player2, self.player1)
return self
def playerTurn_v2(self, player, ennemy):
'''
Les interaction du joueur pendant le tour
@param player: Joueur
@param ennemy: Joueur adverse
'''
validator = True
while validator:
self.player1.enterrerServiteurs()
self.player2.enterrerServiteurs()
print(self)
try:
ID_attack = self.inputAction("<" + player.name + "> Id carte ou serviteur [passer=0]")
if int(ID_attack) == 0:
# Si le joueur souhaite passer son tour
print(player.name + " passe son tour")
validator = False
elif int(ID_attack) < 0:
print("Saisie incorrecte")
else:
if player.isCarteServant(ID_attack):
# Si c'est une carte d'invocation des serviteur
player.invoke(ID_attack)
validator = self.verifActionJoueur(player)
else:
#Si ce n'est pas une carte sort
ID_target = self.inputAction(player.name + " : entrer de la cible [annuler=0]")
if int(ID_target) == 0:
pass
else:
player.war(ID_attack, ID_target, ennemy)
validator = self.verifActionJoueur(player)
except GameException as e:
print(e)
def choiseTargetIA(self, ennemy):
'''
Choisie le cible a attaquer
'''
ID_Target = 2
if len(ennemy.fields) > 0:
for ID_serv in ennemy.fields:
if ennemy.fields[ID_serv].camouflage != True:
ID_Target = ID_serv
return ID_Target
def playerTurnIA(self, player, ennemy):
'''
Action du joueur
@param player: Joueur
@param ennemy: Joueur adverse
'''
self.player1.enterrerServiteurs()
self.player2.enterrerServiteurs()
if len(player.fields):
print("Attaques des serviteur")
for ID_serv in player.fields:
if player.fields[ID_serv].action == True:
ID_Target = self.choiseTargetIA(ennemy)
player.fields[ID_serv].fight(ID_Target, ennemy)
print("Attaques du joueur")
ID_Carte = 0
#go = False
for carte in player.hand:
if player.hand[carte].cost <= player.mana and player.isCarteServant(carte):
print("IA choisie " + carte)
ID_Carte = carte
break
if ID_Carte != 0:
print("IA utilise " + carte)
player.invoke(carte)
ID_Carte = 0
ID_Target = 0
for carte in player.hand:
if player.hand[carte].cost <= player.mana:
#print(player.hand[carte])
if player.isSpell(carte):
ID_Target = self.choiseTargetIA(ennemy)
ID_Carte = carte
if ID_Target != 0:
player.useCarteSpell(ID_Carte, ID_Target, ennemy)
'''
ID = self.inputAction("<" + player.name + "> Id carte ou serviteur [passer=0]")
if int(ID) == 0:
#Passer le tour
validator = False
elif self.isPlayer(ID):
# Si le joueur a choisie lui meme
if int(player.mana) >= 2:
ID_target = self.inputAction(player.name + " : entrer de la cible [passer=0]")
player.fight(ID_target, ennemy)
validator = self.verifActionJoueur(player)
else:
print(player.name + " : Je n'ai pas suffisamment de mana")
elif self.isSpell(ID):
# Si le joueur choisie un sort
try:
ID_target = self.inputAction(player.name + " : entrer de la cible [passer=0]")
player.useCarteSpell(ID, ID_target, ennemy)
validator = self.verifActionJoueur(player)
except GameException as e:
print(e)
elif player.isCarteServant(ID):
# Si le joueur a choisie d'invoquer un serviteur
try:
player.invoke(ID)
validator = self.verifActionJoueur(player)
except GameException as e:
print(e)
elif self.isServant(ID):
try:
ID_target = self.inputAction(player.name + " : entrer de la cible (0 pour passer) ")
servant = player.getServiteur(ID)
servant.fight(ID_target, ennemy)
validator = self.verifActionJoueur(player)
except GameException as e:
print(e)
else:
print("Saisie incorrecte ()")
self.player1.enterrerServiteurs()
self.player2.enterrerServiteurs()
'''
def playerTurn(self, player, ennemy):
'''
Action du joueur
@param player: Joueur
@param ennemy: Joueur adverse
'''
validator = True
while validator:
print(self.toString())
ID = self.inputAction("<" + player.name + "> Id carte ou serviteur [passer=0]")
if int(ID) == 0:
#Passer le tour
validator = False
elif self.isPlayer(ID):
# Si le joueur a choisie lui meme
if int(player.mana) >= 2:
ID_target = self.inputAction(player.name + " : entrer de la cible [passer=0]")
player.fight(ID_target, ennemy)
validator = self.verifActionJoueur(player)
else:
print(player.name + " : Je n'ai pas suffisamment de mana")
elif self.isSpell(ID):
# Si le joueur choisie un sort
try:
ID_target = self.inputAction(player.name + " : entrer de la cible [passer=0]")
player.useCarteSpell(ID, ID_target, ennemy)
validator = self.verifActionJoueur(player)
except GameException as e:
print(e)
elif player.isCarteServant(ID):
# Si le joueur a choisie d'invoquer un serviteur
try:
player.invoke(ID)
validator = self.verifActionJoueur(player)
except GameException as e:
print(e)
elif self.isServant(ID):
try:
ID_target = self.inputAction(player.name + " : entrer de la cible (0 pour passer) ")
servant = player.getServiteur(ID)
servant.fight(ID_target, ennemy)
validator = self.verifActionJoueur(player)
except GameException as e:
print(e)
else:
print("Saisie incorrecte ()")
self.player1.enterrerServiteurs()
self.player2.enterrerServiteurs()
def verifActionJoueur(self, joueur):
'''
Verifie si l'utilisateur peut encore faire des actions
@param joueur: Le joueur
'''
flag = False
if int(joueur.mana) > 0: # Si le joueur n'a plus de mana
if joueur.action == True:
flag = True
for key in joueur.fields:
if joueur.fields[key].action == True:
flag = True
return flag
def toString(self):
txt = "\n\n@@@@@@@@@@@@@@@ --------------- TOUR " + str(self.tour) + " --------------- @@@@@@@@@@@@@@@\n"
txt += "ID=" + str(self.player1)
txt += "ID=" + str(self.player2)
return txt + "\n"
def toString_v2(self):
txt = "\n\n@@@@@@@@@@@@@@@ --------------- TOUR " + str(self.tour) + " --------------- @@@@@@@@@@@@@@@\n"
txt += "ID=" + str(self.player1)
txt += "ID=" + str(self.player2.ID) + ":" + str(self.player2.name) + ":[" + str(self.player2.mana) + "pm, " + str(self.player2.health) + "pv, a=" + str(self.player2.action) + "] "
txt += " Fields :\n"
for key in self.player2.fields:
txt += "\t" + str(self.player2.fields[key]) + "\n"
return txt + "}\n"
def __str__(self):
return self.toString_v2()
def setPlayer1(self, player1):
self.player1 = player1
def setPlayer2(self, player2):
self.player2 = player2
def getPlayer1(self):
return self.player1
def getPlayer2(self):
return self.player2
def getTour(self):
return self.tour
