lordloh

XO.py

Sep 10th, 2015
258
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #! /usr/bin/python3
  2. from enum import Enum
  3. import math
  4.  
  5. class res(Enum):
  6.     OK = 0
  7.     WIN = 1
  8.     DRAW = 2
  9.     OUT_OF_TURN = -1
  10.     INVALID_MOVE = -2
  11.  
  12. def transpose(board):
  13.     transBoard=[[0,0,0],[0,0,0],[0,0,0]]
  14.     c=0;
  15.     for b in board:
  16.         r=2
  17.         for e in b:
  18.             transBoard[r][c]=e;
  19.             r -= 1
  20.         c += 1
  21.     return transBoard
  22.  
  23. class xo:
  24.     def __init__(self):
  25.         self.board = [ [0, 0, 0 ] , [ 0, 0, 0 ] , [ 0, 0, 0 ] ]
  26.         self.sym = [ ' ', '0', 'X' ]
  27.         self.turn = 0
  28.         self.X_TURN_MODULUS = -1
  29.         self.O_TURN_MODULUS = -1
  30.         self.PLAYER_X = 2
  31.         self.PLAYER_O = 1
  32.         self.won = False
  33.         self.game_over = False
  34.         #self.res=enum(OK = 0, WIN = 1, DRAW = 2, OUT_OF_TURN = -1, INVALID_MOVE = -2)
  35.         self.res=res;
  36.         self.empty_positions = 9
  37.        
  38.     def set_pos(self,pos_x,pos_y,player):
  39.         if (player >= 0 & player < 3):
  40.             self.board[pos_x][pos_y]=player
  41.         return 0
  42.        
  43.     def set_absolute(self,pos,player):
  44.         if (self.turn == 0):
  45.             if (player == 1):
  46.                 self.X_TURN_MODULUS = 1
  47.                 self.O_TURN_MODULUS = 0
  48.             elif (player == 2):
  49.                 self.X_TURN_MODULUS = 0
  50.                 self.O_TURN_MODULUS = 1
  51.         if ( self.game_over == True ):
  52.             returnVal=res.INVALID_MOVE
  53.         else:
  54.             pos_x = math.floor( pos / 3 )
  55.             pos_y = pos % 3
  56.             if (player == 1):
  57.                 # if player 1, Check if player is playing out of turn.
  58.                 if (self.turn % 2 == self.O_TURN_MODULUS):
  59.                     # check if we are overwriting a position
  60.                     if (self.board[pos_x][pos_y] == 0):
  61.                         self.board[pos_x][pos_y] = self.PLAYER_O
  62.                         self.turn += 1
  63.                         returnVal = self.has_won(self.PLAYER_O)
  64.                     else:
  65.                         returnVal = self.res.INVALID_MOVE; 
  66.                 else:
  67.                     returnVal = self.res.OUT_OF_TURN
  68.             elif (player == 2):
  69.                 # if player 2, Check if player is playing out of turn.
  70.                 if (self.turn % 2 == self.X_TURN_MODULUS):
  71.                     # check if we are overwriting a position
  72.                     if (self.board[pos_x][pos_y] == 0):
  73.                         self.board[pos_x][pos_y] = self.PLAYER_X
  74.                         self.turn += 1
  75.                         returnVal = self.has_won(self.PLAYER_X)
  76.                     else:
  77.                         returnVal = self.res.INVALID_MOVE;
  78.                 else:
  79.                     returnVal = self.res.OUT_OF_TURN
  80.             else:
  81.                 # actually invalid player
  82.                 returnVal = self.res.INVALID_MOVE
  83.         return returnVal
  84.        
  85.     def set_X(self, pos_x, pos_y):
  86.         if ( self.game_over == False ):
  87.             # check if X is playing first.
  88.             if self.turn == 0:
  89.                 self.X_TURN_MODULUS = 0
  90.                 self.O_TURN_MODULUS = 1
  91.             # check if X is not playing out of turn.
  92.             if self.turn % 2 == self.X_TURN_MODULUS:
  93.                 # check if we are overwriting a position
  94.                 if (self.board[pos_x][pos_y] == 0):
  95.                     self.board[pos_x][pos_y] = self.PLAYER_X
  96.                     self.turn += 1
  97.                     # Check if the last move resulted in a victory
  98.                     return self.has_won(self.PLAYER_X)
  99.                 else:
  100.                     return self.res.INVALID_MOVE
  101.             else:
  102.                 return self.res.OUT_OF_TURN
  103.         else:
  104.             return self.res.INVALID_MOVE;
  105.    
  106.     def set_O(self,pos_x,pos_y):
  107.         # check if O is playing first.
  108.         if ( self.game_over == False ):
  109.             if self.turn == 0:
  110.                 self.X_TURN_MODULUS = 1
  111.                 self.O_TURN_MODULUS = 0
  112.             # check if O is not playing out of turn.
  113.             if self.turn % 2 == self.O_TURN_MODULUS:
  114.                 # check if we are overwriting a position
  115.                 if ( self.board[pos_x][pos_y] == 0 ):
  116.                     self.board[pos_x][pos_y] = self.PLAYER_O
  117.                     self.turn += 1
  118.                     # Check if the last move resulted in a victory
  119.                     return self.has_won(self.PLAYER_O)
  120.                 else:
  121.                     return self.res.INVALID_MOVE
  122.             else:
  123.                 return self.res.OUT_OF_TURN
  124.         else:
  125.             return self.res.INVALID_MOVE
  126.    
  127.     def has_won(self,player):
  128.         self.count_empty_squares();
  129.         transBoard = transpose(self.board);
  130.         result = self.check_board_for_winner( self.board, player ) | self.check_board_for_winner( transBoard, player )
  131.         returnVal = self.res.OK
  132.         # check for draw
  133.         if (result == True):
  134.             # We have a winner
  135.             self.game_over = True
  136.             self.won = True
  137.             returnVal = self.res.WIN
  138.         elif (result == False & self.game_over == True):
  139.             # No winner and no moves left.
  140.             returnVal = self.res.DRAW
  141.         elif (result == False & self.game_over == False):
  142.             # No winner and game not over. Play on.
  143.             returnVal = self.res.OK
  144.         self.won=result
  145.         return returnVal
  146.        
  147.     def count_empty_squares(self):
  148.         # Count the number of empty squares
  149.         self.empty_positions = 0
  150.         for i in self.board:
  151.             for j in i:
  152.                 if j == 0:
  153.                     self.empty_positions += 1;
  154.         if self.empty_positions == 0:
  155.             # If there are no empty squares, then pronounce the game over.
  156.             self.game_over = True;
  157.    
  158.     def check_board_for_winner(self,board,player):
  159.         # Check 3 horizontal and 1 diagonal.
  160.         win = False
  161.         if board[0] == [player, player, player]:
  162.             win = True
  163.         if board[1] == [player, player, player]:
  164.             win = True
  165.         if board[2] == [player, player, player]:
  166.             win = True
  167.         if ( [board[0][0], board[1][1], board[2][2]] == [ player, player, player ] ):
  168.             win = True
  169.         return win
  170.    
  171.     def board2str(self,boardS):
  172.         boardString=""
  173.         for i in range(0, 3):
  174.             for j in range (0,3):
  175.                 if j < 2:
  176.                     boardString += self.sym[boardS[i][j]] + '| '
  177.                 else:
  178.                     boardString += self.sym[boardS[i][j]];
  179.             boardString += "\n"
  180.         return boardString;    
  181.    
  182.     def getBoard(self):
  183.         boardString="";
  184.         for i in range(0, 3):
  185.             for j in range (0,3):
  186.                 if j < 2:
  187.                     boardString += self.sym[self.board[i][j]] + '| ';
  188.                 else:
  189.                     boardString += self.sym[self.board[i][j]];
  190.             boardString += "\n"
  191.         return boardString;
  192.        
  193. def main():
  194.     print("Tic Tac Toe Platform")
  195.     g=xo()
  196.     print(g.getBoard())
  197.    
  198.     print('Play :'+repr(g.set_X(2,2)))
  199.     print(g.getBoard())
  200.     print('----------')
  201.    
  202.     print('Play :'+repr(g.set_O(0,2)))
  203.     print(g.getBoard())
  204.     print('----------')
  205.    
  206.     print('Play :'+str(g.set_X(1,2)))
  207.     print(g.getBoard())
  208.     print('----------')
  209.    
  210.     print('Play :'+str(g.set_O(2,0)))
  211.     print(g.getBoard())
  212.     print('----------')
  213.  
  214.     print('Play :'+str(g.set_X(0,0)))
  215.     print(g.getBoard())
  216.     print('----------')
  217.    
  218.     print('Play :'+str(g.set_O(0,1)))
  219.     print(g.getBoard())
  220.     print('----------')
  221.    
  222.     # out of turn
  223.     print('Play :'+str(g.set_O(0,1)))
  224.     print(g.getBoard())
  225.     print('----------')
  226.    
  227.     # invalid move
  228.     print('Play :'+str(g.set_O(0,1)))
  229.     print(g.getBoard())
  230.     print('----------')
  231.    
  232.    
  233.     print('Play :'+str((g.set_X(1,1))))
  234.     print(g.getBoard())
  235.     print('----------')
  236.  
  237. if __name__ == '__main__':
  238.     main()
RAW Paste Data