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 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)