def init(self, server, numPlayers=4):
#### Server details ####
self.whoAmI = 0
self.server = server
self.otherStrangers = 0
self.pokerMove = None # the move that is to be sent
#### Game Details ####
self.screen = 'splash' # 'game', 'gameOver', 'help', 'credits'
# 'help-game'
self.timerDelay = 0
self.tickSpeed = 10
self.font = pygame.font.Font(pygame.font.get_default_font(), 12)
self.players = [Player(i) for i in range(numPlayers)]
self.boardImage = getBoardImage(self.width, self.height)
self.statusBoardImage = getStatusBoardImage(self, 4)
self.cardScale = 30 # changes size of cards
self.cardImages = getCardImages(self.cardScale)
self.drawPlayerPositions = getDrawPlayerPositions(self, numPlayers)
self.buttonImages = getButtonImages()
self.status = GameController(numPlayers, self.players)
self.buttonPositions = dict()
#### Multiplayer Specific Fixes ####
self.status.server = self.server
self.status.firstClick = False
class Game :
"""
The main game class manages everything and runs the game loop
"""
def __init__ (self):
self.lll = LowLevelLib ()
self.inputmanager = InputManager (self)
#self.display = Display ()
self.viewspace = ViewSpace ()
self.curmap = Map (40)
# just for test
self.curmap.heights.setHeight(2,3,-1)
self.curmap.heights.setHeight(2,5,1)
self.curmap.heights.setHeight(4,5,-1)
self.gfxengine = GFXEngine (self.lll, self.viewspace, self.curmap)
self.gamecontroller = GameController (self)
self.running = False
self.starttime = 0
def run (self):
"""
Run the game.
"""
self.running = True
frames = 0
lasttick = pygame.time.get_ticks ()
while self.running :
self.inputmanager.process ()
self.gamecontroller.tick ()
self.gfxengine.tick ()
frames += 1
if pygame.time.get_ticks() - lasttick >= 1000:
print str(frames)+" fps"+(" - below 40 fps :-( !" if frames<40 else "")
frames = 0
lasttick = pygame.time.get_ticks ()
def getGfxengine(self):
"""
@return: the instance of the gfxengine of the game
"""
return self.gfxengine
def getInputmanager(self):
"""
@return: the instance of the inputmanager of the game
"""
return self.inputmanager
def run_game_program(game_board_param: GameBoard):
"""
The main function in which the game runs
:param game_board_param: GameBoard
"""
while True:
player_turn = GameController.player_next_turn(game_board_param)
if player_turn:
player_win = game_board_param.current_payer_turn
print(f"Congratulations, Player {player_win} have won!")
GameController.end_game(game_board_param)
break
def test_structs(self):
v = GameController.GCAcceleration()
self.assertIsInstance(v.x, float)
self.assertIsInstance(v.y, float)
self.assertIsInstance(v.z, float)
v = GameController.GCRotationRate()
self.assertIsInstance(v.x, float)
self.assertIsInstance(v.y, float)
self.assertIsInstance(v.z, float)
v = GameController.GCQuaternion()
self.assertIsInstance(v.x, float)
self.assertIsInstance(v.y, float)
self.assertIsInstance(v.z, float)
self.assertIsInstance(v.w, float)
def test_structs_10_14_1(self):
# XXX: Introduced in the 10.14.4 SDK
self.assertEqual(
GameController.GCExtendedGamepadSnapshotData.__struct_pack__, 1
)
v = GameController.GCExtendedGamepadSnapshotData()
self.assertIsInstance(v.version, int)
self.assertIsInstance(v.size, int)
self.assertIsInstance(v.dpadX, float)
self.assertIsInstance(v.dpadY, float)
self.assertIsInstance(v.buttonA, float)
self.assertIsInstance(v.buttonB, float)
self.assertIsInstance(v.buttonX, float)
self.assertIsInstance(v.buttonY, float)
self.assertIsInstance(v.leftShoulder, float)
self.assertIsInstance(v.rightShoulder, float)
self.assertIsInstance(v.leftThumbstickX, float)
self.assertIsInstance(v.leftThumbstickY, float)
self.assertIsInstance(v.rightThumbstickX, float)
self.assertIsInstance(v.rightThumbstickY, float)
self.assertIsInstance(v.leftTrigger, float)
self.assertIsInstance(v.rightTrigger, float)
self.assertEqual(v.supportsClickableThumbsticks, False)
self.assertEqual(v.leftThumbstickButton, False)
self.assertEqual(v.rightThumbstickButton, False)
def __init__ (self): self.lll = LowLevelLib () self.inputmanager = InputManager (self) #self.display = Display () self.viewspace = ViewSpace () self.curmap = Map (40) # just for test self.curmap.heights.setHeight(2,3,-1) self.curmap.heights.setHeight(2,5,1) self.curmap.heights.setHeight(4,5,-1) self.gfxengine = GFXEngine (self.lll, self.viewspace, self.curmap) self.gamecontroller = GameController (self) self.running = False self.starttime = 0
def __init__(self, address="0.0.0.0", port=5000):
super(Server, self).__init__()
self.CONNECTION_LIST = [] # list of socket client connected
self.port = port
self.ipaddr = address
# create a new socket
self.sockfd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sockfd.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sockfd.bind((self.ipaddr, self.port))
self.sockfd.listen(5)
self.CONNECTION_LIST.append(self.sockfd)
self.gameServer = GameController()
self.msServer = MessageController()
print "Game server started on port " + str(self.port)
def init(self, numPlayers=4):
self.hideCards = True
self.screen = 'splash' # 'game', 'gameOver', 'help', 'credits'
# 'help-game'
self.timerDelay = 0; self.tickSpeed = 10
self.font = pygame.font.Font(pygame.font.get_default_font(), 12)
self.players = [Player(i) for i in range(numPlayers)]
self.boardImage = getBoardImage(self.width, self.height)
self.statusBoardImage = getStatusBoardImage(self, 4)
self.cardScale = 30 # changes size of cards
self.cardImages = getCardImages(self.cardScale)
self.drawPlayerPositions = getDrawPlayerPositions(self,numPlayers)
self.buttonImages = getButtonImages()
self.status = GameController(numPlayers, self.players)
self.buttonPositions = dict()
self.status.chooseStartCards(self.players)
self.aiList = [None] + [AI(i) for i in range(1,numPlayers)]
self.aiDiff = 'easy'
def check_likes(self):
"""
Проверяет, кто не лайкнул посты, и съедает мышь, которая не лайкнула n последних постов
"""
posts = list(reversed(self.posts))
prev_unliked_mice = self.observers
n = 3 if len(posts) >= 3 else len(posts)
for i in range(0, n):
# находит мышей, которые не лайкнули текущий пост
unliked_mice = GameController.subtract_lists(
self.observers, posts[i].liked)
# сохраняет мышей, которые не лайкнули предыдущий пост
prev_unliked_mice = GameController.intersection_lists(
prev_unliked_mice, unliked_mice)
for mouse in prev_unliked_mice:
self.eat_mouse(mouse)
GameController.mice.remove(mouse)
print(f'Съедено {len(prev_unliked_mice)} мышей')
def on_key_press(self, symbol, modifiers):
# If choice is a number, show only cards with that cost
choice = get_choice(symbol)
if choice is not None: self.filter_catalog(choice)
# Up/Down scan through saved decklists
if symbol is pyglet.window.key.UP:
if self.remembered_deck_id > 0:
self.remembered_deck_id -= 1
new_deck = self.saved_decks[self.remembered_deck_id]
self.view.set_deck(new_deck)
else:
self.view.alert()
if symbol is pyglet.window.key.DOWN:
if self.remembered_deck_id < len(self.saved_decks) - 1:
self.remembered_deck_id += 1
new_deck = self.saved_decks[self.remembered_deck_id]
self.view.set_deck(new_deck)
else:
self.view.alert()
def save_deck(deck):
with open(DECK_FILE, 'a') as writer:
writer.write(CardCodec.encode_deck(deck) + '\n')
# Save the deck, launch the main game
if symbol is pyglet.window.key.SPACE:
if self.view.is_ready():
deck = self.view.get_deck()
save_deck(deck)
game_scene = GameController.get_new_game(
deck, single_player=SINGLE_PLAYER)
director.run(game_scene)
if symbol is pyglet.window.key.S:
deck = self.view.get_deck()
save_deck(deck)
# Add this deck to the saved decklists
self.saved_decks[-1] = deck
self.saved_decks.append([])
# Point to the new deck entry
self.remembered_deck_id = len(self.saved_decks) - 2
if symbol is pyglet.window.key.TAB:
self.view.sort_deck()
if symbol is pyglet.window.key.RIGHT:
self.view.scroll(right=True)
if symbol is pyglet.window.key.LEFT:
self.view.scroll(right=False)
def newGame(playerID, player):
#Makes a new game for the player.
game_sessions = open("../game_sessions/sessionlist", writeback=True)
# create a new entry in game_sessions
gameID = sha256(repr(time()).encode()).hexdigest()
game_sessions[gameID] = [player]
index = 0
player_list = game_sessions[gameID]
game_sessions.close()
#print(list(game_sessions.keys()))
# create a game, create a GameController for it and add the player
game = open("../game_sessions/sess_" + gameID, writeback=True)
gc = GameController()
gc.joinGame(player)
game["GameController"] = gc
game.close()
# make player session
makePlayerSession(playerID, gameID, index)
return str([pl._name for pl in player_list])
def status(user):
global flag
while True:
Viewer.menu_view(user, "MAZE")
ch = Viewer.menu_select()
if ch == '1':
GameController.start_maze(user)
break
elif ch == '2':
ranking()
elif ch == '3':
shop(user)
elif ch == '4':
inventory(user)
elif ch == '0':
flag = 1
break
else:
print("INVALID INPUT")
def read_message(self, message):
if message.startswith("DECK:"):
self.rerender = True
self.cards_to_load = message[len("DECK:"):].split(",")
if len(self.cards_to_load) > 0:
self.check_current()
else:
print "EMPTY DECK!!"
self.main.client.close()
elif message.startswith("CARDFILE:"):
self.rerender = True
s1 = message[len("CARDFILE:"):]
s2 = s1[:s1.index(":")]
#print "RECEIVED CARD "+s2+"/"+str(len(self.cards_to_load))
self.current_message = s2 + "/" + str(len(self.cards_to_load))
index = int(s2)
s3 = s1[len(s2) + 1:]
#print s3[:1000]
self.main.master_deck.unpickle_and_add_card(s3)
print "'" + self.main.master_deck.cards[-1].name + "' downloaded."
if CLIENT_PRERENDER_DECK:
self.card_img = pygame.transform.smoothscale(
self.main.master_deck.cards[-1].get_image(),
self.card_size)
self.add_to_collage()
self.check_next()
elif message.startswith("CARDFILE_ATTRIBUTES:"):
self.rerender = True
s1 = message[len("CARDFILE_ATTRIBUTES:"):]
s2 = s1[:s1.index(":")]
#print "RECEIVED CARD ATTRIBUTES "+s2+"/"+str(len(self.cards_to_load))
self.current_message = s2 + "/" + str(len(self.cards_to_load))
index = int(s2)
s3 = s1[len(s2) + 1:]
if self.matching_card.pc_attributes != s3:
#Our attributes file varies from theirs, so we have to download the entire card... poop.
self.main.client.send("REQUEST_CARDFILE:" +
str(self.card_index))
else:
self.main.master_deck.cards.append(self.matching_card)
if CLIENT_PRERENDER_DECK:
self.card_img = pygame.transform.smoothscale(
self.main.master_deck.cards[-1].get_image(),
self.card_size)
self.add_to_collage()
self.check_next()
elif message == "CLIENT_READY":
print "DURATION:", round(self.main.time - self.start_time, 3)
self.rerender = True
self.main.play_sound("connected")
import GameController
self.main.controller = GameController.GameController(self.main)
else:
return False
return True
def testStructs10_14_4(self):
self.assertEqual(
GameController.GCMicroGamepadSnapshotData.__struct_pack__, 1)
v = GameController.GCMicroGamepadSnapshotData()
self.assertIsInstance(v.version, int)
self.assertIsInstance(v.size, int)
self.assertIsInstance(v.dpadX, float)
self.assertIsInstance(v.dpadY, float)
self.assertIsInstance(v.buttonA, float)
self.assertIsInstance(v.buttonX, float)
def reset():
global current_state, processed_state, done, step_counter
current_state = deque(maxlen=4)
processed_state = deque(maxlen=4)
done = False
step_counter = 0
GameController.clear_input()
game_state = GameStateConst.GAMEPLAY
while game_state is GameStateConst.GAMEPLAY:
frame = GameManager.get_frame(frame_rate=999)
game_state = GameManager.get_current_state(frame)
if game_state is GameStateConst.GAMEPLAY:
GameController.end_current_game()
while True:
frame = GameManager.get_frame(frame_rate=999)
game_state = GameManager.get_current_state(frame)
if game_state is GameStateConst.GAMEPLAY:
update_state(frame, False)
return current_state, processed_state, done
if game_state is GameStateConst.MENU_SCREEN:
GameController.press_play()
def main():
s3 = boto3.client('s3', aws_access_key_id='<NONE>', aws_secret_access_key='<NONE>')
# Get the object from the event and show its content type
bucket = 'chess-private-content'
# key = 'Capablanca.pgn'
key = 'WorldChamp2016.pgn'
response = s3.get_object(Bucket=bucket, Key=key)
body = response['Body'].read().decode('utf-8').replace('\r\n','\n')
parsedGames = GameController.processPGNText(body)
print(len(parsedGames))
def reset_controller(self):
"""
Reset the controller
"""
try:
self.con = gc.Controller()
self.con.connect()
self.con.setSpeed(2.0)
self.con.setRotateSpeed(40.)
print("successfully connect to game controller")
except:
print('Error: Socket Connection failed')
print('did you open your unity exe file?')
sys.exit()
def command(**kwargs):
inputFilename = kwargs['pgnfile']
# very trivial way to check for the extension
if inputFilename[-4:] != ".pgn":
print("The input file should be .pgn")
return
inputPartialFrom = kwargs.get('partialfrom', None)
inputPartialTo = kwargs.get('partialto', None)
if not ((inputPartialFrom and inputPartialTo) or
(not inputPartialFrom and not inputPartialTo)):
print(
"Either both or none should be specified: --partialFrom , --partialTo"
)
return
if inputPartialFrom and inputPartialTo:
GameController.processPGNFilePartial(inputFilename, inputPartialFrom,
inputPartialTo)
else:
GameController.processPGNFile(inputFilename)
def testStructs(self):
self.assertEqual(GameController.GCGamepadSnapShotDataV100.__struct_pack__, 1)
v = GameController.GCGamepadSnapShotDataV100()
self.assertIsInstance(v.version, int)
self.assertIsInstance(v.size, int)
self.assertIsInstance(v.dpadX, float)
self.assertIsInstance(v.dpadY, float)
self.assertIsInstance(v.buttonA, float)
self.assertIsInstance(v.buttonB, float)
self.assertIsInstance(v.buttonX, float)
self.assertIsInstance(v.buttonY, float)
self.assertIsInstance(v.leftShoulder, float)
self.assertIsInstance(v.rightShoulder, float)
def __init__ (self): self.lll = LowLevelLib () self.inputmanager = InputManager (self) #self.display = Display () self.viewspace = ViewSpace () self.curmap = Map (40) # just for test self.curmap.heights.setHeight(2,3,-1) self.curmap.heights.setHeight(2,5,1) self.curmap.heights.setHeight(4,5,-1) self.gfxengine = GFXEngine (self.lll, self.viewspace, self.curmap) self.gamecontroller = GameController (self) self.running = False self.starttime = 0
def eval_genomes(self, genomes, config):
for genome_id, genome in genomes:
self.final_score = 0
self.inputs = []
self.net = neat.nn.FeedForwardNetwork.create(genome, config)
game = GameController.GameController(self)
while game.playing_game:
pass
self.final_score = game.score
genome.fitness = self.final_score
if self.num % self.numPerGen == 0:
self.num = 1
self.gen += 1
self.num += 1
def main():
pygame.init()
done = False
# Start the clock
clock = pygame.time.Clock()
# Lock cursor to window
#pygame.event.set_grab(True)
# Build Game Controller
gameController = GameController.GameController()
# Loop Start
while not done:
gameController.handleInput()
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
done = True
gameController.update()
gameController.draw()
# Throttle frame rate
clock.tick(const.FRAME_RATE)
# Uncomment below to output fps to console
#print(clock.get_fps())
# Flip to user
pygame.display.flip()
#Loop End
pygame.quit()
sys.exit()
def close():
GameManager.stop_screen_recorder()
GameController.clear_input()
def setUp(self):
self.gameController = GameController()
Homework : Final Term Project
Description: A console based Tic Tac Toe game
"""
from GameBoard import GameBoard
import GameController
def run_game_program(game_board_param: GameBoard):
"""
The main function in which the game runs
:param game_board_param: GameBoard
"""
while True:
player_turn = GameController.player_next_turn(game_board_param)
if player_turn:
player_win = game_board_param.current_payer_turn
print(f"Congratulations, Player {player_win} have won!")
GameController.end_game(game_board_param)
break
if __name__ == "__main__":
print("Welcome to our Tic Tac Toe game!")
game_board = GameController.start_game()
run_game_program(game_board)
exit("The game has ended...")
import sys
sys.path.append('../')
from GameController import *
from User import *
newGame = GameController()
player1 = User()
newGame.hostGame(player1, socket.gethostbyname(''), 10000)
from GameController import *
g1 = GameController("gens.exe")
g1.startGame()
class TestGameControllerTestCase(unittest.TestCase):
def test_canary(self):
self.assertTrue(True)
def setUp(self):
self.gameController = GameController()
def test_expose_cell(self):
self.assertTrue(self.gameController.exposeCell(7, 8))
def test_expose_exposed_cell(self):
self.gameController.exposeCell(2, 8)
self.assertFalse(self.gameController.exposeCell(2, 8))
def test_seal_cell(self):
self.assertTrue(self.gameController.toggleSeal(2, 3))
def test_expose_sealed_cell(self):
self.gameController.toggleSeal(1, 2)
self.assertFalse(self.gameController.exposeCell(1, 2))
def test_unseal_sealed_cell(self):
self.gameController.toggleSeal(2, 3)
self.assertTrue(self.gameController.toggleSeal(2, 3))
def test_seal_exposed_cell(self):
self.gameController.exposeCell(3, 7)
self.assertFalse(self.gameController.toggleSeal(3, 7))
def test_count_mines_next_to_empty_cell(self):
self.assertEquals(0, self.gameController.countMines(8, 9))
def test_count_mines_for_cell_next_to_1_mine(self):
self.gameController.setMine(5, 4)
self.assertEquals(1, self.gameController.countMines(5, 5))
def test_count_mines_for_cell_next_to_2_mines(self):
self.gameController.setMine(5, 4)
self.gameController.setMine(5, 6)
self.assertEquals(2, self.gameController.countMines(5, 5))
def test_count_mines_for_cell_next_to_3_mines(self):
self.gameController.setMine(5, 4)
self.gameController.setMine(5, 6)
self.gameController.setMine(4, 4)
self.assertEquals(3, self.gameController.countMines(5, 5))
def test_count_mines_for_cell_next_to_4_mines(self):
self.gameController.setMine(5, 4)
self.gameController.setMine(5, 6)
self.gameController.setMine(4, 4)
self.gameController.setMine(4, 5)
self.assertEquals(4, self.gameController.countMines(5, 5))
def test_count_mines_for_cell_next_to_5_mines(self):
self.gameController.setMine(5, 4)
self.gameController.setMine(5, 6)
self.gameController.setMine(4, 4)
self.gameController.setMine(4, 5)
self.gameController.setMine(4, 6)
self.assertEquals(5, self.gameController.countMines(5, 5))
def test_count_mines_for_cell_next_to_6_mines(self):
self.gameController.setMine(5, 4)
self.gameController.setMine(5, 6)
self.gameController.setMine(4, 4)
self.gameController.setMine(4, 5)
self.gameController.setMine(4, 6)
self.gameController.setMine(6, 4)
self.assertEquals(6, self.gameController.countMines(5, 5))
def test_count_mines_for_cell_next_to_7_mines(self):
self.gameController.setMine(5, 4)
self.gameController.setMine(5, 6)
self.gameController.setMine(4, 4)
self.gameController.setMine(4, 5)
self.gameController.setMine(4, 6)
self.gameController.setMine(6, 4)
self.gameController.setMine(6, 5)
self.assertEquals(7, self.gameController.countMines(5, 5))
def test_count_mines_for_cell_next_to_8_mines(self):
self.gameController.setMine(5, 4)
self.gameController.setMine(5, 6)
self.gameController.setMine(4, 4)
self.gameController.setMine(4, 5)
self.gameController.setMine(4, 6)
self.gameController.setMine(6, 4)
self.gameController.setMine(6, 5)
self.gameController.setMine(6, 6)
self.assertEquals(8, self.gameController.countMines(5, 5))
def test_exposing_cells_on_an_empty_board(self):
counter = 0
self.gameController.recursiveExposeEmptyCells(5,5)
for x in range (self.gameController.getSize()):
for y in range (self.gameController.getSize()):
if (self.gameController.isExposed(x,y) == True):
counter +=1
self.assertEquals(100, counter)
def test_exposing_cells_on_1_mine_board(self):
counter = 0
self.gameController.setMine(0,0)
self.gameController.recursiveExposeEmptyCells(9, 0)
for x in range (0, self.gameController.getSize()):
for y in range (0, self.gameController.getSize()):
if (self.gameController.isExposed(x,y) == True):
counter +=1
self.assertEquals(99, counter)
def test_exposing_cells_on_a_group_of_5_mines_board(self):
counter = 0
self.gameController.setMine(0,0)
self.gameController.setMine(0,1)
self.gameController.setMine(0,2)
self.gameController.setMine(0,3)
self.gameController.setMine(0,4)
self.gameController.recursiveExposeEmptyCells(9, 0)
for x in range (0, self.gameController.getSize()):
for y in range (0, self.gameController.getSize()):
if (self.gameController.isExposed(x,y) == True):
counter +=1
self.assertEquals(95, counter)
def test_exposing_on_1_sealed_cell_board(self):
counter = 0
self.gameController.toggleSeal(1, 1)
self.gameController.recursiveExposeEmptyCells(1, 2)
for x in range (0, self.gameController.getSize()):
for y in range (0, self.gameController.getSize()):
if (self.gameController.isExposed(x,y) == True):
counter +=1
self.assertEquals(99, counter)
def test_exposing_on_5_sealed_cell_board(self):
counter = 0
self.gameController.toggleSeal(1, 1)
self.gameController.toggleSeal(9, 3)
self.gameController.toggleSeal(5, 1)
self.gameController.toggleSeal(4, 1)
self.gameController.toggleSeal(3, 1)
self.gameController.recursiveExposeEmptyCells(9, 0)
for x in range (0, self.gameController.getSize()):
for y in range (0, self.gameController.getSize()):
if (self.gameController.isExposed(x,y) == True):
counter +=1
self.assertEquals(95, counter)
def test_is_game_over_if_exposed_mined_cell(self):
self.gameController.setMine(1,1)
self.gameController.exposeCell(1,1)
self.assertTrue(self.gameController.isGameOver(1,1))
def test_is_game_over_if_exposed_non_mined_cell(self):
self.gameController.exposeCell(4,5)
self.assertFalse(self.gameController.isGameOver(4,5))
def test_win_game_if_sealed_all_existing_mines_and_exposed_the_rest(self):
self.gameController.setMine(0,0)
self.gameController.setMine(0,1)
self.gameController.toggleSeal(0,0)
self.gameController.toggleSeal(0,1)
self.gameController.recursiveExposeEmptyCells(9,0)
self.assertTrue(self.gameController.winGame())
def test_win_game_if_mine_is_not_sealed_yet(self):
self.gameController.setMine(0,0)
self.gameController.recursiveExposeEmptyCells(9,9)
self.assertFalse(self.gameController.winGame())
import pydealer as pyd
import dealerhelper as pydh
import discord
import asyncio
import GameController as gc
deck = pyd.Deck()
deck.shuffle()
hand = deck.deal(13)
hand.spades_sort()
game = gc.GameTable()
p1 = gc.Player('p1', '1', game)
p2 = gc.Player('p2', '2', game)
p3 = gc.Player('p3', '3', game)
p4 = gc.Player('p4', '4', game)
game.add_player(p1)
game.add_player(p2)
game.add_player(p3)
game.add_player(p4)
game.start_game()
print(p1.hand)
class MainController:
def __init__(self, root):
self.root = root
self.root.title("The Towers of Hanoi")
#create the menu page, create and pack images and widgets
self.mainFrame = Frame(self.root, borderwidth = 15)
self.mainFrame.pack()
self.title = Label(self.mainFrame, text = "The Towers of Hanoi",\
font = ("papyrus", 30, "bold"))
self.title.grid(row = 0, column = 0, columnspan = 2)
self.background = PhotoImage(file = "hanoi1.gif")
self.imageLabel = Label(self.mainFrame, image = self.background)
self.imageLabel.grid(row = 1, column = 0)
self.buttonFrame = Frame(self.mainFrame)
self.buttonFrame.grid(row = 1, column = 1)
#-----------------------------------------------
#we used labels, and binded them to events so that
#they function just like buttons
self.gameLabel = Label(self.buttonFrame, text = "Game Mode",\
font = LABEL_NORM_FONT)
#"<Button_1">: when users clicks a widget
self.gameLabel.bind("<Button-1>", self.gamePanel)
#"<Enter>": when the cursor moves into the widget
self.gameLabel.bind("<Enter>", self.activate)
#"<Leave>": when cursor leaves widget
self.gameLabel.bind("<Leave>", self.deactivate)
self.gameLabel.pack(side = "top")
self.demoLabel = Label(self.buttonFrame, text = "Demo Mode",\
font = LABEL_NORM_FONT)
self.demoLabel.bind("<Button-1>", self.demoPanel)
self.demoLabel.bind("<Enter>", self.activate)
self.demoLabel.bind("<Leave>", self.deactivate)
self.demoLabel.pack()
self.ruleLabel = Label(self.buttonFrame, text = "Game Rules",\
font = LABEL_NORM_FONT)
self.ruleLabel.bind("<Button-1>", self.showHelp)
self.ruleLabel.bind("<Enter>", self.activate)
self.ruleLabel.bind("<Leave>", self.deactivate)
self.ruleLabel.pack()
self.exitLabel = Label(self.buttonFrame, text = "Exit",\
font = LABEL_NORM_FONT)
self.exitLabel.bind("<Button-1>", self.exitGame)
self.exitLabel.bind("<Enter>", self.activate)
self.exitLabel.bind("<Leave>", self.deactivate)
self.exitLabel.pack()
#-------------------------------------------------
#create a frame to hold the demo panel(not displayed yet)
self.demoFrame = Frame(self.root)
#create an instance of demo controller
#which creates a demo panel rooted in demo frame
self.createDemoFrame(self.demoFrame)
#--------------------------------------------------
#create a frame to hold the game panel(not displayed yet)
self.gameFrame = Frame(self.root)
#call function to create an instance of game controller
#which creates a game panel rooted in game frame
self.createGameFrame(self.gameFrame)
#Narrative: unpacks all frames from root window with try-except
#Precondition: called
#Postcondition: everything cleared from window, so that the calling function
#may display the right frame
def hideAll(self):
#the .winfo_children function returns a list of all the children
#widgets rooted in a parent window
for w in self.root.winfo_children():
try:
#pack_forget() hides a widget from view
w.pack_forget()
#the pass statement doesn't do anything, simply moves onto
#the next iteration
except:
pass
#Narrative: display the game frame (unpack all, then pack game frame)
#Precondition: "Game Mode" label is clicked
#Postcondition: the game panel is displayed
def gamePanel(self, event):
self.hideAll()
self.gameFrame.pack()
#Narrative: display the demo frame (unpack all, then pack demo frame)
#Precondition: "Demo Mode" label is clicked
#Postcondition: the demo panel is displayed
def demoPanel(self, event):
self.hideAll()
self.demoFrame.pack()
#Narrative: create an instance of game controller
#Precondition: called; a root frame passed in
#Postcondition: an instance of game controller is created
def createGameFrame(self, frame):
self.gameController = GameController(frame)
#add callback funtion so that user can return from game to main menu
self.gameController.addReturnCallBack(self.mainMenu)
#Narrative: create an instance of demo controller
#Precondition: called, a root frame passed in
#Postcondition: an instance of demo controller is created
def createDemoFrame(self, frame):
self.demoController = DemoController(frame)
#add callback funtion so that user can return from demo to main menu
self.demoController.addReturnCallBack(self.mainMenu)
#Narrative: shows a top window for instructions
#Precondition: "Help" label is clicked
#Postcondition: the top window is displayed
def showHelp(self, event):
self.helpWindow = Toplevel()
self.help = Help(self.helpWindow)
#Narrative: display the main menu, (unpack all, pack main Frame)
#Precondition: called
#Postcondition: main menu is displayed
def mainMenu(self):
self.hideAll()
self.mainFrame.pack()
#Narrative: exit the game by destroying the tkinter root window
#Precondition: "Exit" label is clicked
#Postcondition: the window is destroyed, program ends
def exitGame(self, event):
self.root.destroy()
#Narrative: changes a widget when cursor moves over it
#Precondition: when the cursor moves into a widget
#Postcondition: the widget changes color and becomes larger
def activate(self, event):
#evenr.widget returns the widget at which the event happened
event.widget.config(foreground = "red", font = LABEL_ACTIVE_FONT)
#Narrative: changes a widget back when cursor leaves it
#Precondition: when the cursor leaves a widget
#Postcondition: the widget returns to normal state
def deactivate(self, event):
event.widget.config(foreground = "black", font = LABEL_NORM_FONT)
#! /usr/bin/python3
import pygame
import GameView
import GameController
import GameMenu
import GameModel
if __name__ == "__main__":
pygame.mixer.pre_init(44100, -16, 2, 4096)
pygame.mixer.init()
pygame.init()
gameModel = GameModel.GameModel()
gameMenu = GameMenu.GameMenu()
gameView = GameView.GameView(gameMenu.screen, gameModel)
gameController = GameController.GameController(gameView, gameMenu)
gameController.main_menu()
def step(action):
global step_counter
step_counter += 1
GameController.take_action(action)
while True:
frame = GameManager.get_frame()
game_state = GameManager.get_current_state(frame)
# print("Current Frame:", step_counter, "Identified as:", game_state)
if game_state is GameStateConst.UNDEF:
GameController.clear_input()
if game_state is GameStateConst.GAME_OVER_SCREEN:
update_state(frame, True)
GameController.game_over_script()
return current_state, processed_state, done
if game_state is GameStateConst.GAMEPLAY:
update_state(frame, False)
return current_state, processed_state, done
if game_state is GameStateConst.LVL_TRANSITION_SCREEN:
update_state(frame, False)
GameController.clear_input()
return current_state, processed_state, done
if game_state is GameStateConst.LVL_UP_SCREEN:
GameController.lvl_up_script()
if game_state is GameStateConst.MENU_SCREEN:
GameController.press_play()
class PokerGame(object):
def init(self, numPlayers=4):
self.hideCards = True
self.screen = 'splash' # 'game', 'gameOver', 'help', 'credits'
# 'help-game'
self.timerDelay = 0; self.tickSpeed = 10
self.font = pygame.font.Font(pygame.font.get_default_font(), 12)
self.players = [Player(i) for i in range(numPlayers)]
self.boardImage = getBoardImage(self.width, self.height)
self.statusBoardImage = getStatusBoardImage(self, 4)
self.cardScale = 30 # changes size of cards
self.cardImages = getCardImages(self.cardScale)
self.drawPlayerPositions = getDrawPlayerPositions(self,numPlayers)
self.buttonImages = getButtonImages()
self.status = GameController(numPlayers, self.players)
self.buttonPositions = dict()
self.status.chooseStartCards(self.players)
self.aiList = [None] + [AI(i) for i in range(1,numPlayers)]
self.aiDiff = 'easy'
def mousePressed(self, x, y):
# button interactions
if self.screen in ['help', 'credits', 'how-to-play-poker']:
self.screen = 'splash'
elif self.screen == 'gameOver': PokerGame.init(self)
elif self.screen == 'help-game': self.screen = 'game'
elif self.screen == 'splash':
if self.status.isInBounds(self.startButtons,'start-game',x,y):
self.screen = 'game'
elif self.status.isInBounds(self.startButtons,'help',x,y):
self.screen = 'help'
elif self.status.isInBounds(self.startButtons,'credits',x,y):
self.screen = 'credits'
elif self.status.isInBounds(self.startButtons,
'how-to-play-poker',x,y):
self.screen = 'how-to-play-poker'
elif self.status.currentPlayer == 0 and self.status.gameOver == False\
and self.screen == 'game':
if self.status.isInBounds(self.buttonPositions,'check-call',x,y):
self.status.move('check/call', self.status.currentPlayer,
self.players)
elif self.status.isInBounds(self.buttonPositions,'fold',x,y):
self.status.move('fold', self.status.currentPlayer,
self.players)
elif self.status.isInBounds(self.buttonPositions,'raise',x,y):
self.status.move('raise', self.status.currentPlayer,
self.players)
elif self.status.isInBounds(self.buttonPositions,'home',x,y):
PokerGame.init(self)
elif self.status.isInBounds(self.buttonPositions,'end-game',x,y):
self.screen = 'gameOver'
self.status.getWinner(self.players)
elif self.status.isInBounds(self.buttonPositions,
'help-game',x,y):
self.screen = 'help-game'
def mouseReleased(self, x, y):
pass
def mouseMotion(self, x, y):
pass
def mouseDrag(self, x, y):
pass
def keyPressed(self, keyCode, modifier):
if self.status.gameOver == False and self.screen == 'game':
# set AI difficulty
if keyCode == pygame.K_1: self.aiDiff = 'easy'
if keyCode == pygame.K_2: self.aiDiff = 'medium'
def keyReleased(self, keyCode, modifier):
pass
def timerFired(self, dt):
for player in self.players:
if player.money < 0: player.money = 0
self.status.currentPlayer %= len(self.players)
if self.status.gameOver == True: self.screen = 'gameOver'
elif self.status.gameOver == False:
# refreshes one of the checkers for folding/advancing
self.timerDelay += 1
for betID in self.status.betStatus:
if self.players[betID].money == 0:
if self.players[betID].foldStatus == True:
self.status.betStatus[betID] = 0
else:
self.status.betStatus[betID] = 1
if self.players[self.status.currentPlayer].foldStatus == True:
self.status.currentPlayer += 1; return
# increasing the bet!
if PokerGame.isKeyPressed(self, pygame.K_UP) and\
self.status.tempBet < self.players[0].money:
self.status.tempBet += 1
if PokerGame.isKeyPressed(self, pygame.K_DOWN) and\
self.status.tempBet >= self.status.minBet:
self.status.tempBet -= 1
# delays ai speed
if self.timerDelay > self.tickSpeed:
# ai functions go here!
self.timerDelay = 0
if self.status.currentPlayer != 0: # the human player
currentAI = self.aiList[self.status.currentPlayer]
currentAI.aiMove(self.aiDiff, self.players, self.status)
def redrawAll(self, screen):
if self.screen == 'splash':
drawTitle(self, screen)
drawSplashButtons(self, screen)
elif self.screen == 'game':
drawBackground(self, screen)
drawTableCards(self, screen)
drawPlayerStatus(self, screen)
drawPlayerCards(self, screen)
drawGameButtons(self, screen)
drawStatusBoard(self, screen)
drawPokerChips(self, screen)
drawTableChips(self, screen)
elif self.screen == 'gameOver':
drawTitle(self, screen)
drawGameOver(self, screen)
elif self.screen == 'help' or self.screen == 'help-game':
drawTitle(self, screen)
drawHelpText(self, screen)
elif self.screen == 'how-to-play-poker':
drawTitle(self, screen)
drawInsText(self, screen)
elif self.screen == 'credits':
drawTitle(self, screen)
drawCreditsText(self, screen)
pygame.display.flip() # not redrawing entire board every frame
def isKeyPressed(self, key):
''' return whether a specific key is being held '''
return self._keys.get(key, False)
def __init__(self, width=800, height=600, fps=60,
title="Poker - Single Player Client"):
self.width = width
self.height = height
self.fps = fps
self.title = title
self.bgColor = (255, 255, 255)
pygame.init()
def run(self):
clock = pygame.time.Clock()
screen = pygame.display.set_mode((self.width, self.height))
# set the title of the window
pygame.display.set_caption(self.title)
# stores all the keys currently being held down
self._keys = dict()
# call game-specific initialization
self.init()
playing = True
while playing:
time = clock.tick(self.fps)
self.timerFired(time)
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
self.mousePressed(*(event.pos))
elif event.type == pygame.MOUSEBUTTONUP and event.button == 1:
self.mouseReleased(*(event.pos))
elif (event.type == pygame.MOUSEMOTION and
event.buttons == (0, 0, 0)):
self.mouseMotion(*(event.pos))
elif (event.type == pygame.MOUSEMOTION and
event.buttons[0] == 1):
self.mouseDrag(*(event.pos))
elif event.type == pygame.KEYDOWN:
self._keys[event.key] = True
self.keyPressed(event.key, event.mod)
elif event.type == pygame.KEYUP:
self._keys[event.key] = False
self.keyReleased(event.key, event.mod)
elif event.type == pygame.QUIT:
playing = False
screen.fill(self.bgColor)
self.redrawAll(screen)
pygame.quit()
import GameController as gc
import imgdecode as imd
import numpy as np
import cv2
con = gc.Controller()
con.connect()
keyarray = np.zeros(128, dtype=np.int)
while True:
img = con.getDepth()
img = imd.decode(img)
cv2.imshow('Depth', img)
key = cv2.waitKey(10)
if key <= 127:
keyarray[key] = ~keyarray[key]
ckey = chr(key)
if ckey.isalnum():
if keyarray[key] != 0:
con.KeyDown(ckey)
else:
con.KeyUp(ckey)
elif key == 27:
break
con.close()
def createGameFrame(self, frame):
self.gameController = GameController(frame)
#add callback funtion so that user can return from game to main menu
self.gameController.addReturnCallBack(self.mainMenu)
