def __init__(self, root):
self.root = root
#Knapparnas-container
self.menu = Frame(self.root)
self.menu.pack()
#Ny-omgång knappen
self.newGameButton = Button(self.menu,
height=1,
width=20,
text="Ny spelomgång")
self.newGameButton.bind("<Button-1>", self.newGame)
self.newGameButton.pack(side=LEFT)
#highscore-knappen
self.highscoreButton = Button(self.menu,
height=1,
width=20,
text="Toggla Highscores")
self.highscoreButton.bind("<Button-1>", self.toggleHighscore)
self.highscoreButton.pack(side=LEFT)
#Highscore-vyn
self.highscoreView = Highscore(self.root, "highscores.txt")
self.highscoreBool = False
#Spel-vyn
self.gameView = ChessBoard(self, self.root)
self.gameView.container.pack()
def __init__(self, window, game_menu):
self._window = window
self._game_menu = game_menu
self._font = settings.defaultFont
self._highscore = Highscore()
self._name = ""
self._titletext = sf.Text("Game Over", self._font, 50)
self._titletext_left = sf.Text("Game Over", self._font, 50)
self._titletext_up = sf.Text("Game Over", self._font, 50)
self._titletext_right = sf.Text("Game Over", self._font, 50)
self._titletext_down = sf.Text("Game Over", self._font, 50)
self._titletext_left.color = sf.Color.BLACK
self._titletext_up.color = sf.Color.BLACK
self._titletext_right.color = sf.Color.BLACK
self._titletext_down.color = sf.Color.BLACK
self._titletext.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,50)
self._titletext_left.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2-1.5,50)
self._titletext_up.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,50-1.5)
self._titletext_right.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2+1.5,50)
self._titletext_down.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,50+1.5)
self._scoretext = sf.Text("Points "+str(self._game_menu._points), self._font, 50)
self._enternametext = sf.Text("Enter Name!", self._font, 50)
self._enternametext_left = sf.Text("Enter Name!", self._font, 50)
self._enternametext_up = sf.Text("Enter Name!", self._font, 50)
self._enternametext_right = sf.Text("Enter Name!", self._font, 50)
self._enternametext_down = sf.Text("Enter Name!", self._font, 50)
self._enternametext.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,250)
self._enternametext_left.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2-1.5,250)
self._enternametext_up.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,250-1.5)
self._enternametext_right.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2+1.5,250)
self._enternametext_down.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,250+1.5)
self._enternametext_left.color = sf.Color.BLACK
self._enternametext_up.color = sf.Color.BLACK
self._enternametext_right.color = sf.Color.BLACK
self._enternametext_down.color = sf.Color.BLACK
self._nametext = sf.Text(self._name, self._font, 50)
self._nametext_left = sf.Text(self._name, self._font, 50)
self._nametext_up = sf.Text(self._name, self._font, 50)
self._nametext_right = sf.Text(self._name, self._font, 50)
self._nametext_down = sf.Text(self._name, self._font, 50)
self._nametext.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,350)
self._nametext_left.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2-1.5,350)
self._nametext_up.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,350-1.5)
self._nametext_right.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2+1.5,350)
self._nametext_down.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,350+1.5)
self._nametext_left.color = sf.Color.BLACK
self._nametext_up.color = sf.Color.BLACK
self._nametext_right.color = sf.Color.BLACK
self._nametext_down.color = sf.Color.BLACK
#backbutton
self._okbutton = Button(sf.Vector2((self._window.size[0]-150)/2,(self._window.size[1]-50)), #position
sf.Vector2(150,20), #size
sf.Color.GREEN, #background color
sf.Color.BLACK, #text color
sf.Color.RED, #outline color
2, #outline thickness
"OK", #lable
self._font, #font
17) #text size
def end_game(self, player):
"""Call other methods to process game ending."""
self.score = Highscore(self.player1, self.player2)
# self.score.write_highscore()
self.set_game_status(False)
print("WOW! Congra {} you won the game!".format(player.get_name()))
self.histogram.print_histogram(self.player1, self.player2)
self.score.write_file()
def setUp(self):
"""Run at the beginning of the test."""
self.game = Game()
self.game.set_game_status(True)
self.dice = Dice()
self.player1 = Player(str, bool)
self.player2 = Player(str, bool)
self.computer_player = Player(str, bool)
self.highscore = Highscore(self.player1, self.player2)
def setUp(self):
"""Run at the beginning of the test."""
self.game = Game()
self.mock_player1 = Mock(spec=Player, name="player1",
score=42, decision=False)
self.mock_player2 = Mock(spec=Player, name="Computer",
score=65, decision=True)
self.assertIsInstance(self.mock_player1, Player)
self.assertIsInstance(self.mock_player2, Player)
self.score = Highscore(self.mock_player1, self.mock_player2)
def enter():
global player, life, scoreLabel
bg = Background()
game_world.add_object(bg, game_world.layer_bg)
player = Player()
game_world.add_object(player, game_world.layer_player)
life = Life()
bg.target = player
label = ui.Label("Score: 0", 35, get_canvas_height() - 55, 45, ui.FONT_2)
label.color = (255, 127, 127)
ui.labels.append(label)
scoreLabel = label
global highscore
highscore = Highscore()
global music_bg, wav_bomb, wav_item
music_bg = load_music('background.mp3')
wav_bomb = load_wav('explosion.wav')
wav_item = load_wav('item.wav')
game_world.isPaused = isPaused
ready_game()
global gameOverImage
gameOverImage = load_image('game_over.png')
def end_game():
global gameState, player, highscore
gameState = GAMESTETE_GAMEOVER
highscore.add(Highscore.Entry(player.score))
global music_bg
music_bg.stop()
def __init__(self,root):
self.root = root
#Knapparnas-container
self.menu = Frame(self.root)
self.menu.pack()
#Ny-omgång knappen
self.newGameButton = Button(self.menu,height=1,width=20,text="Ny spelomgång")
self.newGameButton.bind("<Button-1>",self.newGame)
self.newGameButton.pack(side=LEFT)
#highscore-knappen
self.highscoreButton = Button(self.menu,height=1,width=20,text="Toggla Highscores")
self.highscoreButton.bind("<Button-1>",self.toggleHighscore)
self.highscoreButton.pack(side=LEFT)
#Highscore-vyn/modulen
self.highscoreView = Highscore(self.root,"highscores.txt")
self.highscoreBool = False
#Spel-vyn/modulen
self.gameView = ChessBoard(self,self.root)
self.gameView.container.pack()
#Absolut noll dokumentation på tkinter.simpledialog. Denna ruta presenterar programmet. Ingen input är nödvändig.
tkinter.simpledialog.askstring("Info", "I detta spel rör du sig som en springare \npå ett shackbräde. Du får bara gå på \n varje ruta en gång och målet är att gå \nså många steg som möjligt. \n\nKlicka OK för att köra!")
def main():
player = AudioPlayer()
player.play()
tetris_environment = TetrisEnvironment()
timer = 0
reward = 0
with keyboard.Listener(on_press=on_press,
on_release=on_release) as listener:
while not tetris_environment.gameover:
if input_queue.qsize() > 0:
key = input_queue.get()
if key == 'q':
print('Exit the GAME')
break
elif key == 'a' or key == '\x1b[D' or key == keyboard.Key.left:
reward = tetris_environment.move_left()
elif key == 'd' or key == '\x1b[C' or key == keyboard.Key.right:
reward = tetris_environment.move_right()
elif key == 's' or key == '\x1b[B' or key == keyboard.Key.down:
reward = tetris_environment.drop()
elif key == 'w' or key == '\x1b[A' or key == '.' or key == keyboard.Key.up:
reward = tetris_environment.rotate_right()
elif key == ',':
reward = tetris_environment.rotate_left()
draw_board(tetris_environment)
print('Reward: {}'.format(reward))
if timer % FPS == 0:
reward = tetris_environment.wait()
draw_board(tetris_environment)
print('Reward: {}'.format(reward))
timer += 1
time.sleep(1 / FPS)
player.stop()
print('GAME OVER')
print('YOUR SCORE: {0}'.format(tetris_environment.score))
print('')
highscore = Highscore()
highscore.write(tetris_environment.score)
print(highscore)
exit(0)
class MainView(): #Klassens huvud-vy. Samlar ihop och bestämmer layout av de andra modulerna.
def __init__(self,root):
self.root = root
#Knapparnas-container
self.menu = Frame(self.root)
self.menu.pack()
#Ny-omgång knappen
self.newGameButton = Button(self.menu,height=1,width=20,text="Ny spelomgång")
self.newGameButton.bind("<Button-1>",self.newGame)
self.newGameButton.pack(side=LEFT)
#highscore-knappen
self.highscoreButton = Button(self.menu,height=1,width=20,text="Toggla Highscores")
self.highscoreButton.bind("<Button-1>",self.toggleHighscore)
self.highscoreButton.pack(side=LEFT)
#Highscore-vyn/modulen
self.highscoreView = Highscore(self.root,"highscores.txt")
self.highscoreBool = False
#Spel-vyn/modulen
self.gameView = ChessBoard(self,self.root)
self.gameView.container.pack()
#Absolut noll dokumentation på tkinter.simpledialog. Denna ruta presenterar programmet. Ingen input är nödvändig.
tkinter.simpledialog.askstring("Info", "I detta spel rör du sig som en springare \npå ett shackbräde. Du får bara gå på \n varje ruta en gång och målet är att gå \nså många steg som möjligt. \n\nKlicka OK för att köra!")
def finished(self,score): #Kallas från self.gameView när det inte finns några möjliga förflyttningar
index = self.highscoreView.finishedGame(score)
self.toggleHighscore() #Visar automatiskt highscore-vyn när en omgång är över.
#När ny-omgång knappen klickas är det denna funktion som anropas. Startar en ny omgång.
def newGame(self,event):
if self.highscoreBool :
self.highscoreView.container.pack_forget()
self.highscoreBool = not self.highscoreBool
self.gameView.container.pack_forget()
self.gameView.container.destroy()
self.gameView = ChessBoard(self,self.root) #Ny instans av ChessBoard.
self.gameView.container.pack()
def toggleHighscore(self,event=None): #Togglar visning av highscore/spelvyn
if self.highscoreBool :
self.highscoreView.container.pack_forget()
self.gameView.container.pack()
else:
self.highscoreView.container.pack()
self.gameView.container.pack_forget()
self.highscoreBool = not self.highscoreBool #Switchar Boolean-värde
def __init__(self):
"""Initialize instances from other classes."""
self.computer_controlar = False
self.dice = Dice()
# Changable value
self.forbidden_face = 1
self.player1 = Player(str, bool)
self.player2 = Player(str, bool)
self.set_playing_now(self.player1)
# Basically, player2 may be computer in case user decided.
# However, computer_player object has been added to make the
# code easier to read. Since computer controlled by another class.
self.computer_player = Player("Computer", bool)
self.computer_player.set_level("easy")
self.score = Highscore(self.player1, self.player2)
self.histogram = Histogram()
class MainView(): #Main view of the program. Ties the game & highscore-views together.
def __init__(self,root):
self.root = root
#Knapparnas-container
self.menu = Frame(self.root)
self.menu.pack()
#Ny-omgång knappen
self.newGameButton = Button(self.menu,height=1,width=20,text="Ny spelomgång")
self.newGameButton.bind("<Button-1>",self.newGame)
self.newGameButton.pack(side=LEFT)
#highscore-knappen
self.highscoreButton = Button(self.menu,height=1,width=20,text="Toggla Highscores")
self.highscoreButton.bind("<Button-1>",self.toggleHighscore)
self.highscoreButton.pack(side=LEFT)
#Highscore-vyn
self.highscoreView = Highscore(self.root,"highscores.txt")
self.highscoreBool = False
#Spel-vyn
self.gameView = ChessBoard(self,self.root)
self.gameView.container.pack()
def finished(self,score): #Kallas från self.gameView när det inte finns några möjliga förflyttningar
index = self.highscoreView.finishedGame(score)
self.toggleHighscore() #Visar automatiskt highscore när en omgång är över.
#Creates a new game instance.
def newGame(self,event):
if self.highscoreBool :
self.highscoreView.container.pack_forget()
self.highscoreBool = not self.highscoreBool
self.gameView.container.pack_forget()
self.gameView.container.destroy()
self.gameView = ChessBoard(self,self.root) #Ny instans av ChessBoard.
self.gameView.container.pack()
def toggleHighscore(self,event=None): #Togglar visning av highscore/spelvyn
if self.highscoreBool :
self.highscoreView.container.pack_forget()
self.gameView.container.pack()
else:
self.highscoreView.container.pack()
self.gameView.container.pack_forget()
self.highscoreBool = not self.highscoreBool
def __init__(self, root):
self.root = root
#Knapparnas-container
self.menu = Frame(self.root)
self.menu.pack()
#Ny-omgång knappen
self.newGameButton = Button(self.menu,
height=1,
width=20,
text="Ny spelomgång")
self.newGameButton.bind("<Button-1>", self.newGame)
self.newGameButton.pack(side=LEFT)
#highscore-knappen
self.highscoreButton = Button(self.menu,
height=1,
width=20,
text="Toggla Highscores")
self.highscoreButton.bind("<Button-1>", self.toggleHighscore)
self.highscoreButton.pack(side=LEFT)
#Highscore-vyn/modulen
self.highscoreView = Highscore(self.root, "highscores.txt")
self.highscoreBool = False
#Spel-vyn/modulen
self.gameView = ChessBoard(self, self.root)
self.gameView.container.pack()
#Absolut noll dokumentation på tkinter.simpledialog. Denna ruta presenterar programmet. Ingen input är nödvändig.
tkinter.simpledialog.askstring(
"Info",
"I detta spel rör du sig som en springare \npå ett shackbräde. Du får bara gå på \n varje ruta en gång och målet är att gå \nså många steg som möjligt. \n\nKlicka OK för att köra!"
)
def __init__(self, window, game_menu):
self._window = window
self._game_menu = game_menu
self._font = settings.defaultFont
self._score = Highscore().getScore()
#backbutton
self._backbutton = Button(
sf.Vector2(20, (self._window.size[1] - 50)), #position
sf.Vector2(150, 20), #size
sf.Color.GREEN, #background color
sf.Color.BLACK, #text color
sf.Color.RED, #outline color
2, #outline thickness
"Back", #lable
self._font, #font
17) #text size
def enter():
global player, life, scoreStatic, scoreLabel
bg = Background()
game_world.add_object(bg, game_world.layer_bg)
player = Player()
game_world.add_object(player, game_world.layer_player)
life = Life()
global ball
ball = Ball(400, 400, 1, 1)
game_world.add_object(ball, game_world.layer_player)
global wall
wall = Wall()
game_world.add_object(wall, game_world.layer_bg)
bg.target = player
global stage_number
stage_number = 1
cw = get_canvas_width()
ch = get_canvas_height()
label = ui.Label("Score:", cw - 200, ch - 55, 36, ui.FONT_2)
label.color = (255, 191, 127)
ui.labels.append(label)
scoreStatic = label
label = ui.Label("0", cw - 200, ch - 100, 36, ui.FONT_2)
label.color = (255, 191, 127)
ui.labels.append(label)
scoreLabel = label
global highscore
highscore = Highscore()
global music_bg, wav_bomb, wav_item
# music_bg = load_music('background.mp3')
# wav_bomb = load_wav('explosion.wav')
# wav_item = load_wav('item.wav')
game_world.isPaused = isPaused
ready_game()
global gameOverImage
def __init__(self):
ShowBase.__init__(self)
# Set the frame rate lock
# We need to set globalClock rate to 30' because it looks
# like the AI is affected by the frame rate.
# the higher the rate the faster they move depending on
# your pc.
globalClock.setMode(ClockObject.MLimited)
globalClock.setFrameRate(30)
self.win.setClearColor(Vec4(0.12,0.43,0.18,1))
self.disableMouse()
self.player = Player(self)
self.enemyList = []
self.maxEnemyCount = 15
self.itemList = []
self.maxItemCount = 4
self.level = Level()
self.enemyParent = render.attachNewNode("EnemyParent")
self.enemyParent.setH(180)
self.enemyStrength = 0
self.itemParent = render.attachNewNode("ItemParent")
self.mouse = Mouse(self.level.planeNP)
random.seed()
self.gameStarted = False
# Setup Gui
self.mainMenu = MainScreen()
self.mainMenu.show()
self.highscore = Highscore()
# Menu events
self.accept("escape", self.quit)
self.accept("MainMenu_start", self.start)
self.accept("Highscore_show", self.highscore.show)
self.accept("MainMenu_quit", self.quit)
self.accept("Highscore_back", self.mainMenu.show)
# ingame events
self.accept("killEnemy", self.removeEnemy)
self.accept("pickedUpHealth", self.removeItem)
self.accept("pickedUpWeapon", self.removeItem)
class TestHigscore(unittest.TestCase):
"""Test Higscore Class."""
def setUp(self):
"""Run at the beginning of the test."""
self.game = Game()
self.mock_player1 = Mock(spec=Player, name="player1",
score=42, decision=False)
self.mock_player2 = Mock(spec=Player, name="Computer",
score=65, decision=True)
self.assertIsInstance(self.mock_player1, Player)
self.assertIsInstance(self.mock_player2, Player)
self.score = Highscore(self.mock_player1, self.mock_player2)
def test_write_file(self):
"""Test write_file."""
self.player1 = Player("score1", False)
self.game.set_playing_now(self.game.player1)
self.player1.change_score(5)
self.score.write_file()
self.player2_name = Player("score2", False)
self.game.set_playing_now(self.game.player2)
self.player1.change_score(4)
def test_read_file(self):
"""Test read_file."""
self.score.get_path()
catch_output = io.StringIO()
sys.stdout = catch_output
self.score.read_file()
sys.stdout = sys.__stdout__
output = catch_output.getvalue()
self.assertIn("player name: ", output)
self.assertIn(" (score) -> ", output)
def test_get_path(self):
"""Test get_path."""
exp = self.score.get_path()
self.assertTrue(exp, 'score.txt')
def __init__(self,root):
self.root = root
#Knapparnas-container
self.menu = Frame(self.root)
self.menu.pack()
#Ny-omgång knappen
self.newGameButton = Button(self.menu,height=1,width=20,text="Ny spelomgång")
self.newGameButton.bind("<Button-1>",self.newGame)
self.newGameButton.pack(side=LEFT)
#highscore-knappen
self.highscoreButton = Button(self.menu,height=1,width=20,text="Toggla Highscores")
self.highscoreButton.bind("<Button-1>",self.toggleHighscore)
self.highscoreButton.pack(side=LEFT)
#Highscore-vyn
self.highscoreView = Highscore(self.root,"highscores.txt")
self.highscoreBool = False
#Spel-vyn
self.gameView = ChessBoard(self,self.root)
self.gameView.container.pack()
def test_end_game(self):
"""Test end_game."""
histogram = Histogram()
score = Highscore(self.game.player1, self.game.player2)
self.game.set_game_status(False)
self.assertIsInstance(histogram, Histogram)
# self.assertFalse(self.game.get_game_status())
self.assertIsInstance(score, Highscore)
# The folling two lines work find to test
# the the method change-game.status to false
# exp = self.player1
# self.game.end_game(exp)
# However;
# The followign method-call raise an error
# and may need another tests typ!
# score.write_file() <-----
highscore = Highscore(self.game.player1, self.game.player2)
highscore.write_file = MagicMock(name='write_file')
highscore.write_file()
def scorelist(self):
self._highcontainer = DrawableContainer()
self._score = Highscore().getScore()
self._highcontainer.position = ((self._window.size[0] - 200) / 2, 0)
self._titletext = sf.Text("Highscore", self._font, 50)
self._titletext_left = sf.Text("Highscore", self._font, 50)
self._titletext_left.position = (0 - 1.5, 0)
self._titletext_left.color = sf.Color.BLACK
self._titletext_up = sf.Text("Highscore", self._font, 50)
self._titletext_up.position = (0, 0 - 1.5)
self._titletext_up.color = sf.Color.BLACK
self._titletext_right = sf.Text("Highscore", self._font, 50)
self._titletext_right.position = (0 + 1.5, 0)
self._titletext_right.color = sf.Color.BLACK
self._titletext_down = sf.Text("Highscore", self._font, 50)
self._titletext_down.position = (0, 0 + 1.5)
self._titletext_down.color = sf.Color.BLACK
self._highcontainer.add_element(self._titletext_left)
self._highcontainer.add_element(self._titletext_up)
self._highcontainer.add_element(self._titletext_right)
self._highcontainer.add_element(self._titletext_down)
self._highcontainer.add_element(self._titletext)
for x in range(10):
name = self._score[x]['name']
score = self._score[x]['score']
linename = sf.Text(name, self._font, 40)
linename_left = sf.Text(name, self._font, 40)
linename_left.color = sf.Color.BLACK
linename_up = sf.Text(name, self._font, 40)
linename_up.color = sf.Color.BLACK
linename_right = sf.Text(name, self._font, 40)
linename_right.color = sf.Color.BLACK
linename_down = sf.Text(name, self._font, 40)
linename_down.color = sf.Color.BLACK
linescore = sf.Text(str(score), self._font, 40)
linescore_left = sf.Text(str(score), self._font, 40)
linescore_left.color = sf.Color.BLACK
linescore_up = sf.Text(str(score), self._font, 40)
linescore_up.color = sf.Color.BLACK
linescore_right = sf.Text(str(score), self._font, 40)
linescore_right.color = sf.Color.BLACK
linescore_down = sf.Text(str(score), self._font, 40)
linescore_down.color = sf.Color.BLACK
self._highcontainer.add_element(
linename_left, sf.Vector2(-200 - 1.5, (50 * x) + 50))
self._highcontainer.add_element(
linename_up, sf.Vector2(-200, (50 * x) + 50 - 1.5))
self._highcontainer.add_element(
linename_right, sf.Vector2(-200 + 1.5, (50 * x) + 50))
self._highcontainer.add_element(
linename_down, sf.Vector2(-200, (50 * x) + 50 + 1.5))
self._highcontainer.add_element(linename,
sf.Vector2(-200, (50 * x) + 50))
self._highcontainer.add_element(
linescore_left, sf.Vector2(250 - 1.5, (50 * x + 50)))
self._highcontainer.add_element(
linescore_up, sf.Vector2(250, (50 * x + 50 - 1.5)))
self._highcontainer.add_element(
linescore_right, sf.Vector2(250 + 1.5, (50 * x + 50)))
self._highcontainer.add_element(
linescore_down, sf.Vector2(250, (50 * x + 50 + 1.5)))
self._highcontainer.add_element(linescore,
sf.Vector2(250, (50 * x + 50)))
class Main(ShowBase, DirectObject):
def __init__(self):
ShowBase.__init__(self)
# Set the frame rate lock
# We need to set globalClock rate to 30' because it looks
# like the AI is affected by the frame rate.
# the higher the rate the faster they move depending on
# your pc.
globalClock.setMode(ClockObject.MLimited)
globalClock.setFrameRate(30)
self.win.setClearColor(Vec4(0.12,0.43,0.18,1))
self.disableMouse()
self.player = Player(self)
self.enemyList = []
self.maxEnemyCount = 15
self.itemList = []
self.maxItemCount = 4
self.level = Level()
self.enemyParent = render.attachNewNode("EnemyParent")
self.enemyParent.setH(180)
self.enemyStrength = 0
self.itemParent = render.attachNewNode("ItemParent")
self.mouse = Mouse(self.level.planeNP)
random.seed()
self.gameStarted = False
# Setup Gui
self.mainMenu = MainScreen()
self.mainMenu.show()
self.highscore = Highscore()
# Menu events
self.accept("escape", self.quit)
self.accept("MainMenu_start", self.start)
self.accept("Highscore_show", self.highscore.show)
self.accept("MainMenu_quit", self.quit)
self.accept("Highscore_back", self.mainMenu.show)
# ingame events
self.accept("killEnemy", self.removeEnemy)
self.accept("pickedUpHealth", self.removeItem)
self.accept("pickedUpWeapon", self.removeItem)
# Start everything needed to play the game
def start(self):
self.gameStarted = True
self.level.start()
self.player.start(self.level.startPos, self.mainMenu.getPlayername())
self.taskMgr.add(self.world, "MAIN TASK")
self.accept("escape", self.stop)
self.AiWorld = AIWorld(render)
self.taskMgr.add(self.AIUpdate, "UPDATEAI")
# When the game stops, we do some cleanups
def stop(self):
self.level.stop()
self.highscore.setPoints(self.player.name, self.player.points)
self.player.stop()
tempIDList = []
for enemy in self.enemyList:
tempIDList.append(enemy.id)
for enemyID in tempIDList:
self.removeEnemy(enemyID)
tempIDList = []
for item in self.itemList:
tempIDList.append(item.id)
for itemID in tempIDList:
self.removeItem(itemID)
self.taskMgr.remove("MAIN TASK")
self.mainMenu.show()
self.accept("escape", self.quit)
def quit(self):
if self.appRunner:
self.appRunner.stop()
else:
exit(0)
def spawnEnemy(self):
if len(self.enemyList) > self.maxEnemyCount: return False
enemy = Enemy(self)
x = self.player.model.getX()
y = self.player.model.getY()
while (x > self.player.model.getX() - 4.5 and x < self.player.model.getX() + 4.5):
x = random.uniform(-9, 9)
while (y > self.player.model.getY() - 4.5 and y < self.player.model.getY() + 4.5):
y = random.uniform(-9, 9)
position = VBase2(x, y)
enemy.start(position, self.enemyParent)
enemy.makeAi()
self.player.addEnemyDmgEvent(enemy.id)
self.enemyList.append(enemy)
return True
def removeEnemy(self, enemyID):
for enemy in self.enemyList:
if enemy.id == enemyID:
enemy.stop()
self.AiWorld.removeAiChar("Enemy"+str(enemyID))
self.enemyList.remove(enemy)
return True
return False
def removeItem(self, itemId):
for item in self.itemList:
if item.id == itemId:
item.stop()
self.itemList.remove(item)
return True
return False
def spawnItem(self):
if len(self.itemList) > self.maxItemCount: return False
item = random.choice([Heal(self), MachineGun(self)])
x = self.player.model.getX()
y = self.player.model.getY()
while (x > self.player.model.getX() - 4.5 and x < self.player.model.getX() + 4.5):
x = random.uniform(-9, 9)
while (y > self.player.model.getY() - 4.5 and y < self.player.model.getY() + 4.5):
y = random.uniform(-9, 9)
position = VBase2(x, y)
item.start(position)
self.itemList.append(item)
if item.type == "heal":
self.player.addHealItemEvent(item.id)
else:
self.player.addWeaponItemEvent(item.id)
return True
def world(self, task):
"""MAIN TASK"""
mul = int(self.player.points / 500)
self.maxEnemyCount + (5 * mul)
mul = int(self.player.points / 1000)
self.maxItemCount - (1 * mul)
mul = int(self.player.points / 1500)
self.enemyStrength = 1 * mul
self.spawnEnemy()
self.spawnItem()
self.player.playerTraverser.traverse(self.enemyParent)
self.player.playerTraverser.traverse(self.itemParent)
self.player.playerPushTraverser.traverse(self.level.planeNP)
return task.cont
def AIUpdate(self, task):
if len(self.enemyList) <= 0:
return False
else:
self.AiWorld.update()
for enemy in self.enemyList:
enemy.model.setP(-90)
return task.cont
class Game():
"""Game Class."""
win_pig = 50
still_going = False
def __init__(self):
"""Initialize instances from other classes."""
self.computer_controlar = False
self.dice = Dice()
# Changable value
self.forbidden_face = 1
self.player1 = Player(str, bool)
self.player2 = Player(str, bool)
self.set_playing_now(self.player1)
# Basically, player2 may be computer in case user decided.
# However, computer_player object has been added to make the
# code easier to read. Since computer controlled by another class.
self.computer_player = Player("Computer", bool)
self.computer_player.set_level("easy")
self.score = Highscore(self.player1, self.player2)
self.histogram = Histogram()
def create_player(self, player_amount):
"""
Create Players accourding to passed parameter.
Get info from shell.py, fit equavelent players with names.
Turn computer_controller on/off.
"""
player1_name = input("Enter the first player's name >> ")
if player1_name == "":
player1_name = "USER1"
self.player1.set_name(player1_name)
self.player2.set_name("Computer")
# Hold player object temporarily above
if player_amount == 2:
player2_name = input("Enter the second player's name >> ")
if player2_name == "":
player2_name = "USER2"
self.player2.set_name(player2_name)
else:
self.player2 = self.computer_player
print("Game Starts!\n\n")
def switcher(self):
"""
Switch between players.
Considering who is playing now and whether
computer-controler true or false, take rule in switching turns
between players.
"""
if (self.get_computer_controler()
and self.get_playing_now() == self.player1):
self.set_playing_now(self.computer_player)
return self.computer_turn()
if (self.get_computer_controler()
and self.get_playing_now() == self.computer_player):
self.set_playing_now(self.player1)
if self.get_playing_now() == self.player1 and not (
self.get_computer_controler()):
print(">>>>> Start {} turn <<<<<\n".format(
self.player2.get_name()))
return self.set_playing_now(self.player2)
print(">>>>> Start {} turn <<<<<\n".format(self.player1.get_name()))
return self.set_playing_now(self.player1)
def roll(self):
"""
Reached by human players.
Call other methods to make operations depends on die rollments.
"""
force_stop = self.console(self.get_playing_now())
if not force_stop and self.get_game_status():
self.switcher()
def console(self, player):
"""Synchronize between players's scores and rolled dice."""
self.print_out_dice(player, self.dice.get_dice())
player.change_score(self.dice.get_dice())
player.set_score_list(self.dice.get_dice())
self.print_score(player)
# self.mock_in_console = self.dice.get_dice()
self.set_face(self.dice.get_dice()) # For test purpose.
if self.dice.get_dice() in (1, 6):
self.dice.roll_dice()
return False
if self.get_playing_now().get_score() >= self.win_pig:
self.end_game(self.playing_now)
self.set_game_status(False)
self.dice.roll_dice()
return True
def computer_turn(self):
"""Take orders from Intelligence class to control the decison."""
print(">>>>> Start Computer turn <<<<<\n")
while self.get_game_status():
reaction = self.computer_player.reaction.get_inti_decision(
self.computer_player, self.cheat())
if not reaction:
print("\t\t\t\t>>>>> Computer decide to HOLD <<<<<")
self.switcher()
break
print("\t\t\t\t>>>>> Computer decide to ROLL <<<<<")
self.playing_now = self.computer_player
force_stop = self.console(self.computer_player)
if not force_stop:
print("\t\t\t\t>>>>> Computer lose its turn <<<<<")
self.switcher()
break
def cheat(self):
"""Return the rolled dice to reach cheating feture."""
return self.dice.get_dice()
def check_levels(self, level):
"""Check if the entered level is valid."""
levels = ("easy", "normal", "hard")
if level in levels:
self.computer_player.set_level(level)
print("My level now is", level)
else:
raise ValueError("This kind of level is not available!!")
def change_name(self, name):
"""Change player name."""
self.playing_now.set_name(name)
@staticmethod
def print_score(player):
"""Print out player score and name."""
print("{} score is {}".format(player.get_name(), player.get_score()))
@staticmethod
def print_out_dice(player, number):
"""Print out rolled dice."""
print("{} got:".format(player.get_name()))
print(" ______")
print(r"|\______\ ")
print("|| |")
print("|| {} |".format(number))
print(r"\|______|" + "\n")
def highscore(self):
"""Call method sprint out from highscore file."""
self.score.read_file()
def end_game(self, player):
"""Call other methods to process game ending."""
self.score = Highscore(self.player1, self.player2)
# self.score.write_highscore()
self.set_game_status(False)
print("WOW! Congra {} you won the game!".format(player.get_name()))
self.histogram.print_histogram(self.player1, self.player2)
self.score.write_file()
def set_game_status(self, bool):
"""Set game status."""
self.still_going = bool
def get_game_status(self):
"""Check the game status."""
return self.still_going
def set_playing_now(self, player):
"""Change object's holder to help exchanging players."""
self.playing_now = player
def get_playing_now(self):
"""Return currently player."""
return self.playing_now
def set_computer_controler(self, bool):
"""Setter for a boolen variable.
Help in switching turns.
"""
self.computer_controlar = bool
def get_computer_controler(self):
"""Getter for a boolen variable.
Help to switching turns.
"""
return self.computer_controlar
# The following two methods helps to check
# the dice face while playing and exatly
# before the next rollment,
# do not effect the game, helping in testing
def set_face(self, num):
"""Set value in variable to hold dice face before automatic rolling.
This method used for testing purpose.
"""
self.forbidden_face = num
def get_face(self):
"""Return dice face before automatic rolling.
Method used for testing purpose.
"""
return self.forbidden_face
class Gameover_menu():
def __init__(self, window, game_menu):
self._window = window
self._game_menu = game_menu
self._font = settings.defaultFont
self._highscore = Highscore()
self._name = ""
self._titletext = sf.Text("Game Over", self._font, 50)
self._titletext_left = sf.Text("Game Over", self._font, 50)
self._titletext_up = sf.Text("Game Over", self._font, 50)
self._titletext_right = sf.Text("Game Over", self._font, 50)
self._titletext_down = sf.Text("Game Over", self._font, 50)
self._titletext_left.color = sf.Color.BLACK
self._titletext_up.color = sf.Color.BLACK
self._titletext_right.color = sf.Color.BLACK
self._titletext_down.color = sf.Color.BLACK
self._titletext.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,50)
self._titletext_left.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2-1.5,50)
self._titletext_up.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,50-1.5)
self._titletext_right.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2+1.5,50)
self._titletext_down.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,50+1.5)
self._scoretext = sf.Text("Points "+str(self._game_menu._points), self._font, 50)
self._enternametext = sf.Text("Enter Name!", self._font, 50)
self._enternametext_left = sf.Text("Enter Name!", self._font, 50)
self._enternametext_up = sf.Text("Enter Name!", self._font, 50)
self._enternametext_right = sf.Text("Enter Name!", self._font, 50)
self._enternametext_down = sf.Text("Enter Name!", self._font, 50)
self._enternametext.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,250)
self._enternametext_left.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2-1.5,250)
self._enternametext_up.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,250-1.5)
self._enternametext_right.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2+1.5,250)
self._enternametext_down.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,250+1.5)
self._enternametext_left.color = sf.Color.BLACK
self._enternametext_up.color = sf.Color.BLACK
self._enternametext_right.color = sf.Color.BLACK
self._enternametext_down.color = sf.Color.BLACK
self._nametext = sf.Text(self._name, self._font, 50)
self._nametext_left = sf.Text(self._name, self._font, 50)
self._nametext_up = sf.Text(self._name, self._font, 50)
self._nametext_right = sf.Text(self._name, self._font, 50)
self._nametext_down = sf.Text(self._name, self._font, 50)
self._nametext.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,350)
self._nametext_left.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2-1.5,350)
self._nametext_up.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,350-1.5)
self._nametext_right.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2+1.5,350)
self._nametext_down.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,350+1.5)
self._nametext_left.color = sf.Color.BLACK
self._nametext_up.color = sf.Color.BLACK
self._nametext_right.color = sf.Color.BLACK
self._nametext_down.color = sf.Color.BLACK
#backbutton
self._okbutton = Button(sf.Vector2((self._window.size[0]-150)/2,(self._window.size[1]-50)), #position
sf.Vector2(150,20), #size
sf.Color.GREEN, #background color
sf.Color.BLACK, #text color
sf.Color.RED, #outline color
2, #outline thickness
"OK", #lable
self._font, #font
17) #text size
def loop(self, background):
self._scoretext.string = "Points " + str(self._game_menu._points)
self._scoretext_left = sf.Text("Points "+str(self._game_menu._points), self._font, 50)
self._scoretext_up = sf.Text("Points "+str(self._game_menu._points), self._font, 50)
self._scoretext_right = sf.Text("Points "+str(self._game_menu._points), self._font, 50)
self._scoretext_down = sf.Text("Points "+str(self._game_menu._points), self._font, 50)
self._scoretext.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,150)
self._scoretext_left.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2-1.5,150)
self._scoretext_up.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,150-1.5)
self._scoretext_right.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2+1.5,150)
self._scoretext_down.position = ((self._window.size[0]-self._titletext.local_bounds.size[0])/2,150+1.5)
self._scoretext_left.color = sf.Color.BLACK
self._scoretext_up.color = sf.Color.BLACK
self._scoretext_right.color = sf.Color.BLACK
self._scoretext_down.color = sf.Color.BLACK
background.draw(self._window)
self._window.draw(self._titletext_left)
self._window.draw(self._titletext_up)
self._window.draw(self._titletext_right)
self._window.draw(self._titletext_down)
self._window.draw(self._titletext)
self._window.draw(self._enternametext_left)
self._window.draw(self._enternametext_up)
self._window.draw(self._enternametext_right)
self._window.draw(self._enternametext_down)
self._window.draw(self._enternametext)
self._window.draw(self._scoretext_left)
self._window.draw(self._scoretext_up)
self._window.draw(self._scoretext_right)
self._window.draw(self._scoretext_down)
self._window.draw(self._scoretext)
self._window.draw(self._nametext_left)
self._window.draw(self._nametext_up)
self._window.draw(self._nametext_right)
self._window.draw(self._nametext_down)
self._window.draw(self._nametext)
self._window.draw(self._okbutton)
def listen_for_event(self, event):
self.mouse_listener(event)
self.text_listener(event)
self.key_listener(event)
def key_listener(self, event):
if type(event) is sf.KeyEvent and event.pressed and event.code is sf.Keyboard.RETURN:
self._highscore.addScore(self._name,self._game_menu._points)
self._name = ""
self._nametext.string = ""
self._game_menu._highscore.scorelist()
self._game_menu.show_highscore()
try:
if type(event) is sf.KeyEvent and event.pressed and event.code is sf.Keyboard.BACK_SPACE:
if not (len(self._name)==0):
self._name = self._name[:-1]
self._nametext.string = self._name
self._nametext_left.string = self._name
self._nametext_up.string = self._name
self._nametext_right.string = self._name
self._nametext_down.string = self._name
except AttributeError:
if type(event) is sf.KeyEvent and event.pressed and event.code is sf.Keyboard.BACK:
if not (len(self._name)==0):
self._name = self._name[:-1]
self._nametext.string = self._name
self._nametext_left.string = self._name
self._nametext_up.string = self._name
self._nametext_right.string = self._name
self._nametext_down.string = self._name
def mouse_listener(self, event):
if type(event) is sf.MouseButtonEvent and event.pressed and sf.Mouse.is_button_pressed(sf.Mouse.LEFT):
mouse_pos = sf.Mouse.get_position(self._window)
if self._okbutton.contains(mouse_pos):
self._okbutton.bgcolor(sf.Color.RED)
if type(event) is sf.MouseButtonEvent and event.released and event.button == sf.Mouse.LEFT:
mouse_pos = sf.Mouse.get_position(self._window)
#startbutton
if self._okbutton.contains(mouse_pos):
self._highscore.addScore(self._name,self._game_menu._points)
self._name = ""
self._nametext.string = ""
self._game_menu._highscore.scorelist()
self._game_menu.show_highscore()
if type(event) is sf.MouseButtonEvent and event.released:
self._okbutton.bgcolor(sf.Color.GREEN)
def text_listener(self, event):
if type(event) is sf.TextEvent:
if(48 <= event.unicode <= 57 or 65 <= event.unicode <= 90 or 97 <= event.unicode <= 122):
self._name += chr(event.unicode)
self._nametext.string = self._name
self._nametext_left.string = self._name
self._nametext_up.string = self._name
self._nametext_right.string = self._name
self._nametext_down.string = self._name
class MainView(
): #Main view of the program. Ties the game & highscore-views together.
def __init__(self, root):
self.root = root
#Knapparnas-container
self.menu = Frame(self.root)
self.menu.pack()
#Ny-omgång knappen
self.newGameButton = Button(self.menu,
height=1,
width=20,
text="Ny spelomgång")
self.newGameButton.bind("<Button-1>", self.newGame)
self.newGameButton.pack(side=LEFT)
#highscore-knappen
self.highscoreButton = Button(self.menu,
height=1,
width=20,
text="Toggla Highscores")
self.highscoreButton.bind("<Button-1>", self.toggleHighscore)
self.highscoreButton.pack(side=LEFT)
#Highscore-vyn
self.highscoreView = Highscore(self.root, "highscores.txt")
self.highscoreBool = False
#Spel-vyn
self.gameView = ChessBoard(self, self.root)
self.gameView.container.pack()
def finished(
self, score
): #Kallas från self.gameView när det inte finns några möjliga förflyttningar
index = self.highscoreView.finishedGame(score)
self.toggleHighscore(
) #Visar automatiskt highscore när en omgång är över.
#Creates a new game instance.
def newGame(self, event):
if self.highscoreBool:
self.highscoreView.container.pack_forget()
self.highscoreBool = not self.highscoreBool
self.gameView.container.pack_forget()
self.gameView.container.destroy()
self.gameView = ChessBoard(self, self.root) #Ny instans av ChessBoard.
self.gameView.container.pack()
def toggleHighscore(self,
event=None): #Togglar visning av highscore/spelvyn
if self.highscoreBool:
self.highscoreView.container.pack_forget()
self.gameView.container.pack()
else:
self.highscoreView.container.pack()
self.gameView.container.pack_forget()
self.highscoreBool = not self.highscoreBool
from sqare import Square
from game import Game
from highscore import Highscore
import pygame
import numpy as np
from _thread import *
import os
SCREENSIZE = 905
hs = Highscore()
hs.form()
pygame.init()
pygame.font.init()
win = pygame.display.set_mode((SCREENSIZE + 400, SCREENSIZE))
test = Game(0, 0, 60, 200)
back = Square(1000, 100, 0, 0, (100, 100, 100), test)
fin = Square(1000, 350, 0, 0, (100, 100, 100), test)
score = Square(1000, 600, 0, 0, (150, 80, 80), test)
ext = Square(1255, 0, 0, 0, (100, 100, 100), Game(0, 0, 20, 50))
def end(x, game, win):
if x:
#print("reached end -- win")
win.fill((255, 255, 255))
#s = "Gewonnen!! :)"
#font = pygame.font.SysFont("comicsans", 80)
#text = font.render(s, 1, (255,69,0))
#win.blit(text, (x,y))
for i in range(0, game.GAMESIZE):
class PlayScreen(object):
def __init__(self):
'''
PLAY SCREEN INIT
'''
# Init the font
self.largefont = pygame.font.SysFont("Impact", 20)
self.smallfont = pygame.font.SysFont("Impact", 15)
# Load all graphics for the screen
self.playbg = createGraphics("img/play_bg.png", 0,0) # load the backgorund
self.pause = createGraphics("img/pause.png", 745,450) # load the pause button
self.mute = createGraphics("img/mute.png", 745,496) # load the mute button
self.undo = createGraphics("img/undo.png", 745,542) # load the undo button
self.deck = createGraphics("img/deck.png", 21,449) # load the deck graphic
self.menubg = createGraphics("img/pause_menu_bg.png", 223,70) # load the pause menu popup
self.playOn = createGraphics("img/halda_afram.png", 242,99) # load the play on button in menu
self.playAgain = createGraphics("img/byrja_aftur.png", 242,211) # load the play again button in menu
self.stopGame = createGraphics("img/haetta_leik.png", 242,323) # load the stop game button in menu
self.endscreen = createGraphics("img/lose_bg.png", 0,0) # load the loose screen
self.winscreen = createGraphics("img/win_bg.png", 0,0) # load the win screen
self.register_bg = createGraphics("img/register_bg.png", 0,0) # load the top 10 register screen
self.view_toplist = createGraphics("img/view_toplist.png", 262,363) # load the view top list button
# For music player
self.last_song = createGraphics("img/last_song.png", 356,7)
self.play_song = createGraphics("img/pause_song.png", 381,7)
self.next_song = createGraphics("img/next_song.png", 412,7)
self.song = 0
self.initPlayer = True
# place cards on table in first iteration
self.initBoardMode = True
self.sound = True
self.i = 0
self.j = 0
play = Sound()
#card taken from deck
self.lastStock = False
'''
CARDS INIT
'''
self.suits = 'hsdc' #hearts, spades, diamonds, clubs
self.ranks = '23456789TJQKA' # all card types
cardslist = [rank + suit for suit in self.suits for rank in self.ranks] # create dummy deck
self.cardsImg = {} # list that will contain all card graphics
# create card graphic for every card in cardslist and put into self.cardsImg
for card in cardslist:
self.cardsImg[card] = createGraphics("img/cards/" + card + ".png",0,0)
'''
DRAGMODE INIT
'''
self.mouseInDeck = False
self.dragmode = False
self.selectedCard = None
self.selectedCardOrigPosL = None
self.selectedCardOrigPosT = None
self.displayMenu = False
'''
SCORE INIT
'''
self.score = Score()
self.currentScore = self.largefont.render(str(self.score.returnScore()), 1, (255,255,255))
self.currentScoreRect = self.currentScore.get_rect()
self.currentScoreRect = self.currentScoreRect.move(20,8)
# count successful moves in a row
self.combo = 0
# finalTime is set when game ends and is sent to high score etc
self.finalTime = 0
# Controls if to dispaly end screens or not
self.displayLoseScreen = False
self.displayWinScreen = False
self.checkGameStatus = True
self.gameResults = False
'''
TIME INIT
'''
# Time since program was executed
self.startTime = pygame.time.get_ticks()
# Time in pause mode
self.pauseTime = 0
# Object to write time to screen
self.displayTime = self.smallfont.render('Tími: ' + str(pygame.time.get_ticks() - self.startTime), 1, (255,255,255))
self.displayTimeRect = self.displayTime.get_rect()
self.displayTimeRect = self.displayTimeRect.move(100,8)
self.highscore = Highscore()
self.displayRegister = False
'''
TEXT INPUT INIT
'''
self.txtbx = eztext.Input(maxlength=45, color=(255,0,0), prompt='')
def gameOver(self, deck, pile, minidecks):
'''
Checks if the user has no more moves to make.
'''
gameover = True # assume the game is over
# If the deck is empty check if card in any minideck can go to pile
if deck.isEmpty():
for minideck in minidecks:
if not minideck.isEmpty():
if deck.isMatch(minideck.peek(),pile.topCard()):
gameover = False
break
else:
# deck is not empty so the game is not over
gameover = False
return gameover
def display(self, screen, currentScreenIndex, deck, pile, minidecks):
play = Sound()
# Is left mouse button pressed
isPressed = (pygame.mouse.get_pressed() == (1,0,0))
# Do we need to startover
startover = False
IMG = 0 # Location of graphic object in card list
RECT = 1 # Location of rect object in card list
# Count empty minidecks
numberofEmpties = 0 # Number of empty minidecks
for minideck in minidecks:
if minideck.isEmpty():
numberofEmpties += 1
# Is mouse over mute button
if collides(self.mute[RECT]):
if self.i%2==0:
self.mute[IMG] = pygame.image.load("img/mute_hover.png")
else:
self.mute[IMG] = pygame.image.load("img/mute.png")
if isPressed and self.i%2==0:
self.mouseInDeck = True
elif not isPressed and self.mouseInDeck and self.i%2==0:
self.mute[IMG] = pygame.image.load("img/mute_press.png")
self.mouseInDeck = False
self.sound = False
self.i += 1
isPressed = False
play.pauseSong()
elif isPressed and self.i%2==1 and self.mouseInDeck == False:
self.mouseInDeck = True
elif not isPressed and self.mouseInDeck and self.i%2==1:
self.mute[IMG] = pygame.image.load("img/mute.png")
self.mouseInDeck = False
self.sound = True
self.i += 1
isPressed = False
play.resumeSong()
# Is mouse over undo button
elif collides(self.undo[RECT]):
self.undo[IMG] = pygame.image.load("img/undo_hover.png")
if isPressed:
#Undo last action
if pile.isEmpty():
card = pile.topCard()
if self.lastStock:
deck._deck.append(card)
pile.takeLastCard()
self.lastStock = False
self.combo = 0
# Is the deck being clicked
elif collides(self.deck[RECT]) and isPressed:
# Wait until mouse is released
self.mouseInDeck = True
# Is mouse being released over deck and was it clicked before
elif collides(self.deck[RECT]) and not isPressed and self.mouseInDeck:
self.mouseInDeck = False
# Check if deck is empty
if not deck.isEmpty():
if self.sound and self.combo > 2:
play.comboBreaker()
# reset combo counter
self.combo = 0
# Draw card and place it on the pile
drawn_card = deck.draw_card()
#update that last action was from deck
self.lastStock = True
self.cardsImg[drawn_card][RECT] = self.cardsImg[pile.topCard()][RECT]
pile.put(drawn_card)
if self.sound == True:
play.drawCard()
else:
# No action required, make sure buttons are in original position
self.pause[IMG] = pygame.image.load("img/pause.png")
if self.i%2==1 and self.mouseInDeck == False:
self.mute[IMG] = pygame.image.load("img/mute_press.png")
elif self.i%2==0 and self.mouseInDeck == False:
self.mute[IMG] = pygame.image.load("img/mute.png")
self.undo[IMG] = pygame.image.load("img/undo.png")
# Draw play, mute and undo button to screen
screen.blit(self.playbg[IMG], self.playbg[RECT])
screen.blit(self.mute[IMG], self.mute[RECT])
screen.blit(self.undo[IMG], self.undo[RECT])
'''
MUSIC PLAYER
'''
screen.blit(self.last_song[IMG], self.last_song[RECT])
screen.blit(self.play_song[IMG], self.play_song[RECT])
screen.blit(self.next_song[IMG], self.next_song[RECT])
if abs(self.song) == play.getLenPlaylist():
self.song = 0
if self.initPlayer:
self.song = randint(0,play.getLenPlaylist()-1)
play.playSong(self.song)
self.initPlayer = False
if collides(self.last_song[RECT]):
self.last_song[IMG] = pygame.image.load("img/last_song_hover.png")
if isPressed:
self.song -= 1
if abs(self.song) == play.getLenPlaylist():
self.song = 0
play.playSong(self.song)
elif collides(self.play_song[RECT]):
if self.j%2 == 0:
self.play_song[IMG] = pygame.image.load("img/pause_song_hover.png")
else:
self.play_song[IMG] = pygame.image.load("img/play_song_hover.png")
if isPressed and self.j%2 == 0:
self.mouseInDeck = True
elif not isPressed and self.mouseInDeck and self.j%2 == 0:
self.play_song[IMG] = pygame.image.load("img/play_song.png")
self.mouseInDeck = False
self.j += 1
play.pauseSong()
elif isPressed and self.j%2==1 and self.mouseInDeck == False:
self.mouseInDeck = True
elif not isPressed and self.mouseInDeck and self.j%2==1:
self.play_song[IMG] = pygame.image.load("img/pause_song.png")
self.mouseInDeck = False
self.j += 1
isPressed = False
play.resumeSong()
elif collides(self.next_song[RECT]):
self.next_song[IMG] = pygame.image.load("img/next_song_hover.png")
if isPressed:
self.song += 1
if abs(self.song) == play.getLenPlaylist():
self.song = 0
play.playSong(self.song)
else:
self.last_song[IMG] = pygame.image.load("img/last_song.png")
if self.j%2 == 1:
self.play_song[IMG] = pygame.image.load("img/play_song.png")
else:
self.play_song[IMG] = pygame.image.load("img/pause_song.png")
self.next_song[IMG] = pygame.image.load("img/next_song.png")
nowplaying = self.largefont.render('i spilun: ' + play.getSongName(self.song), 1, (255,255,255))
screen.blit(nowplaying, (450,6))
# Place cards on the board
if self.initBoardMode:
# Display the pile
self.cardsImg[pile.topCard()][RECT] = self.cardsImg[pile.topCard()][RECT].move(131,450)
# Locate all cards in minidecks
xpos = 20
ypos = 57
for minideck in minidecks:
for card in minideck:
self.cardsImg[card][RECT] = self.cardsImg[card][RECT].move(xpos,ypos)
ypos += 50
xpos += 110
ypos = 57
# Only want to run this if loop once
self.initBoardMode = False
# Get the mouse position
mousepos = pygame.mouse.get_pos()
# If we are in dragmode
if self.dragmode:
# and if mouse is pressed
if isPressed:
# make selected card follow mouse position, -50 to place cursor in center of card
self.cardsImg[self.selectedCard][RECT][0] = mousepos[0]-50
self.cardsImg[self.selectedCard][RECT][1] = mousepos[1]-50
# Card released over pile, check if card can go to pile
elif not isPressed and self.cardsImg[self.selectedCard][RECT].colliderect(self.cardsImg[pile.topCard()][RECT]) and Deck.isMatch(self.selectedCard, pile.topCard()):
# the card can go to pile, move card from minideck to pile
self.combo += 1
#Play combo sound if combo
if self.combo == 3 and self.sound:
play.combo(3)
elif self.combo == 5 and self.sound:
play.combo(3)
elif self.combo == 10 and self.sound:
play.combo(3)
elif self.combo == 20 and self.sound:
play.combo(3)
self.score.getComboScore(self.combo)
self.score.normalMove()
# find out in what minideck selected card was
for minideck in minidecks:
# check if the card was in selected minideck
if self.selectedCard in minideck:
# pop the card from the minideck to the top of the pile
self.cardsImg[self.selectedCard][RECT] = self.cardsImg[pile.topCard()][RECT]
pile.put(minideck.pop())
#update lastStock
self.lastStock = False
if self.sound:
play.placeCard()
# re-init dragmode
self.selectedCard = None
self.selectedCardOrigPosL = None
self.selectedCardOrigPosT = None
self.dragmode = False
break
else:
# card can't go to pile
if self.sound and self.combo > 2:
play.comboBreaker()
# reset combo counter
self.combo = 0
# move it back to its original position in minideck
self.cardsImg[self.selectedCard][RECT][0] = self.selectedCardOrigPosL
self.cardsImg[self.selectedCard][RECT][1] = self.selectedCardOrigPosT
if self.sound:
play.wrongPlayed()
# re-init dragmode
self.selectedCard = None
self.dragmode = False
else:
# Check if we need to enable drag mode
for minideck in minidecks:
# Start dragmode when user clicks card for first time
if not minideck.isEmpty() and self.cardsImg[minideck.peek()][RECT].collidepoint(mousepos) and isPressed:
# start dragmode and start drag
self.dragmode = True
self.selectedCard = minideck.peek()
self.selectedCardOrigPosL = self.cardsImg[minideck.peek()][RECT][0]
self.selectedCardOrigPosT = self.cardsImg[minideck.peek()][RECT][1]
break
# Draw pile
screen.blit(self.cardsImg[pile.topCard()][IMG], self.cardsImg[pile.topCard()][RECT])
# Draw deck
if deck.isEmpty():
self.deck[IMG] = pygame.image.load("img/deck_empty.png")
else:
self.deck[IMG] = pygame.image.load("img/deck.png")
screen.blit(self.deck[IMG], self.deck[RECT])
# Cards in deck counter
deckCount = self.smallfont.render(str(deck.card_count()) + ' spil eftir', 1, (255,255,255))
# draw the count
screen.blit(deckCount, (21,428))
# Draw all cards in minidecks
for minideck in minidecks:
for card in minideck:
screen.blit(self.cardsImg[card][IMG], self.cardsImg[card][RECT])
# If card is selected, draw it
if self.selectedCard is not None:
screen.blit(self.cardsImg[self.selectedCard][IMG], self.cardsImg[self.selectedCard][RECT])
# if mouse hovers over pause button
if collides(self.pause[RECT]):
self.pause[IMG] = pygame.image.load("img/pause_hover.png") # display hover graphic
if isPressed:
self.displayMenu = True # start displaying pause menu
self.pauseTime = pygame.time.get_ticks() # start record time in pause mode
if self.sound == True:
play.select()
# if we are supposed to display pause menu
if self.displayMenu:
# draw pause menu graphic
self.playOn[IMG] = pygame.image.load("img/halda_afram.png")
self.playAgain[IMG] = pygame.image.load("img/byrja_aftur.png")
self.stopGame[IMG] = pygame.image.load("img/haetta_leik.png")
# if play on button is hovered
if collides(self.playOn[RECT]):
self.playOn[IMG] = pygame.image.load("img/halda_afram_hover.png") # display hover graphic
# if play button is pressed
if isPressed:
self.displayMenu = False # Hide menu
if self.sound == True:
play.select()
self.startTime += pygame.time.get_ticks() - self.pauseTime # add pause time to total time to subtract
# if play again button is hovered
elif collides(self.playAgain[RECT]):
self.playAgain[IMG] = pygame.image.load("img/byrja_aftur_hover.png") #display hover graphic
if isPressed:
startover = True # re-init playscreen class to start a new game
if self.sound == True:
play.select()
# if stop game button is hovered
elif collides(self.stopGame[RECT]):
self.stopGame[IMG] = pygame.image.load("img/haetta_leik_hover.png") # display hover graphic
if isPressed:
# end game and go to start screen
play.pauseSong()
currentScreenIndex = 0
startover = True
if self.sound == True:
play.select()
# draw the menu
screen.blit(self.menubg[IMG], self.menubg[RECT])
screen.blit(self.playOn[IMG], self.playOn[RECT])
screen.blit(self.playAgain[IMG], self.playAgain[RECT])
screen.blit(self.stopGame[IMG], self.stopGame[RECT])
# draw pause button
screen.blit(self.pause[IMG], self.pause[RECT])
# Update score
self.currentScore = self.largefont.render('Stig: ' + str(self.score.returnScore()), 1, (255,255,255))
screen.blit(self.currentScore, self.currentScoreRect)
# Update time
if self.displayMenu:
displayTimeString = str(self.pauseTime - self.startTime)
else:
displayTimeString = str(pygame.time.get_ticks() - self.startTime)
displayTimeString = displayTimeString[:-3]
# write time to screen
self.displayTime = self.largefont.render('Klukka: ' + displayTimeString, 1, (255,255,255))
screen.blit(self.displayTime, self.displayTimeRect)
# check if we are in 'game finished' mode
if self.displayLoseScreen or self.displayWinScreen:
'''
TODO: Highscore registration screen
'''
if isPressed:
if self.highscore.parseHighscores(self.score.getSumScore(self.gameResults)):
self.displayWinScreen = False
self.displayLoseScreen = False
self.displayRegister = True
else:
currentScreenIndex = STARTSCREEN
startover = True
color = (192, 57, 43)
if self.displayLoseScreen:
# if game was lost set color theme to red
color = (192, 57, 43)
self.gameResults = False
elif self.displayWinScreen:
# if game was won set color theme to green
color = (49, 182, 144)
self.gameResults = True
# create drawable objects for score and time. Score info is requested from model
timeLabel = self.smallfont.render(str(self.finalTime) , 1, color)
pointLabel = self.smallfont.render(str(self.score.returnNormalScore()), 1, color)
bonuspointLabel = self.smallfont.render(str(self.score.returnCombo()), 1, color)
timepointLabel = self.smallfont.render(str(self.score.getTimeScore(int(self.finalTime), self.gameResults)), 1, color)
totalpointLabel = self.largefont.render(str(self.score.getSumScore(self.gameResults)), 1, color)
# if lose screen draw lose screen
if self.displayLoseScreen:
screen.blit(self.endscreen[IMG], self.endscreen[RECT])
# if win screen draw win screen
elif self.displayWinScreen:
screen.blit(self.winscreen[IMG], self.winscreen[RECT])
# draw info to screen
screen.blit(timeLabel, timeLabel.get_rect().move(369,216))
screen.blit(pointLabel, pointLabel.get_rect().move(369,280))
screen.blit(bonuspointLabel, bonuspointLabel.get_rect().move(369,305))
screen.blit(timepointLabel, timepointLabel.get_rect().move(369,330))
screen.blit(totalpointLabel, totalpointLabel.get_rect().move(369,353))
# check if game is over
gameover = PlayScreen.gameOver(self, deck, pile, minidecks)
# if game is over and game status hasn't been checked
if gameover and self.checkGameStatus:
play.pauseSong()
self.displayLoseScreen = True # request lose screen
self.finalTime = displayTimeString # stop and save timer to variable
self.checkGameStatus = False # we only need to check game status once in each game
if self.sound == True:
play.gameOver()
# if all minidecks are empty and game status hasn't been checked
elif numberofEmpties == len(minidecks) and self.checkGameStatus:
play.pauseSong()
#play winning sound
if self.sound:
play.winning()
self.displayWinScreen = True # request win screen
self.finalTime = displayTimeString # stop and save timer to variable
self.checkGameStatus = False # we only need to check game status once in each game
if self.displayRegister:
screen.blit(self.register_bg[IMG], self.register_bg[RECT])
screen.blit(self.view_toplist[IMG], self.view_toplist[RECT])
if collides(self.view_toplist[RECT]) and isPressed:
self.highscore.addHighscore(self.score.getSumScore(self.gameResults), self.txtbx.getValue())
currentScreenIndex = TOPSCREEN
startover = True
# events for txtbx
events = pygame.event.get()
# process other events
'''
for event in events:
# close it x button si pressed
if event.type == QUIT: return
'''
# update txtbx
self.txtbx.update(events)
# blit txtbx on the sceen
self.txtbx.draw(screen)
# refresh the display
#pygame.display.flip()
# Send report to controller about current position
return currentScreenIndex, startover
class TestGameClass(unittest.TestCase):
"""Test Game Class."""
def setUp(self):
"""Run at the beginning of the test."""
self.game = Game()
self.game.set_game_status(True)
self.dice = Dice()
self.player1 = Player(str, bool)
self.player2 = Player(str, bool)
self.computer_player = Player(str, bool)
self.highscore = Highscore(self.player1, self.player2)
@patch('builtins.input', return_value='')
def test_create_player(self, mock):
"""Test create_player."""
# Test with one player name and no name entered
self.game.create_player(1)
self.game.player1_name = mock
self.assertEqual(self.game.player1.get_name(), "USER1")
@patch('builtins.input', return_value='name')
def test_create_player1(self, mock):
"""Test create_player."""
# Test with one player name and no name entered
self.game.create_player(1)
self.game.player1_name = mock
self.assertEqual(self.game.player1.get_name(), "name")
self.assertEqual(self.game.player2.get_name(), "Computer")
@patch('builtins.input', return_value='')
def test_create_player2(self, mock):
"""Test create_player."""
# Test with Two players name and no name entered
self.game.create_player(2)
self.game.player1_name = mock
self.game.player2_name = mock
self.assertEqual(self.game.player1.get_name(), "USER1")
self.assertEqual(self.game.player2.get_name(), "USER2")
# Check that computer_controler is off
self.assertFalse(self.game.get_computer_controler())
def test_switcher(self):
"""Test Switcher."""
# Testing switcher
self.game.set_game_status(True)
before_switching = self.game.get_playing_now()
self.game.switcher()
after_switching = self.game.get_playing_now()
self.assertNotEqual(before_switching, after_switching)
# another test and assuming it is ccomputer's turn
self.game.set_game_status(True)
self.game.set_playing_now(self.computer_player)
self.game.switcher()
self.assertEqual(self.game.get_playing_now(), self.game.player1)
def test_roll(self):
"""Test roll."""
res = self.game.roll()
if self.game.get_face() in (1, 6):
self.assertFalse(res)
def test_console(self):
"""Test console."""
ret_bool = self.game.console(self.game.get_playing_now())
if self.game.get_face() in (1, 6):
self.assertFalse(ret_bool)
# Test that the game ends when the currently player
# reached the winning score
if self.game.get_playing_now().get_score() >= self.game.win_pig:
self.assertFalse(self.game.get_game_status())
self.game.end_game(self.game.get_playing_now())
def test_computer_turn(self):
"""Test computer_turn."""
# Testing prints message:
self.game.computer_turn()
# Most output from method inculds :
printing_res = ' Computer '
catch_output = io.StringIO()
sys.stdout = catch_output
self.game.computer_turn()
# print player's name and score and catch it.
sys.stdout = sys.__stdout__
output = catch_output.getvalue()
self.assertIn(str(printing_res), output)
# Testing switcher() be called by computer_player
# when it decide stops playing
test_reaction = self.computer_player.reaction.get_inti_decision(
self.computer_player, 4)
if not test_reaction:
mock_com_player = Mock(spec=Game)
self.assertIsInstance(mock_com_player, Game)
mock_com_player.switcher()
mock_com_player.switcher.assert_called()
# If game force stop, call switcher
mock_com_player2 = Mock(spec=Game)
game_return = self.game.console(self.computer_player)
if not game_return:
mock_com_player2.switcher()
mock_com_player2.switcher.assert_called()
def test_cheat(self):
"""Test cheat method."""
cheat_method = self.game.cheat()
self.assertEqual(cheat_method, self.game.dice.get_dice())
def test_highscore(self):
"""Test highscore method."""
mock = Mock(spec=Highscore)
self.assertIsInstance(mock, Highscore)
with patch('highscore.Highscore') as fake_obj:
mock.read_file()
fake_obj.asert_called()
# another test
read_file_method = self.highscore.read_file()
self.assertEqual(read_file_method, self.highscore.read_file())
# Test The Instance
self.assertIsInstance(self.highscore, Highscore)
def test_change_name(self):
"""Test changing name feature."""
self.game.change_name("new_name")
res = self.game.playing_now.get_name()
self.assertTrue(res == "new_name")
def test_end_game(self):
"""Test end_game."""
histogram = Histogram()
score = Highscore(self.game.player1, self.game.player2)
self.game.set_game_status(False)
self.assertIsInstance(histogram, Histogram)
# self.assertFalse(self.game.get_game_status())
self.assertIsInstance(score, Highscore)
# The folling two lines work find to test
# the the method change-game.status to false
# exp = self.player1
# self.game.end_game(exp)
# However;
# The followign method-call raise an error
# and may need another tests typ!
# score.write_file() <-----
highscore = Highscore(self.game.player1, self.game.player2)
highscore.write_file = MagicMock(name='write_file')
highscore.write_file()
def test_check_levels(self):
"""Test check_levels."""
# assuming easy level passed:
passed_level = "easy"
levels_list = ("easy")
self.game.check_levels(passed_level)
if passed_level in levels_list:
res = self.computer_player.reaction.level
self.assertEqual(res, passed_level)
def test_print_score(self):
"""Test print_score."""
name_res = self.player1.get_name()
score_res = self.player1.get_score()
res = name_res and score_res
catch_output = io.StringIO()
sys.stdout = catch_output
self.game.print_score(self.player1)
# print player's name and score and catch it.
sys.stdout = sys.__stdout__
output = catch_output.getvalue()
self.assertIn(str(res), output)
def test_print_out_dice(self):
"""Test print_out_dice."""
res = str(self.player1.get_name())
catch_output = io.StringIO()
sys.stdout = catch_output
self.game.print_out_dice(self.player1, 5)
# print cube out and catch it.
sys.stdout = sys.__stdout__
output = catch_output.getvalue()
self.assertIn(res, output)
def test_get_playing_now(self):
"""Test set And get_playing_now."""
exp = self.player1
self.game.set_playing_now(exp)
res = self.game.get_playing_now()
self.assertEqual(res, exp)
def test_get_game_status(self):
"""Test get_game_status."""
res = self.game.get_game_status()
self.assertIn(res, [True, False])
def test_set_cmputer_controler(self):
"""Test set_computer_controler."""
self.game.set_computer_controler(True)
self.assertTrue(self.game.computer_controlar)
def test_get_computer_controler(self):
"""Test get_computer_controler."""
res = self.game.get_computer_controler()
self.assertIn(res, [True, False])
def test_set_face(self):
"""Test set_face."""
self.game.set_face(2)
res = self.game.get_face()
self.assertEqual(res, 2)
def __init__(self):
'''
PLAY SCREEN INIT
'''
# Init the font
self.largefont = pygame.font.SysFont("Impact", 20)
self.smallfont = pygame.font.SysFont("Impact", 15)
# Load all graphics for the screen
self.playbg = createGraphics("img/play_bg.png", 0,0) # load the backgorund
self.pause = createGraphics("img/pause.png", 745,450) # load the pause button
self.mute = createGraphics("img/mute.png", 745,496) # load the mute button
self.undo = createGraphics("img/undo.png", 745,542) # load the undo button
self.deck = createGraphics("img/deck.png", 21,449) # load the deck graphic
self.menubg = createGraphics("img/pause_menu_bg.png", 223,70) # load the pause menu popup
self.playOn = createGraphics("img/halda_afram.png", 242,99) # load the play on button in menu
self.playAgain = createGraphics("img/byrja_aftur.png", 242,211) # load the play again button in menu
self.stopGame = createGraphics("img/haetta_leik.png", 242,323) # load the stop game button in menu
self.endscreen = createGraphics("img/lose_bg.png", 0,0) # load the loose screen
self.winscreen = createGraphics("img/win_bg.png", 0,0) # load the win screen
self.register_bg = createGraphics("img/register_bg.png", 0,0) # load the top 10 register screen
self.view_toplist = createGraphics("img/view_toplist.png", 262,363) # load the view top list button
# For music player
self.last_song = createGraphics("img/last_song.png", 356,7)
self.play_song = createGraphics("img/pause_song.png", 381,7)
self.next_song = createGraphics("img/next_song.png", 412,7)
self.song = 0
self.initPlayer = True
# place cards on table in first iteration
self.initBoardMode = True
self.sound = True
self.i = 0
self.j = 0
play = Sound()
#card taken from deck
self.lastStock = False
'''
CARDS INIT
'''
self.suits = 'hsdc' #hearts, spades, diamonds, clubs
self.ranks = '23456789TJQKA' # all card types
cardslist = [rank + suit for suit in self.suits for rank in self.ranks] # create dummy deck
self.cardsImg = {} # list that will contain all card graphics
# create card graphic for every card in cardslist and put into self.cardsImg
for card in cardslist:
self.cardsImg[card] = createGraphics("img/cards/" + card + ".png",0,0)
'''
DRAGMODE INIT
'''
self.mouseInDeck = False
self.dragmode = False
self.selectedCard = None
self.selectedCardOrigPosL = None
self.selectedCardOrigPosT = None
self.displayMenu = False
'''
SCORE INIT
'''
self.score = Score()
self.currentScore = self.largefont.render(str(self.score.returnScore()), 1, (255,255,255))
self.currentScoreRect = self.currentScore.get_rect()
self.currentScoreRect = self.currentScoreRect.move(20,8)
# count successful moves in a row
self.combo = 0
# finalTime is set when game ends and is sent to high score etc
self.finalTime = 0
# Controls if to dispaly end screens or not
self.displayLoseScreen = False
self.displayWinScreen = False
self.checkGameStatus = True
self.gameResults = False
'''
TIME INIT
'''
# Time since program was executed
self.startTime = pygame.time.get_ticks()
# Time in pause mode
self.pauseTime = 0
# Object to write time to screen
self.displayTime = self.smallfont.render('Tími: ' + str(pygame.time.get_ticks() - self.startTime), 1, (255,255,255))
self.displayTimeRect = self.displayTime.get_rect()
self.displayTimeRect = self.displayTimeRect.move(100,8)
self.highscore = Highscore()
self.displayRegister = False
'''
TEXT INPUT INIT
'''
self.txtbx = eztext.Input(maxlength=45, color=(255,0,0), prompt='')
class MainView(
): #Klassens huvud-vy. Samlar ihop och bestämmer layout av de andra modulerna.
def __init__(self, root):
self.root = root
#Knapparnas-container
self.menu = Frame(self.root)
self.menu.pack()
#Ny-omgång knappen
self.newGameButton = Button(self.menu,
height=1,
width=20,
text="Ny spelomgång")
self.newGameButton.bind("<Button-1>", self.newGame)
self.newGameButton.pack(side=LEFT)
#highscore-knappen
self.highscoreButton = Button(self.menu,
height=1,
width=20,
text="Toggla Highscores")
self.highscoreButton.bind("<Button-1>", self.toggleHighscore)
self.highscoreButton.pack(side=LEFT)
#Highscore-vyn/modulen
self.highscoreView = Highscore(self.root, "highscores.txt")
self.highscoreBool = False
#Spel-vyn/modulen
self.gameView = ChessBoard(self, self.root)
self.gameView.container.pack()
#Absolut noll dokumentation på tkinter.simpledialog. Denna ruta presenterar programmet. Ingen input är nödvändig.
tkinter.simpledialog.askstring(
"Info",
"I detta spel rör du sig som en springare \npå ett shackbräde. Du får bara gå på \n varje ruta en gång och målet är att gå \nså många steg som möjligt. \n\nKlicka OK för att köra!"
)
def finished(
self, score
): #Kallas från self.gameView när det inte finns några möjliga förflyttningar
index = self.highscoreView.finishedGame(score)
self.toggleHighscore(
) #Visar automatiskt highscore-vyn när en omgång är över.
#När ny-omgång knappen klickas är det denna funktion som anropas. Startar en ny omgång.
def newGame(self, event):
if self.highscoreBool:
self.highscoreView.container.pack_forget()
self.highscoreBool = not self.highscoreBool
self.gameView.container.pack_forget()
self.gameView.container.destroy()
self.gameView = ChessBoard(self, self.root) #Ny instans av ChessBoard.
self.gameView.container.pack()
def toggleHighscore(self,
event=None): #Togglar visning av highscore/spelvyn
if self.highscoreBool:
self.highscoreView.container.pack_forget()
self.gameView.container.pack()
else:
self.highscoreView.container.pack()
self.gameView.container.pack_forget()
self.highscoreBool = not self.highscoreBool #Switchar Boolean-värde
name = input("Your name: ")
level = input("easy, normal, hard: ")
if level == "easy":
while True:
a, b, op, r, err = generate_quiz_easy()
print(a, op, b, "=", r)
chon = input("Y / N :")
if chon == "y":
if err == 0:
print("Bingo")
diem += 1
else:
print("fail")
print(name, diem)
highscore = Highscore(name=name, diem=diem, level=level)
highscore.save()
break
else:
if err == 0:
print("Fail")
print(name, diem)
highscore = Highscore(name=name, diem=diem, level=level)
highscore.save()
break
else:
print("Bingo")
diem += 1
elif level == "normal":
while True:
pygame.font.init()
clock = pygame.time.Clock()
pygame.display.set_caption("TypeMaster")
gameWidth = 1400
gameHeight = 800
spawnWordEvent = 25
moveWordEvent = 26
increaseSpeedEvent = 27
textArea = ""
gameOver = False
level = 1
gameScore = Score(int(gameWidth*0.15), gameHeight-50)
gameHighscore = Highscore(int(gameWidth*0.72), gameHeight-50)
win = pygame.display.set_mode((gameWidth, gameHeight))
font = pygame.font.SysFont("Comic Sans MS", 30)
words = WordListMIT.listOfWords
onScreenExplosions = []
sampleExplosion = Explosion(0, 0)
bgMusic = BackgroundMusic("halo")
wordsInPlay = []
spawnInterval = 2800
movePerMs = 15
pygame.time.set_timer(spawnWordEvent, spawnInterval)
