def place_pdu(self, context, client, x, y):
if client == context.socket_player_white:
if GameLogic.is_valid_position(context.boardmodel, x, y, Player.WHITE):
affected_positions = GameLogic.get_affected_positions(context.boardmodel, x, y, Player.WHITE)
GameLogic.apply_move(context.boardmodel, x, y, Player.WHITE)
board_pdu = GameClientPDUCodec.update_board_pdu(Player.WHITE, affected_positions)
context.request.send_req(context.socket_player_white, board_pdu)
context.request.send_req(context.socket_player_black, board_pdu)
next_turn_player = GameLogic.next_turn_player(context.boardmodel, Player.WHITE)
white_count, black_count = context.boardmodel.count_disks()
# if white_count > 4:
# context.end_game()
if next_turn_player == Player.WHITE:
context.turn = context.socket_player_white
context.state = context.WHITE_TURN
context.state.turn_req(context)
elif next_turn_player == Player.BLACK:
context.turn = context.socket_player_black
context.state = context.BLACK_TURN
context.state.turn_req(context)
else:
# no valid movements->board full or no valid placements for any player
context.end_game()
else:
context.request.send_req(client, GameClientPDUCodec.place_error_pdu())
context.request.send_req(client, GameClientPDUCodec.turn_pdu())
else:
# not your turn
# read protocol, I don't remember if it's specified to report the error or not
context.request.send_req(client, GameClientPDUCodec.place_error_pdu())
def test_check_ace_eleven(self):
gameLogic = GameLogic()
player = Player(
[Card('Hearts', 'A'), Card('Clubs', '2')], False, False, 500, 0)
self.assertEqual(
gameLogic.checkSum(player), 13,
f"gameLogic.checkSum(player) = {gameLogic.checkSum(player)} // Player hand should sum to 13 because A is valued as 11"
)
def test_sum(self):
gameLogic = GameLogic()
player = Player(
[Card('Hearts', 'A'), Card('Clubs', 'J')], False, True, 500, 0)
self.assertEqual(
gameLogic.checkSum(player), 21,
f"gameLogic.checkSum(player) = {gameLogic.checkSum(player)} // Ace and Jack should sum to 21"
)
def test_check_double_ace(self):
gameLogic = GameLogic()
player = Player(
[Card('Hearts', 'A'), Card('Clubs', 'A')], False, False, 500, 0)
self.assertEqual(
gameLogic.checkSum(player), 12,
f"gameLogic.checkSum(player) = {gameLogic.checkSum(player)} // Player hand should be 12 because one A is valued as 11 and one as 1"
)
def __init__(self):
self.controller = Controller()
self.Handler = EventHandler(self.controller)
self.object_list = []
self.game_logic = GameLogic()
self.fps_clock = pygame.time.Clock()
self.fps = 60
self.neuralnet = NeuralNetHolder()
self.version = "v1.01"
def test_check_ace_one(self):
gameLogic = GameLogic()
player = Player(
[Card('Hearts', 'A'),
Card('Clubs', 'J'),
Card('Clubs', '9')], False, False, 500, 0)
self.assertEqual(
gameLogic.checkSum(player), 20,
f"gameLogic.checkSum(player) = {gameLogic.checkSum(player)} // Player hand should sum to 20 because A is valued as 1"
)
def test_check_double_ace_and_normal_card(self):
gameLogic = GameLogic()
player = Player(
[Card('Hearts', 'A'),
Card('Clubs', 'A'),
Card('Clubs', '10')], False, False, 500, 0)
self.assertEqual(
gameLogic.checkSum(player), 12,
f"gameLogic.checkSum(player) = {gameLogic.checkSum(player)} // Player hand should be 12 because both aces are valued as 1"
)
def run(col, row, k, ai_path_1, ai_path_2, fh, mode='t', full_path=None):
if full_path is not None:
ai_path_1 = full_path + ai_path_1
ai_path_2 = full_path + ai_path_2
main = GameLogic(col, row, k, 'l', debug=True)
return main.Run(fh=fh,
mode=mode,
ai_path_1=ai_path_1,
ai_path_2=ai_path_2,
time=1200)
def __init__(self): # Initialize key objects
self.game = GameLogic()
self.grid = GameGrid()
self.human = HumanView(self.game, self.grid)
self.ai = AI_View(self.game, self.grid)
self.showTitle()
def draw(self, widget=None, events=None):
self.drawingarea.window.draw_pixbuf(
None, self.scaledbackground, 0, 0, int(round(self.shift_x)), int(round(self.shift_y))
)
for i in range(self.request.board_model.get_size()):
for j in range(self.request.board_model.get_size()):
player = self.request.board_model.get(i, j)
if player == Player.WHITE:
self.draw_cell(i, j, self.scaledwhite)
elif player == Player.BLACK:
self.draw_cell(i, j, self.scaledblack)
elif (
self.yourturn
and self.toolbuttonShowHint.get_active()
and GameLogic.is_valid_position(self.request.board_model, i, j, self.player)
):
self.draw_cell(i, j, self.scaledhint)
if (
self.yourturn
and self.selection_row is not None
and self.selection_column is not None
and self.selection_valid
):
self.drawingarea.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
self.draw_cell(
self.selection_row,
self.selection_column,
self.scaledwhite if self.player == Player.WHITE else self.scaledblack,
)
else:
self.drawingarea.window.set_cursor(None)
def initialize(self):
self.player_frame = Frame(self.root)
self.player_frame.pack(side=LEFT)
self.enemy_frame = Frame(self.root)
self.enemy_frame.pack(side=LEFT)
self.menu_frame = Frame(self.root)
self.menu_frame.pack(side=LEFT)
# initialize GUI for player board
divider = Label(self.player_frame,
text=' \n \n \n \n \n \n \n \n \n \n')
divider.pack(side=TOP)
self.enemy_buttons_2d_array = [[
0 for x in range(self.player_board.get_board_size() + 1)
] for y in range(self.player_board.get_board_size() + 1)]
# initialize GUI for enemy board
for i in range(0, self.enemy_board.get_board_size()):
for j in range(0, self.enemy_board.get_board_size()):
b = Button(
self.enemy_frame,
text=' ',
command=lambda x=j, y=i: self.button_click_at_pos(x, y),
background="yellow")
b.grid(row=i, column=j)
self.enemy_buttons_2d_array[j][i] = b
self.player_info_label = Label(self.menu_frame,
text='You still have ships: ')
self.player_info_label.pack(side=TOP)
self.enemy_info_label = Label(self.menu_frame,
text='Enemy still have ships: ')
self.enemy_info_label.pack(side=TOP)
greenbutton = Button(self.menu_frame,
text="Restart game",
command=lambda: self.restart_game(),
fg="brown")
greenbutton.pack(side=LEFT)
self.game_logic = GameLogic(self.player_board, self.enemy_board)
def game_init(self):
self.request.send_req(self.socket_player_white, GameClientPDUCodec.connect_ok_pdu(Player.WHITE))
self.request.send_req(self.socket_player_black, GameClientPDUCodec.connect_ok_pdu(Player.BLACK))
initial_board = GameLogic.initial_board_as_affected_positions(8)
self.request.send_req(self.socket_player_white, GameClientPDUCodec.update_board_pdu(Player.WHITE, initial_board[0]))
self.request.send_req(self.socket_player_white, GameClientPDUCodec.update_board_pdu(Player.BLACK, initial_board[1]))
self.request.send_req(self.socket_player_black, GameClientPDUCodec.update_board_pdu(Player.WHITE, initial_board[0]))
self.request.send_req(self.socket_player_black, GameClientPDUCodec.update_board_pdu(Player.BLACK, initial_board[1]))
self.request.send_req(self.socket_player_black, GameClientPDUCodec.turn_pdu())
def RunGameHuman(self):
self.LoadObstacles()
self.game = GameLogic(self, self.screen, self.level, self.text)
self.GetSprites()
self.player.DrawPlayer(self.screen)
for o in self.obList:
o.DrawObstacle(self.screen)
self.menu.StartGame(self.screen)
while self.playing and not self.collision.CheckCollision(
self.obList, self.player):
# Get the player movement
self.HandlePlayerMovement()
# Add other Obstacles
self.AddObstacle()
# Run the game logic
self.game.TheGame(self.obList)
# Refresh Rate
self.clock.tick(120)
pygame.time.delay(1000)
self.menu.EndGameScreen(self.screen, self.player)
pygame.time.delay(5000)
self.menu.SetState('MainMenu')
class GuessingGame:
def __init__(self, max_tries=5):
self.logic = GameLogic(max_tries)
def start(self):
print(
f"Welcome to NumGuesser!\n You have {self.logic.max_tries} tries to guess the right number between 1-1000.\n Do you want a starting clue?\nYes(Y), No(N)> "
)
choice = input()
if (choice.lower() == "y"):
print(self.logic.clue())
elif (choice.lower() == "n"):
print("No clue it is. Lets roll!")
else:
print("That's not a command, no clue for you. Lets roll!")
running = True
while running:
print("Make your guess> ")
guess = input()
if (self.logic.make_guess(guess)):
running = False
print("Correct answer!")
else:
tries_left = self.logic.tries_left()
if (tries_left == 0):
print(
f"You're out of tries, game over! Correct Answer was {self.logic.answer}"
)
running = False
else:
print(
f"That's not quite it, You have {tries_left} tries left. here's a new clue!"
)
print(self.logic.clue())
def run_algorithm(algorithm, board, board_size):
logic = GameLogic(State(board), board_size)
if algorithm == 1:
ids = IDS(State(board), logic)
chosen = ids.run_search()
elif algorithm == 2:
bfs = BFS(State(board), logic)
chosen = bfs.run_search()
elif algorithm == 3:
a_star = Astar(State(board), logic)
chosen = a_star.run_search()
else:
raise Exception("No algorithm was chosen")
if chosen is not None:
to_print = ' '.join(map(str, chosen))
with open('output.txt', 'w') as output_file:
output_file.write(to_print)
def make_app():
logic = GameLogic()
_app = CokeApp(logic)
return _app
def __init__(self, max_tries=5):
self.logic = GameLogic(max_tries)
(r"/logout", LogoutHandler, dict(logic=logic)),
(r"/chat/new", ChatMessageHandler, dict(logic=logic)),
(r"/chat/update", ChatUpdateHandler, dict(logic=logic))
]
#create random + safe cookie_secret key
secret = base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes)
settings = {
"static_path": os.path.join(os.path.dirname(__file__), "static"),
"template_path": os.path.join(os.path.dirname(__file__), "templates"),
"cookie_secret": secret,
"login_url": "/login",
"xsrf_cookies":True,
"debug":options.debug,
}
tornado.web.Application.__init__(self, handlers, **settings)
def make_app():
logic = GameLogic()
_app = CokeApp(logic)
return _app
if __name__ == "__main__":
logic = GameLogic()
app = CokeApp(logic)
app.listen(options.port)
tornado.ioloop.IOLoop.current().spawn_callback(minute_loop, logic)
tornado.ioloop.IOLoop.current().start()
def updated_board_ind(self, context, player, affected_positions):
GameLogic.apply_updated_positions(context.board_model, player, affected_positions)
context.indication.updated_board_ind(player, affected_positions)
class GameLoop:
def __init__(self): # Initialize key objects
self.game = GameLogic()
self.grid = GameGrid()
self.human = HumanView(self.game, self.grid)
self.ai = AI_View(self.game, self.grid)
self.showTitle()
'''
Evaluates player's guess against opponent fired upon:
1. If the opponent's ship is hit, opponent's display grid is updated
2. Prints results of the shot
'''
def shootAt(self, guess, opponent):
result, label, shipKey = self.game.fire(
guess, opponent) # Retrieve results of the guess
if opponent == 'AI': # Opponent = AI
print "Results:"
if result: # Hit
if label == "X": # Ship did not sink
self.grid.update(guess,
label, opponent) # update display with a "X"
print("You hit one of the AI's ship!"),
else:
for cell in self.game.aiShips[shipKey]: # Sunk ship
self.grid.update(cell,
label, opponent) # reveal ship type on game grid for human player
print("You sunk an AI ship!"),
else: # Miss
print("You missed!"),
else: # Opponent = Human
if result: # Hit
if label == "X": # Ship did not sink
self.grid.update(guess,
label, opponent) # update display with a "X"
print("AI hit one of your ships!")
else:
label = "O" # Sunk ship
for cell in self.game.humanShips[shipKey]: # removes ship from the display grid
self.grid.update(cell, label, opponent)
print("AI sunk your ship!")
else: # Miss
print("AI missed!")
print""
def showTitle(self): # Title & Credits
print ("""
Welcome to PYSHIP V1.0
A battleship game written in Python
By Ray "Cyberpup" Tong
""")
'''
Auto plays
'''
def testMode(self):
row = "ABCDEFGHIJ"
col = "0123456789"
pastGuesses = set()
while True: # Main loop
self.grid.displayDual() # Display game grid
guess = row[randint(0,9)] + col[randint(0,9)]
while guess in pastGuesses:
guess = row[randint(0,9)] + col[randint(0,9)]
pastGuesses.add(guess)
print guess
self.shootAt(guess, "AI")
if self.game.getNumOfShips('AI') == 0: # If human wins, game's over
print("Game over. You win!") # otherwise, continue loop
break
guess = self.ai.guess() # AI's turn to fire
self.shootAt(guess, "human")
if self.game.getNumOfShips('human') == 0: # If AI wins, game's over
print("Game over. You lose!") # otherwise, continue loop
break
print ""
print "FINAL"
self.grid.displayDual() # Display final grids
'''
Human vs AI play
'''
def gameMode(self):
while True: # Main loop
self.grid.displayDual() # Display game grid
guess = self.human.guess() # Human's turn to fire
self.shootAt(guess, "AI")
if self.game.getNumOfShips('AI') == 0: # If human wins, game's over
print("Game over. You win!") # otherwise, continue loop
break
guess = self.ai.guess() # AI's turn to fire
self.shootAt(guess, "human")
if self.game.getNumOfShips('human') == 0: # If AI wins, game's over
print("Game over. You lose!") # otherwise, continue loop
break
print ""
print "FINAL"
self.grid.displayDual() # Display final grids
class Player:
gameLogic = GameLogic()
def __init__(self, hand, isAI, playerChoice, balance, bet):
self.hand = hand # Hand list that will contain the cards the player has drawn
self.isAI = isAI # Bool that shows if player is Artificial Intelligence or not
self.playerChoice = playerChoice # Bool that shows if it's players turn to hit or stand
self.balance = balance # The initial balance of a player
self.bet = bet # The bet each round
def choseBetAmount(self):
while True: # Loop
choice = input("Please chose your desired bet(10, 20, 30, 40 or 50)")
betList = [10, 20, 30, 40, 50] # List containing possible bet amounts
if int(choice) not in betList: # If the entered bet is not in the bet list, repeat loop
print("Your desired amount didn't match any of the allowed amounts - Try again!")
elif self.balance - int(choice) >= 0: # If their bet doesn't exceed their balance
return int(choice) # Return the bet amount
elif self.balance - int(choice) < 0: # If their entered bet is higher than their current balance
print("You don't have enough balance to place this bet - try again!")
def checkBust(self): # Method that checks if the player exceeds 21, hits 21 or is below 21 in sum
sum = self.gameLogic.checkSum(self) # Call checkSum() method and recieve total sum of hand
if sum > 21: # If the sum is greater than 21
print(f"Player has lost the game with {sum} value!") # Prints lost msg to user with total sum
self.balance = self.balance - self.bet # Update balance and print it
self.printBalance()
return False # Sets playerChoice to false so it breaks out of while-loop
elif sum == 21: # If players total sum is exactly 21
print(f"Player has hit {sum} - Dealers turn")
return False # Player is forced to stand - sets playerChoice to false to break out of while-loop
else: # If players total sum is below 21
return True # Set playerChoice to True so while-loop repeats
def printCardsAndSum(self): # Method that formats and prints players cards and total sum
print("==============================================")
print(" P L A Y E R H A N D ")
for i in self.hand: # For-loop traversing through cards in hand and printing them. Ex. 3 of Spades
print('┌───────┐')
print(f'| {i.value:<2} |')
print('| |')
print(f'| {i.suit} |')
print('| |')
print(f'| {i.value:>2} |')
print('└───────┘')
print()
print(f"Player hand sum: {self.gameLogic.checkSum(self)}")
print("==============================================")
def takeTurn(self, dealer, deck): # Method that prompts user to tell if they want to stand or hit
sum = self.gameLogic.checkSum(self) # Get the total sum of hand
choice = -1 # Make sure we won't get error in if-statement
if not self.isAI: # if player is not AI, give them option to hit or stand
choice = input(f"The sum of your hand is {sum}, would you like to stand or hit?(type 1 for stand and 0 for hit)")
if choice == '1' or self.isAI and sum > 16: # If user's input is 1 - They want to stand - or if AI and sum above 16
print('Player chose to stand - Dealers turn(Dealers 2nd card is revealed)')
return False # Set playersTurn to False to break out of while-loop
elif choice == '0' or self.isAI and sum <= 16: # Else-if the user input is 0 - They want to hit - or user is AI and below 17
self.hand.append(self.gameLogic.dealCard(deck)) # Add new card to users hand
self.printCardsAndSum() # Print users cards and total sum
return self.checkBust() # Check if user is bust after newly added card
# TODO Make 404-else to prevent bad user input
def isBlackjack(self): # Method that checks if players starting hand is blackjack(10 value card + Ace)
ten = ['Q', 'K', 'J', '10'] # Initialize list with all card values that is equal to 10
if self.contains(self.hand, lambda x: x.value == 'A'): # Call the contain method with our lambda expression
# that checks if object.value is equal to 'A' (Ace)
for i in ten: # For-loop traversing through ten list
if self.contains(self.hand, lambda x: x.value == i): # Contain method if value is equal to either 10 value cards
print('Player has hit blackjack! Dealers turn..')
return True # If we have hit blackjack - end players turn and break out of while-loop
# TODO Should player win instantly if blackjack is hit?
def contains(self, list, filter): # Contain method that recieves a list and a lambda expression
for x in list: # For-loop traverse through list
if filter(x): # If given lambda expression is met
return True
return False # If lambda expression is NOT met
# TODO Move this method to Menu / Client class when if created
def chooseIfPlayerOrDealer(self, dealer): # User is prompted if they want to play as player or dealer
choice = input("Would you like to play as a player or a dealer? (type 1 for player and 0 for dealer)")
if choice == '1': # If user types 1 and wants to be the player
dealer.isAI = True # Dealer is Artificial Intelligence
print("You are the player...")
return False # Break out of while-loop
elif choice == '0': # If user types 0 and wants to be dealer
self.isAI = True # Player is Artificial Intelligence
print("You are the dealer... You will now deal the cards.")
dealer.isReveal = True # Dealer can look at his own 2nd card
return False # Break out of while-loop
else: # If 404 bad input - print error msg and continue while-loop
print(f"Your input: {choice} didn't match any of the cases - Please try again!")
def printBalance(self):
print(f"|| Bet placed: {self.bet} || Total balance: {self.balance} ||")
class World():
# Initialisation
def __init__(self):
#self.player = Player()
self.ScreenSetup()
self.menu = Menus(self.screen)
self.text = Text(self.screen)
self.state = ''
self.playing = True
self.clock = pygame.time.Clock()
self.fps = 120
self.obstacleSprites = []
self.obList = []
self.collision = CollisionChecker()
def RunningStatus(self):
if self.state == 'Quit':
return False
else:
return True
# Sets up the screen
def ScreenSetup(self):
width = 1000
height = 800
self.screen = pygame.display.set_mode(
(width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
pygame.display.set_caption('Dodge The Monsters 3')
# Draws all the game objects
def GameStatus(self):
self.DetermineGameState()
if self.state == 'MainMenu':
self.menu.MainMenu(self.screen)
elif self.state == 'TuteMenu':
self.menu.TutorialMenu(self.screen)
elif self.state == 'SelectAI':
self.menu.SelectAI(self.screen)
elif self.state == 'FSM':
self.player = Player('AI')
self.fsm = FiniteStateMachine(self)
self.fsm.RunGameFSM()
self.menu.SetState('MainMenu')
elif self.state == 'PlayGameHuman':
self.player = Player('HUMAN')
self.level = Level(self.screen, self.player)
self.RunGameHuman()
def DetermineGameState(self):
self.state = self.menu.GetState()
def LoadObstacles(self):
self.obList = [
Obstacle(130, -100, 1),
Obstacle(350, -100, 2),
Obstacle(645, -100, 3),
Obstacle(800, -100, 4)
]
# Handles the left and right movement of the player
def HandlePlayerMovement(self):
if self.player.type == 'HUMAN':
if pygame.key.get_pressed()[pygame.K_LEFT]:
self.player.MoveLeft()
if pygame.key.get_pressed()[pygame.K_RIGHT]:
self.player.MoveRight()
if not pygame.key.get_pressed(
)[pygame.K_LEFT] and not pygame.key.get_pressed()[pygame.K_RIGHT]:
self.player.ReturnStraight()
def GetSprites(self):
self.allObstacles = pygame.sprite.Group()
for o in self.obList:
self.allObstacles.add(o.oSprite)
def AddObstacle(self):
if self.level.level == 2 and len(self.obList) == 4:
self.obList.append(
Obstacle(random.randint(130, 850), (random.randint(50, 300)),
5))
elif self.level.level == 3 and len(self.obList) == 5:
self.obList.append(
Obstacle(random.randint(130, 850), (random.randint(50, 300)),
6))
elif self.level.level == 4 and len(self.obList) == 6:
self.obList.append(
Obstacle(random.randint(130, 850), (random.randint(50, 300)),
7))
def RunGameHuman(self):
self.LoadObstacles()
self.game = GameLogic(self, self.screen, self.level, self.text)
self.GetSprites()
self.player.DrawPlayer(self.screen)
for o in self.obList:
o.DrawObstacle(self.screen)
self.menu.StartGame(self.screen)
while self.playing and not self.collision.CheckCollision(
self.obList, self.player):
# Get the player movement
self.HandlePlayerMovement()
# Add other Obstacles
self.AddObstacle()
# Run the game logic
self.game.TheGame(self.obList)
# Refresh Rate
self.clock.tick(120)
pygame.time.delay(1000)
self.menu.EndGameScreen(self.screen, self.player)
pygame.time.delay(5000)
self.menu.SetState('MainMenu')
def setConfig(self, policyConfig):
self.gameLogic = GameLogic(policyConfig)
from GameLogic import GameLogic
import sys
if __name__ == "__main__":
if len(sys.argv) < 6:
print("Invalid Parameters")
sys.exit(-1)
col = int(sys.argv[1])
row = int(sys.argv[2])
k = int(sys.argv[3])
g = int(sys.argv[4])
mode = sys.argv[5]
debug = False
if len(sys.argv) == 7 and sys.argv[6] == "-d":
debug = True
main = GameLogic(col,row,k,g,mode,debug)
main.Run()
def __init__(self, policy):
self.policy = policy
self.width = None
self.height = None
self.values = np.zeros(0)
self.gameLogic = GameLogic(getDefaultPolicyConfig())
from Player import Player
from Dealer import Dealer
from Deck import Deck
from GameLogic import GameLogic
import os
player = Player([], False, True, 200,
0) # Instantiate our player, dealer and deck
dealer = Dealer([], False, False, False, False)
gameLogic = GameLogic()
endGame = False
print("WELCOME TO THE BLACKJACK GAME") # Welcome MSG TODO - Move to Menu class
while player.playerChoice: # Loop while player needs to make a choice
player.playerChoice = player.chooseIfPlayerOrDealer(
dealer) # Method that let's user make choice to be a player or dealer
while not endGame:
deck = Deck([])
for i in range(4):
deck.createDeck() # Create 4 decks in loop (208 cards)
deck.shuffleDeck() # Shuffle the deck randomly
player = Player(
[], player.isAI, True, player.balance,
0) # Instantiate our player and dealer with their correct fields
dealer = Dealer(
[], dealer.isAI, False, False, False
) # dealer ai, player ai and balance remains the same as previous round
if not player.isAI: # if player is not ai, he has to choose bet amount
class GameLoop:
def __init__(self):
self.controller = Controller()
self.Handler = EventHandler(self.controller)
self.object_list = []
self.game_logic = GameLogic()
self.fps_clock = pygame.time.Clock()
self.fps = 60
self.neuralnet = NeuralNetHolder()
self.version = "v1.01"
def init(self, config_data):
# used to initialise the pygame library
pygame.init()
if config_data["FULLSCREEN"] == "TRUE":
user32 = ctypes.windll.user32
config_data['SCREEN_HEIGHT'] = int(user32.GetSystemMetrics(1))
config_data['SCREEN_WIDTH'] = int(user32.GetSystemMetrics(0))
self.screen = pygame.display.set_mode(
(config_data['SCREEN_WIDTH'], config_data['SCREEN_HEIGHT']),
pygame.FULLSCREEN)
else:
config_data['SCREEN_HEIGHT'] = int(config_data['SCREEN_HEIGHT'])
config_data['SCREEN_WIDTH'] = int(config_data['SCREEN_WIDTH'])
self.screen = pygame.display.set_mode(
(config_data['SCREEN_WIDTH'], config_data['SCREEN_HEIGHT']))
pygame.display.set_caption('CE889 Assignment Template')
pygame.display.set_icon(
pygame.image.load(config_data['LANDER_IMG_PATH']))
def score_calculation(self):
score = 1000.0 - (self.surface.centre_landing_pad[0] -
self.lander.position.x)
angle = self.lander.current_angle
if (self.lander.current_angle == 0):
angle = 1
if (self.lander.current_angle > 180):
angle = abs(self.lander.current_angle - 360)
score = score / angle
velocity = 500 - (self.lander.velocity.x + self.lander.velocity.y)
score = score + velocity
print("lander difference " +
str(self.surface.centre_landing_pad[0] - self.lander.position.x))
print("SCORE " + str(score))
return score
def main_loop(self, config_data):
pygame.font.init() # you have to call this at the start,
# if you want to use this module you need to call pygame.font.init()
myfont = pygame.font.SysFont('Comic Sans MS', 30)
# create the group for visuals to be updated
sprites = pygame.sprite.Group()
# booleans for what the game state is
on_menus = [True, False, False] # Main, Won, Lost
game_start = False
# Game modes: Play Game, Data Collection, Neural Net, Quit
game_modes = [False, False, False, False]
# The main loop of the window
background_image = pygame.image.load(
config_data['BACKGROUND_IMG_PATH']).convert_alpha()
background_image = pygame.transform.scale(
background_image,
(config_data['SCREEN_WIDTH'], config_data['SCREEN_HEIGHT']))
data_collector = DataCollection(config_data["ALL_DATA"])
main_menu = MainMenu(
(config_data['SCREEN_WIDTH'], config_data['SCREEN_HEIGHT']))
result_menu = ResultMenu(
(config_data['SCREEN_WIDTH'], config_data['SCREEN_HEIGHT']))
score = 0
# Initialize
while True:
# menus
# check if Quit button was clicked
if (game_modes[len(game_modes) - 1]):
pygame.quit()
sys.exit()
# if game is started, initialize all objects
if game_start:
self.controller = Controller()
self.Handler = EventHandler(self.controller)
sprites = pygame.sprite.Group()
self.game_start(config_data, sprites)
if on_menus[0] or on_menus[1] or on_menus[2]:
if on_menus[1] or on_menus[2]:
result_menu.draw_result_objects(self.screen, on_menus[1],
score)
else:
main_menu.draw_buttons(self.screen)
# draw the version number
textsurface = myfont.render(self.version, False, (0, 0, 0))
self.screen.blit(textsurface, (0, 0))
# main_menu.draw_buttons(self.screen)
for event in pygame.event.get():
if on_menus[0]:
main_menu.check_hover(event)
button_clicked = main_menu.check_button_click(event)
main_menu.draw_buttons(self.screen)
if button_clicked > -1:
game_modes[button_clicked] = True
on_menus[0] = False
game_start = True
elif on_menus[1] or on_menus[2]:
result_menu.check_hover(event)
on_menus[0] = result_menu.check_back_main_menu(event)
result_menu.draw_result_objects(
self.screen, on_menus[1], score)
if on_menus[0]:
on_menus[1] = False
on_menus[2] = False
else:
# game
self.Handler.handle(pygame.event.get())
# check if data collection mode is activated
if (game_modes[2]):
input_row = data_collector.get_input_row(
self.lander, self.surface, self.controller)
nn_prediction = self.neuralnet.predict(input_row)
# print(nn_prediction)
# self.controller.set_mouse(False)
self.controller.set_up(False)
self.controller.set_left(False)
self.controller.set_right(False)
# self.controller.set_up(nn_prediction[0] == 1)
# self.lander.velocity.y = nn_prediction[0]
# self.lander.velocity.x = nn_prediction[1]
if (self.lander.velocity.y > nn_prediction[0]):
self.controller.set_up(True)
# self.lander.velocity.y = nn_prediction[0]
if (self.lander.velocity.x < nn_prediction[1]):
self.controller.set_right(True)
else:
self.controller.set_left(True)
if (self.lander.current_angle > 30
and self.lander.current_angle < 330):
ang_val = (self.lander.current_angle - 30) / (330 - 30)
ang_val = round(ang_val)
if (ang_val == 0):
self.lander.current_angle = 30
else:
self.lander.current_angle = 330
# print("lander vel: ", self.lander.velocity.y, " -- ", self.lander.velocity.x)
# if (nn_prediction[1] == 1):
# self.controller.set_right(True)
# elif (nn_prediction[1] == -1):
# self.controller.set_left(True)
# self.lander.velocity.y = nn_prediction[0]
# self.lander.velocity.x = nn_prediction[1]
# self.lander.current_angle = int(nn_prediction[1])
# if (nn_prediction[0] == 1):
# self.controller.set_up(True)
# if (nn_prediction[1] == 1):
# self.controller.set_left(True)
# elif (nn_prediction[2] == 1):
# self.controller.set_right(True)
# if (game_modes[1]):
# data_collector.save_current_status(self.lander, self.surface, self.controller)
self.screen.blit(background_image, (0, 0))
if (not self.Handler.first_key_press and game_start == True):
self.update_objects()
game_start = False
if (self.Handler.first_key_press):
data_input_row = data_collector.get_input_row(
self.lander, self.surface, self.controller)
self.update_objects()
if (game_modes[1]):
data_collector.save_current_status(
data_input_row, self.lander, self.surface,
self.controller)
# then update the visuals on screen from the list
sprites.draw(self.screen)
# the win state and the score calculation
if (self.lander.landing_pad_collision(self.surface)):
score = self.score_calculation()
on_menus[1] = True
if (game_modes[1]):
data_collector.write_to_file()
data_collector.reset()
# check if lander collided with surface
elif (self.lander.surface_collision(self.surface)
or self.lander.window_collision(
(config_data['SCREEN_WIDTH'],
config_data['SCREEN_HEIGHT']))):
on_menus[2] = True
data_collector.reset()
if (on_menus[1] or on_menus[2]):
game_start = False
for i in range(len(game_modes)):
game_modes[i] = False
# surface_sprites.draw(self.screen)
pygame.display.flip()
self.fps_clock.tick(self.fps)
def update_objects(self):
# update the speeds and positions of the objects in game
self.game_logic.update(0.2)
def setup_lander(self, config_data):
lander = Lander(config_data['LANDER_IMG_PATH'], [
config_data['SCREEN_WIDTH'] / 2, config_data['SCREEN_HEIGHT'] / 2
], Vector(0, 0), self.controller)
self.game_logic.add_lander(lander)
return lander
def game_start(self, config_data, sprites):
# Creates the lander object
self.lander = self.setup_lander(config_data)
self.surface = Surface(
(config_data['SCREEN_WIDTH'], config_data['SCREEN_HEIGHT']))
sprites.add(self.lander)
sprites.add(self.surface)
class Dealer:
gameLogic = GameLogic()
def __init__(self, hand, isAI, isReveal, dealerTurn, roundOver):
self.hand = hand # List that stores cards in the dealers hand
self.isAI = isAI # Bool that decides if dealer is Artificial Intelligence
self.isReveal = isReveal # Bool that decides if dealer's 2nd card is revealed
self.dealerTurn = dealerTurn # Bool that decides if it's dealer's turn to hit or stand
self.roundOver = roundOver # Bool that decides if a round is over
def takeTurn(self, player,
deck): # Method for when dealer needs to take his turn
self.isReveal = True # Dealers 2nd card is revealed
self.printCardsAndSum() # Print hand and sum
self.checkWin(player) # Check if the game is done
self.dealerTurn = True # Set dealerTurn to true so we enter while loop
while self.dealerTurn and not self.roundOver: # Loops while it's dealers turn to take an action
sum = self.gameLogic.checkSum(self)
if sum <= 16: # If sum is 16 or lower, dealer needs to hit
print(
'Dealers sum is equal to or lower than 16 - dealer hits!')
self.hand.append(self.gameLogic.dealCard(
deck)) # Card is added to dealers hand
self.printCardsAndSum() # New hand and sum is printed
self.checkWin(player) # Check if anyone has won
def printCardsAndSum(
self): # Method that prints out the dealers hand and total sum
print("==============================================")
if not self.isReveal: # If user is dealer, show both cards - else, keep 2nd card hidden
print(" D E A L E R H A N D ")
print('┌───────┐')
print(f'| {self.hand[0].value:<2} |')
print('| |')
print(f'| {self.hand[0].suit} |')
print('| |')
print(f'| {self.hand[0].value:>2} |')
print('└───────┘')
print('┌───────┐')
print('|///////|')
print('|=======|')
print('| ͡◉ ͜ʖ ͡◉)|')
print('|=======|')
print('|///////|')
print('└───────┘')
else:
print(" D E A L E R H A N D ")
for i in self.hand:
print('┌───────┐')
print(f'| {i.value:<2} |')
print('| |')
print(f'| {i.suit} |')
print('| |')
print(f'| {i.value:>2} |')
print('└───────┘')
print(f"Dealer hand sum: {self.gameLogic.checkSum(self)}")
print("==============================================")
def checkWin(self, player): # Method that checks if the game has ended
playerSum = self.gameLogic.checkSum(player)
sum = self.gameLogic.checkSum(self)
if sum > 21: # If dealers sum is larger than 21, dealer is bust
print('Dealer exceeded 21 and has LOST the game!')
player.balance += player.bet
player.printBalance()
self.dealerTurn = False # Break out of while-loop
self.roundOver = True
# TODO Player instant win if hit blackjack?
elif sum > playerSum and sum > 16: # TODO Draw over 16 even tho player is below 16? check rules
print(
f'Dealer hit {sum} and WINS over the player with {playerSum}')
player.balance = player.balance - player.bet
player.printBalance()
self.dealerTurn = False # Break out of loop
self.roundOver = True
elif sum == playerSum and sum > 16: # If both players are above 16 and they have equal values - game tied
print(f"Game is tied! Both players hit {sum}")
player.printBalance()
self.roundOver = True
elif sum < playerSum and sum > 16: # If dealers sum is above 16 but less than players - player won
print(
f'Dealer hit {sum} and is still lower than players sum: {playerSum}'
)
print('Player has won')
player.balance += player.bet
player.printBalance()
self.dealerTurn = False # Break out of while-loop
self.roundOver = True
else: # In any other case: It's still dealers turn to hit
self.dealerTurn = True # Set to true to keep looping TODO else needed?
from GameLogic import GameLogic l = GameLogic() l.newBots() l.addPoison(100) l.addFood(200) l.run(10)
if __name__ == '__main__':
width = 13
height = 13
map_ = Map(width, height)
snake = Snake([(width // 2, height // 2)] * 3)
fruit = Fruit(0, 0)
fruit.randomPosition((0, width), (0, height), snake.getBody())
gameLogic = GameLogic(snake, fruit, map_)
renderer = cv2Renderer(width, height, 10)
while not snake.isDead:
setRenderer(snake, fruit, renderer)
k = renderer.render()
if k == ord('w'):
k = 3
elif k == ord('a'):
k = 2
def run():
""" The main method for running our game """
# Keep track of when the game was started...
# this is so that if you win, we can display how long it took you
start_time = datetime.now()
# Display highscores - maybe?
get_highscores()
# Class instantiation
obj = GameLogic()
# Initialize variables
WinLoseCheck = 'continue to play'
global west_bank
global east_bank
global canoe
# Display the story so use knows what to do
display_story()
# Ask for player name so we know who to humiliate when they lose... just kidding.
# This will be used to keep track of high scores
player_name = input("Who is the brave soul playing this game?: ")
player_name = str(player_name)
#Begin game
while WinLoseCheck == 'continue to play':
# Display the locations
obj.display_locations(east_bank, west_bank, canoe)
# Ask for user prompt of who to send
val_ask = obj.user_prompt(east_bank, west_bank, canoe)
if val_ask[0] == "q" or val_ask[1] == "q":
print("Thank you for playing!")
sys.exit(1)
else:
# Update location dictionaries and reset values
result = obj.update_locations(val_ask, east_bank, west_bank, canoe)
east_bank = result[0]
west_bank = result[1]
canoe = result[2]
# Check for a win/loss
WinLoseCheck = obj.check_for_win(east_bank, west_bank)
# If there is a win, get the ending time so we can compare start_time to see how long it took
# We also display the winning screen, otherwise show the losing screen
if WinLoseCheck == "Winner":
end_time = datetime.now()
date_diff = end_time - start_time
print("You completed the game in: ", date_diff, '\n')
# Update the highscore bank
update_highscores(player_name, date_diff)
display_win()
get_highscores()
elif WinLoseCheck == "Loser":
display_lost()
else:
pass
from GameLogic import GameLogic
from CameraView import CameraView
# Intialize the pygame
pygame.init()
# create the screen
screen = pygame.display.set_mode((800, 600))
# Sound
mixer.music.load("music/background.wav")
mixer.music.play(-1)
# Caption and Icon
pygame.display.set_caption("Recycle Game")
pygame.display.set_icon(pygame.image.load('images/recycle_bin.png'))
logic = GameLogic()
view = CameraView()
clock = pygame.time.Clock()
#create pollution score
# Game Loop
while logic.state != "exit":
pygame.display.set_caption('Pollution = ' + str(logic.pollution))
#get elapsed time
dt = clock.tick(60)
#process user input
view.processInput(screen, logic, dt)
#tick natural game logic
logic.update(dt)
#draw window
from GameLogic import GameLogic
Condition = "y"
while Condition == "y":
print("Lets play hangman...")
GameLogic()
Condition = input(
"Press 'y' to continue and play again or press any key to stop.")
# e.g. "python3 main.py 7 7 2 l {AI_path 1} {AI_path 2}"
# e.g. "python3 main.py 7 7 2 n {AI_path}"
# Because the initialization of network mode is different from the normal modes,
# the initialization of network mode is separated from other modes.
if len(sys.argv) == 3:
mode = sys.argv[1]
if mode == 'n' or mode == 'network':
ai_path = sys.argv[2]
response,host_flag, rule = network_init()
rule = list(map(lambda x:int(x),rule))
col, row, k, order = rule
main = GameLogic(col, row, k, 'n', debug=True)
try:
main.Run(mode=host_flag, ai_path=ai_path, info=response, time=1200)
except:
import traceback
traceback.print_exc()
import threading
for timer in threading.enumerate():
if type(timer) == threading.Timer:
timer.cancel()
exit(0)
else:
print("Invalid Parameters")
sys.exit(-1)
if len(sys.argv) < 5:
class Policy:
def __init__(self, policy):
self.policy = policy
self.width = None
self.height = None
self.values = np.zeros(0)
self.gameLogic = GameLogic(getDefaultPolicyConfig())
def getPolicy(self):
return self.policy
def setConfig(self, policyConfig):
self.gameLogic = GameLogic(policyConfig)
def __eq__(self, other):
if not isinstance(other, Policy):
return False
if self.width != other.width:
return False
if self.height != other.height:
return False
#for (p1, p2) in zip(self.policy, other.policy):
#if p1 != p2:
#print (p1, p2)
return self.policy == other.policy
def getValues(self):
return self.values
def setPolicy(self, policy):
self.policy = policy
def setValues(self, values):
self.values = values
def resetValues(self):
self.values = np.zeros(0)
def setWidth(self, width):
self.width = width
def setHeight(self, height):
self.height = height
def policyActionForCell(self, cell):
return self.policy[cell.getIndex()].getType()
def pi(self, cell, action):
# probability that policy performs action 'a' in state 's'
if len(self.policy) == 0:
# no policy: try all actions
return 1
if self.policyActionForCell(cell) == action:
# policy allows this action
return 1
else:
# policy forbids this action
return 0
def P(self, oldState, newState, actionType, gridWorld):
# probability to transition from oldState to newState given action
return self.gameLogic.getTransitionProbability(oldState, newState, actionType, gridWorld)
def R(self, oldState, newState, action):
return self.gameLogic.R(oldState, newState, action)
def evaluatePolicy(self, gridWorld, gamma = 1):
# determine the value function V using policy iteration
# map: gridworld map
# gamma: discount rate
t = time.time()
if len(self.policy) != len(gridWorld.getCells()):
# sanity check whether policy matches dimension of gridWorld
raise Exception("Policy dimension doesn't fit gridworld dimension.")
maxIterations = 500
V_old = None
V_new = initValues(gridWorld)
iter = 0
convergedCellIndices = np.zeros(0) # cells where values don't change anymore
while len(convergedCellIndices) != len(V_new):
V_old = V_new
iter += 1
V_new = self.evaluatePolicySweep(gridWorld, V_old, gamma, convergedCellIndices)
convergedCellIndices = self.findConvergedCells(V_old, V_new)
if iter > maxIterations:
print("Terminated policy evaluation after " + str(maxIterations) + " iterations")
break
t = time.time() - t
print("Policy evaluation converged after iteration: " + str(iter) + ", time: " + str(t))
#print(V_new)
return V_new
def findConvergedCells(self, V_old, V_new, theta = 0.01):
# returns list of cells where values haven't changed
# optimization for policy evaluation such that known values aren't recomputed again
# silence warnings from '-inf' values
with warnings.catch_warnings():
warnings.filterwarnings('ignore', r'invalid value encountered')
diff = abs(V_old-V_new)
idx = np.where(diff < theta)[0]
sameIdx = np.where(V_new == -np.inf)[0]
return np.concatenate((idx, sameIdx))
def evaluatePolicySweep(self, gridWorld, V_old, gamma, ignoreCellIndices):
V = initValues(gridWorld)
# evaluate policy for every state (i.e. for every viable actor position)
for (i,cell) in enumerate(gridWorld.getCells()):
if np.any(ignoreCellIndices == i):
V[i] = V_old[i]
else:
if cell.canBeEntered():
gridWorld.setActor(cell)
V_s = self.evaluatePolicyForState(gridWorld, V_old, gamma)
gridWorld.unsetActor(cell)
V[i] = V_s
self.setValues(V)
return V
def evaluatePolicyForState(self, gridWorld, V_old, gamma):
V = 0
cell = gridWorld.getActorCell()
stateGen = StateGenerator()
transitionRewards = [-np.inf] * len(Actions)
# perform full backup operation for this state
for (i, actionType) in enumerate(Actions):
gridWorld.setActor(cell) # set state
actionProb = self.pi(cell, actionType)
if actionProb == 0 or actionType == Actions.NONE:
continue
newStates = stateGen.generateState(gridWorld, actionType, cell)
transitionReward = 0
for newActorCell in newStates:
V_newState = V_old[newActorCell.getIndex()]
# Bellman equation
newStateReward = self.P(cell, newActorCell, actionType, gridWorld) *\
(self.R(cell, newActorCell, actionType) +\
gamma * V_newState)
transitionReward += newStateReward
transitionRewards[i] = transitionReward
V_a = actionProb * transitionReward
V += V_a
if len(self.policy) == 0:
V = max(transitionRewards)
return V
def getValue(self, i):
return self.values[i]
def resetPolicy(self):
self.policy = []
def valueIteration(self, gridWorld, gamma = 1, storeValueFunction = False):
# determine the value function V by combining
# evaluation and policy improvement steps
# reset policy to ensure that value iteration algorithm is used
# instead of improving existing policy
self.resetPolicy()
t = time.time()
V_old = None
V_new = np.repeat(0, gridWorld.size())
iter = 0
convergedCellIndices = np.zeros(0) # cells where values don't change anymore
while len(convergedCellIndices) != len(V_new):
V_old = V_new
iter += 1
V_new = self.evaluatePolicySweep(gridWorld, V_old, gamma, convergedCellIndices)
self.setValues(V_new)
if storeValueFunction:
label = str(iter)
if iter < 10:
label = "0" + str(iter)
storeValueFunctionInIter(gridWorld, self, label, "value_iteration")
convergedCellIndices = self.findConvergedCells(V_old, V_new)
t = time.time() - t
print("Value iteration terminated after: " + str(iter) + " iterations, time: " + str(t))
# store policy found through value iteration
greedyPolicy = findGreedyPolicy(V_new, gridWorld, self.gameLogic)
self.setPolicy(greedyPolicy)
self.setWidth(gridWorld.getWidth())
self.setHeight(gridWorld.getHeight())
return(V_new)
def __str__(self):
out = ""
for (i,a) in enumerate(self.policy):
if (i % self.width) == 0:
out += "\n"
if len(self.values) == 0:
out += str(a)
else:
val = str(round(self.values[i], 1))
while len(val) < 4:
val += " "
out += val
return(out)
class GUI:
player_board = 0
enemy_board = 0
#always add +1 and get the direction rotation by modulo %4
total_positions = 0
def __init__(self, player_board, enemy_board):
self.player_board = player_board
self.enemy_board = enemy_board
self.root = Tk()
def initialize(self):
self.player_frame = Frame(self.root)
self.player_frame.pack(side=LEFT)
self.enemy_frame = Frame(self.root)
self.enemy_frame.pack(side=LEFT)
self.menu_frame = Frame(self.root)
self.menu_frame.pack(side=LEFT)
# initialize GUI for player board
divider = Label(self.player_frame,
text=' \n \n \n \n \n \n \n \n \n \n')
divider.pack(side=TOP)
self.enemy_buttons_2d_array = [[
0 for x in range(self.player_board.get_board_size() + 1)
] for y in range(self.player_board.get_board_size() + 1)]
# initialize GUI for enemy board
for i in range(0, self.enemy_board.get_board_size()):
for j in range(0, self.enemy_board.get_board_size()):
b = Button(
self.enemy_frame,
text=' ',
command=lambda x=j, y=i: self.button_click_at_pos(x, y),
background="yellow")
b.grid(row=i, column=j)
self.enemy_buttons_2d_array[j][i] = b
self.player_info_label = Label(self.menu_frame,
text='You still have ships: ')
self.player_info_label.pack(side=TOP)
self.enemy_info_label = Label(self.menu_frame,
text='Enemy still have ships: ')
self.enemy_info_label.pack(side=TOP)
greenbutton = Button(self.menu_frame,
text="Restart game",
command=lambda: self.restart_game(),
fg="brown")
greenbutton.pack(side=LEFT)
self.game_logic = GameLogic(self.player_board, self.enemy_board)
def player_setup(self):
self.setup_frame = Frame(self.root)
self.setup_frame.pack(side=LEFT)
self.setup_frame.grid_rowconfigure(1, weight=1)
self.setup_frame.grid_columnconfigure(1, weight=1)
self.setup_help_frame = Frame(self.root)
self.setup_help_frame.pack(side=LEFT)
title_label = Label(self.setup_help_frame,
text="Welcome to Battleship!")
title_label.pack(side=TOP)
help_label = Label(
self.setup_help_frame,
text=
"Click to position ship!\nClick again to delete ship and rotate!")
help_label.pack(side=TOP)
start_button = Button(self.setup_help_frame,
text="Start!",
command=lambda: self.start_button())
start_button.pack(side=BOTTOM)
random_button = Button(self.setup_help_frame,
text="Place random!",
command=lambda: self.random_button())
random_button.pack(side=BOTTOM)
self.player_setup_buttons_2d_array = [[
0 for x in range(self.player_board.get_board_size() + 1)
] for y in range(self.player_board.get_board_size() + 1)]
# initialize GUI for player board
for i in range(0, self.player_board.get_board_size()):
for j in range(0, self.player_board.get_board_size()):
b = Button(self.setup_frame,
text=' ',
command=lambda x=j, y=i: self.
player_setup_button_click_at_pos(x, y))
b.grid(row=i, column=j)
self.player_setup_buttons_2d_array[j][i] = b
self.root.mainloop()
def start_button(self):
if len(self.player_board.get_remaining_ships()) > 0:
msg = str("You still have to place ship with size: " +
str(self.player_board.get_remaining_ships()))
self.popup_message(msg)
else:
self.player_board.clear_bounds()
self.initialize()
self.setup_help_frame.pack_forget()
self.setup_help_frame.destroy()
self.set_setup_buttons_disabled()
def random_button(self):
del self.player_board
self.player_board = 0
self.player_board = Board()
self.player_board.set_blank_board()
self.player_board.initialize()
self.refresh_player_setup_frame()
def set_setup_buttons_disabled(self):
for i in range(0, self.player_board.get_board_size()):
for j in range(0, self.player_board.get_board_size()):
self.player_setup_buttons_2d_array[j][i]["state"] = DISABLED
def popup_message(self, msg):
popup = Tk()
popup.wm_title("Place all the ships!")
label = Label(
popup,
text=msg,
)
label.pack(side="top")
b1 = Button(popup, text="Okay", command=popup.destroy)
b1.pack()
popup.mainloop()
def player_setup_button_click_at_pos(self, x, y):
if self.player_board.get_board_info_at_pos(
x, y) != 0 and self.player_board.get_board_info_at_pos(x,
y) != 7:
self.player_board.delete_ship(x, y)
self.refresh_player_setup_frame()
else:
self.player_board.place_ship_at_pos(x, y, self.total_positions % 2)
self.total_positions += 1
self.refresh_player_setup_frame()
self.player_board.print_board()
def refresh_player_setup_frame(self):
# initialize GUI for player board
self.player_board.print_board()
for i in range(0, self.player_board.get_board_size()):
for j in range(0, self.player_board.get_board_size()):
self.player_setup_buttons_2d_array[j][i]["state"] = ACTIVE
if self.player_board.get_board_info_at_pos(j, i) == 0:
self.player_setup_buttons_2d_array[j][i]["text"] = " "
elif self.player_board.get_board_info_at_pos(j, i) == 7:
self.player_setup_buttons_2d_array[j][i][
"state"] = DISABLED
else:
self.player_setup_buttons_2d_array[j][i]["text"] = "x"
def button_click_at_pos(self, x, y):
# player move
self.game_logic.make_move(x, y)
print("ENEMY BOARD =----")
self.enemy_board.print_board()
# AI Move
self.game_logic.make_move(-1, -1)
self.refresh_boards()
self.refresh_info()
def refresh_info(self):
# refresh remaining ships info
player_ships_sizes = []
enemy_ships_sizes = []
for i, obj in enumerate(self.player_board.get_remaining_alive_ships()):
player_ships_sizes.append(obj.get_size())
for i, obj in enumerate(self.enemy_board.get_remaining_alive_ships()):
enemy_ships_sizes.append(obj.get_size())
self.player_info_label["text"] = "You: " + str(player_ships_sizes)
self.enemy_info_label["text"] = "Enemy: " + str(enemy_ships_sizes)
def refresh_boards(self):
# refresh player board
for i in range(0, self.player_board.get_board_size()):
for j in range(0, self.player_board.get_board_size()):
if self.player_board.get_board_info_at_pos(j, i) == 9:
self.player_setup_buttons_2d_array[j][i]["text"] = 'hit'
if self.player_board.get_board_info_at_pos(j, i) == 8:
self.player_setup_buttons_2d_array[j][i][
"state"] = DISABLED
self.player_setup_buttons_2d_array[j][i]["text"] = 'o'
# refresh enemy board
for i in range(0, self.enemy_board.get_board_size()):
for j in range(0, self.enemy_board.get_board_size()):
if self.enemy_board.get_board_info_at_pos(j, i) == 9:
self.enemy_buttons_2d_array[j][i]["state"] = DISABLED
self.enemy_buttons_2d_array[j][i]["text"] = 'x'
if self.enemy_board.get_board_info_at_pos(j, i) == 8:
self.enemy_buttons_2d_array[j][i]["state"] = DISABLED
self.enemy_buttons_2d_array[j][i]["text"] = 'o'
def restart_game(self):
self.setup_frame.destroy()
self.enemy_frame.destroy()
self.menu_frame.destroy()
del self.player_board
self.player_board = 0
self.player_board = Board()
self.player_board.set_blank_board()
del self.enemy_buttons_2d_array
del self.player_setup_buttons_2d_array
del self.enemy_board
self.enemy_board = 0
self.enemy_board = Board()
self.enemy_board.initialize()
self.player_setup()
def play_game(self, data, conn):
data = data.split('@')
current_game_id = data[1]
current_move = data[2:]
print("current_move inside server ", current_move)
connection1 = conn
global current_games
for con in current_games[current_game_id].get_connections():
if con != connection1:
connection2 = con
current_game_name = current_games[current_game_id].get_game()
current_game_board = current_games[current_game_id].get_board()
current_game_logic = GameLogic()
if current_game_name == "Othello":
current_game_logic = OthelloLogic()
elif current_game_name == "Connect4":
current_game_logic = Connect4Logic()
elif current_game_name == "Battleship":
current_game_logic = BattleshipLogic()
try:
if current_game_name == "Battleship":
current_game_logic.make_move(current_game_board, current_move)
self.send_data_to_connection(connection1, "VALID_MOVE")
tracking_move = ""
for row in range(current_game_board.get_num_rows()):
for col in range(current_game_board.get_num_columns()):
tracking_move += "@" + current_game_board.get_tracking_state()[row][col]
tracking_move += "@"
current_game_logic.switch_Turn(current_game_board)
move = ""
for row in range(current_game_board.get_num_rows()):
for col in range(current_game_board.get_num_columns()):
move += "@" + current_game_board.get_game_state()[row][col]
move += "@"
print("Move from server ", move)
self.send_data_to_connection(connection1, "BS_TRACKING" + tracking_move)
self.send_data_to_connection(connection2, "BS_PRIMARY" + move)
self.send_data_to_connection(connection1, "SWITCH_PLAYER")
self.send_data_to_connection(connection2, "SWITCH_PLAYER")
else:
current_game_logic.make_move(current_game_board, current_move)
self.send_data_to_connection(connection1, "VALID_MOVE")
move = ""
for row in range(current_game_board.get_num_rows()):
for col in range(current_game_board.get_num_columns()):
move += "@" + current_game_board.get_game_state()[row][col]
move += "@"
print("Move from server ", move)
self.send_data_to_connection(connection1, "UPDATE" + move)
self.send_data_to_connection(connection2, "UPDATE" + move)
current_game_logic.switch_Turn(current_game_board)
self.send_data_to_connection(connection1, "SWITCH_PLAYER")
self.send_data_to_connection(connection2, "SWITCH_PLAYER")
if current_game_logic.game_is_over(current_game_board):
self.send_data_to_connection(connection1, "GAME_OVER")
self.send_data_to_connection(connection2, "GAME_OVER")
else:
if len(current_game_logic.all_valid_moves(current_game_board)) != 0:
self.send_data_to_connection(connection1, "WAIT")
self.send_data_to_connection(connection2, "READY")
else:
self.send_data_to_connection(connection2, "NO_MOVE_FOR_YOU")
current_game_logic.switch_Turn(current_game_board)
self.send_data_to_connection(connection1, "SWITCH_PLAYER")
self.send_data_to_connection(connection2, "SWITCH_PLAYER")
self.send_data_to_connection(connection1, "READY")
self.send_data_to_connection(connection2, "WAIT")
except Exception as e:
print("INVALID_MOVE Exception happened inside server.")
print(str(e))
self.send_data_to_connection(conn, "INVALID_MOVE")
