ΘΕΜΑ: Παιχνίδι Τρίλιζα 2 Παιχτών

def display_score(score):
    print ("Το σκόρ είναι {} ".format(score))
 
def place_marker(board, marker, position): 
    board[position] = marker
 
Έγώ δεν θα τις χρησιμοποιούσα από ότι βλέπω χρησιμοποιείς μια φορά την καθεμία
βάλε κατευθείαν στην main τον κορμό τους
 

def choose_first():
    player = ''
    arithmos = random.randint(1,2)
    if arithmos == 1 :
        player = 'Παίκτης 1'
    else:
        player = 'Παίκτης 2'
    return player
 
 

def choose_first():
  return 'Παίκτης {}'.format(random.randint(1,2))

def board_check(board): 
    check = False
    if board[1] == ' ' or board[2] == ' ' or board[3] == ' ' or board[4] == ' ' or board[5] == ' ' or board[6] == ' ' or board[7] == ' ' or board[8] == ' ' or board[9] == ' '  :
        return False
    else :
        return True
 

def board_check(board):
  return all(map(lambda x: x!=' ', board[1:]))
 

def player_choice(board, turn): 
    epilogi = ''
    epilogi = input("Ποία είναι η κινησή σου? (1-9) : {} ".format(turn))
    while True :
        if epilogi not in '1 2 3 4 5 6 7 8 9'.split() :
            epilogi = input("Ποία είναι η κινησή σου? (1-9) : {} ".format(turn))
            continue
        else :
            if board[int(epilogi)] != ' ' :
                print("Πιασμένο Τετράγωνο Ξαναδοκίμασε")
                epilogi = input("Ποία είναι η κινησή σου? (1-9) : {} ".format(turn))
                continue
            else :
                return int(epilogi)

def player_choice(board, turn): 
  while True :
    epilogi = input("Ποία είναι η κινησή σου? (1-9) : {} ".format(turn))
    if epilogi not in list('123456789'):
      continue
    elif board[int(epilogi)] != ' ':
      print("Πιασμένο Τετράγωνο Ξαναδοκίμασε")
      continue
    else:
      return int(epilogi)

#Author: babaliaris.nikos@gmail.com
#Date  : 7/6/2017
#Name  : Triceza.py
#Python: Python 3.6
 
 
 
 
#Graphics.
graphics ='''+--------------+
+    |    |    +
+--------------+
+    |    |    +
+--------------+
+    |    |    +
+--------------+'''
 
 
#Where to fill positions.
pos = [ [(1,2), (1,7), (1,12)],
        [(3,2), (3,7), (3,12)],
        [(5,2), (5,7), (5,12)],
      ]
 
 
 
 
#===============================Main===============================#
def main():
    '''Start the game.'''
 
    #Create a 2D array.
    array = createArray()
 
    #Positions already used.
    used  = []
 
    #Start playing.
    for i in range(9):
 
        #Repeat.
        repeat = True
 
        while repeat:
 
            #Just some space.
            print("")
 
            #Render the array.
            render(array)
 
            #Player 1.
            if i%2 == 0:
                ch = "O"
                print("\nPlayer 1")
 
            #Player 2.
            else:
                ch = "X"
                print("\nPlayer 2")
 
 
            #Try to read integers.
            try:
                row    = int(input("Give row   : "))
                column = int(input("Give column: "))
                pass
 
            #Failed.
            except ValueError:
                print("You must give integer numbers!")
                continue
 
 
            #The position already in use.
            if (row, column) in used:
                print("The cell["+str(row)+"]["+str(column)+"] is" \
                      " already filled.")
                continue
 
 
            #Fill.
            error = fill(array, row, column, ch)
 
            #An error occured.
            if error != None:
                print(error)
                continue
 
            #Append a used position.
            used.append( (row, column) )
 
            #Check for win.
            answer = checkWin(array)
 
            #Player 1 wins.
            if answer == "O":
                render(array)
                print("\nPlayer 1 wins!")
                input("Press ENTER to exit...")
                return
 
            #Player 1 wins.
            elif answer == "X":
                render(array)
                print("\nPlayer 2 wins!")
                input("Press ENTER to exit...")
                return
 
            #Do not repeat.
            repeat = False
 
 
    #Match is equal.
    print("\nThe match is equal!")
    input("Press ENTER to exit...")
#===============================Main===============================#
 
 
 
 
 
#===========================Create Array===========================#
def createArray():
    '''Create's a 2D Array with the characters of the graphics.'''
 
    #2D Array.
    array = [[]]
 
    #----------Fill the array with the grapics----------#
    counter = 0
    for i, ch in enumerate(graphics):
 
        #If i'm still in a row.
        if ch != "\n":
 
            #Append the character in this column.
            array[counter].append(ch)
            pass
 
        #Else create a new row.
        else:
 
            #Create a new list inside the array.
            array.append([])
 
            #Encrease the counter.
            counter += 1
            pass
    #----------Fill the array with the grapics----------#
 
    return array
#===========================Create Array===========================#
 
 
 
 
 
#==============================Render==============================#
def render(array):
    '''Draw the graphics on the screen.'''
 
    #Print column numbers.
    print("    1    2    3   ")
 
    #Go through the rows.
    for row in range( len(array) ):
        string = ""
 
        #Go through columns.
        for column in range( len(array[row]) ):
            string += array[row][column]
 
        #Create the row 1.
        if row == 1:
            string = "1 "+string
            pass
 
        #Create the row 2.
        elif row == 3:
            string = "2 "+string
            pass
 
        #Create the row 3.
        elif row == 5:
            string = "3 "+string
            pass
 
        #Create other graphics.
        else:
            string = "  "+string
 
        #Print.
        print(string)
#==============================Render==============================#
 
 
 
 
 
#===============================Fill===============================#
def fill(array, x, y, ch):
    '''Fill the graphics with a character.'''
 
    #Check x and y.
    if x < 1 or x > 3 or y < 1 or y > 3:
        return "x and y must be numbers between 1 and 3."
 
    #Get the position of the array.
    x, y = pos[x-1][y-1]
 
    #Fill the array with that character.
    array[x][y] = ch
#===============================Fill===============================#
 
 
 
 
#=============================Check Win============================#
def checkWin(array):
    '''Check if someone won.'''
 
    #Characters.
    chars  = ["O", "X"]
 
    for ch in chars:
 
        #Check row 0.
        if array[ pos[0][0][0]]  [pos[0][0][1] ] == ch and \
           array[ pos[0][1][0]]  [pos[0][1][1] ] == ch and \
           array[ pos[0][2][0]]  [pos[0][2][1] ] == ch:
            return ch
 
        #Check row 1.
        elif array[ pos[1][0][0]]  [pos[1][0][1] ] == ch and \
             array[ pos[1][1][0]]  [pos[1][1][1] ] == ch and \
             array[ pos[1][2][0]]  [pos[1][2][1] ] == ch:
            return ch
 
        #Check row 2.
        elif array[ pos[2][0][0]]  [pos[2][0][1] ] == ch and \
             array[ pos[2][1][0]]  [pos[2][1][1] ] == ch and \
             array[ pos[2][2][0]]  [pos[2][2][1] ] == ch:
            return ch
 
 
        #Check column 0.
        if array[ pos[0][0][0]]  [pos[0][0][1] ] == ch and \
           array[ pos[1][0][0]]  [pos[1][0][1] ] == ch and \
           array[ pos[2][0][0]]  [pos[2][0][1] ] == ch:
            return ch
 
        #Check column 1.
        elif array[ pos[0][1][0]]  [pos[0][1][1] ] == ch and \
             array[ pos[1][1][0]]  [pos[1][1][1] ] == ch and \
             array[ pos[2][2][0]]  [pos[2][2][1] ] == ch:
            return ch
 
        #Check column 2.
        elif array[ pos[0][2][0]]  [pos[0][2][1] ] == ch and \
             array[ pos[1][2][0]]  [pos[1][2][1] ] == ch and \
             array[ pos[2][2][0]]  [pos[2][2][1] ] == ch:
            return ch
 
        #Check diagonal from left to right.
        elif array[ pos[0][0][0]]  [pos[0][0][1] ] == ch and \
             array[ pos[1][1][0]]  [pos[1][1][1] ] == ch and \
             array[ pos[2][2][0]]  [pos[2][2][1] ] == ch:
            return ch
 
        #Check diagonal from right to left.
        elif array[ pos[0][2][0]]  [pos[0][2][1] ] == ch and \
             array[ pos[1][1][0]]  [pos[1][1][1] ] == ch and \
             array[ pos[2][0][0]]  [pos[2][0][1] ] == ch:
            return ch
 
 
    return ""
#=============================Check Win============================#
 
 
 
 
 
#Run the program.
if __name__ == "__main__":
    main()
 

def win_check(board,mark): 
    if board[1] == board[2] == board[3] == mark :
        return True
    elif board[4] == board[5] == board[6] == mark :
        return True
    elif board[7] == board[8] == board[9] == mark :
        return True
    elif board[7] == board[4] == board[1] == mark :
        return True
    elif board[8] == board[5] == board[2] == mark :
        return True
    elif board[9] == board[6] == board[3] == mark :
        return True
    elif board[7] == board[5] == board[3] == mark :
        return True
    elif board[9] == board[5] == board[1] == mark :
        return True
    else:
        return False

def win_check(board, marker):
  win_options=('123','456','789','147','258','369','357','159')
  for option in win_options:
    if board[int(option[0])]==board[int(option[1])]==board[int(option[2])]==marker:
      return True
  return False

def play_robot(self):
    options=[i for i in range(1,10) if self.board[i]==' ']
 
    #check for win
    for i in options:
      self.board[int(i)]=self.symbol2
      if self.win_check(self.symbol2):
        return
      else:
        self.board[int(i)]=' ' 
 
    #check for loses
    for i in options:
      self.board[int(i)]=self.symbol1
      if self.win_check(self.symbol1):
        self.board[int(i)]=self.symbol2
        return
      else:
        self.board[int(i)]=' '
 
    #Robot tries to make a fork
    for i in options: 
      self.board[int(i)]=self.symbol2
      new_options=[i for i in range(1,10) if self.board[i]==' ']
      ways_to_win=0
      for j in new_options:
        self.board[int(j)]=self.symbol2
        if self.win_check(self.symbol2):
          ways_to_win+=1
        self.board[int(j)]=' '
      if ways_to_win==2:
        return
      else:
        self.board[int(i)]=' '
 
    #avoid fork
    if self.board[5]==self.symbol2 and self.board[1]==self.symbol1 and self.board[9]==self.symbol1 and self.board[2]==' ' and self.board[4]==' ' and self.board[6]==' ' and self.board[8]==' ':
      self.board[2]=self.symbol2
      return
    #avoid fork 
    if self.board[5]==self.symbol2 and self.board[3]==self.symbol1 and self.board[7]==self.symbol1 and self.board[2]==' ' and self.board[4]==' ' and self.board[6]==' ' and self.board[8]==' ':
      self.board[2]=self.symbol2
      return
    for i in options: #Stop players fork not sure if it evers play
      self.board[int(i)]=self.symbol1
      new_options=[i for i in range(1,10) if self.board[i]==' ']
      ways_to_win=0
      for j in new_options:
        self.board[int(j)]=self.symbol1
        if self.win_check(self.symbol1):
          ways_to_win+=1
        self.board[int(j)]=' '
      if ways_to_win==2:
        self.board[int(i)]=self.symbol2
        return
      else:
        self.board[int(i)]=' '
 
    #check for center
    if self.board[5]==' ': 
      self.board[5]=self.symbol2
      return
 
    #check for corner 
    for i in options: 
      if i in (1,3,5,7):
        self.board[i]=self.symbol2
        return
 
    #get random
    self.board[random.choice(options)]=self.symbol2
 

# Τρίλιζα (Tic Tac Toe στα Αγγλικά)
 
import random
 
 
def draw_board(board):
    # Εκτύπωση του board
    # Ορίζουμε το "board" σαν λίστα 10 από stings και αγνοούμε το index 0.
    print('\n')
    print(' 7' + ' '*4 + '|' + '8' + ' '*4 + '|' + '9' + ' '*4)
    print('   ' + board[7] + '  ' + '|' + '  ' + board[8] + '  ' + '|' + '  ' + board[9] + '  ')
    print(' '*6 + '|' + ' '*5 + '|' + ' '*5)
    print(' -----+-----+-----')
    print(' 4' + ' '*4 + '|' + '5' + ' '*4 + '|' + '6' + ' '*4)
    print('   ' + board[4] + '  ' + '|' + '  ' + board[5] + '  ' + '|' + '  ' + board[6] + '  ')
    print(' '*6 + '|' + ' '*5 + '|' + ' '*5)
    print(' -----+-----+-----')
    print(' 1' + ' '*4 + '|' + '2' + ' '*4 + '|' + '3' + ' '*4)
    print('   ' + board[1] + '  ' + '|' + '  ' + board[2] + '  ' + '|' + '  ' + board[3] + '  ')
    print(' '*6 + '|' + ' '*5 + '|' + ' '*5)
    print('\n')
 
 
def player_sign():
    # Ο παίκτης διαλέγει με ποιό γράμμα θα παίξει.
    # Επιστρέφεται μια λίστα με 2 στοιχεία: του παίκτη και του Η/Υ.
    sign = ''
    while not (sign == 'X' or sign == 'O' or sign == 'Χ' or sign == 'Ο'):
        print('Θέλετε να παίξετε με το Χ ή με το Ο;')
        sign = input().upper()
 
    # Το πρώτο στοιχείο της λίστας είναι του παίκτη. Το δεύτερο του Η/Υ.
    if sign == 'X':
        return ['X', 'O']
    else:
        return ['O', 'X']
 
 
def whos_turn():
    # Τυχαία διαλέγουμε ποιος θα παίξει πρώτος.
    if random.randint(0, 1) == 0:
        return 'computer'
    else:
        return 'player'
 
 
def make_move(board, sign, move):
    board[move] = sign
 
 
def win(board, mark): 
    # Η συνάρτηση εξετάζει αν ο παίκτης νίκησε με δεδομένο τον πίνακα και το γράμμα του παίκτη.
    # bo είναι για το board και le για το γράμμα.
    return ((board[7] == mark and board[8] == mark and board[9] == mark) or # Πάνω σειρά
    (board[4] == mark and board[5] == mark and board[6] == mark) or # Μεσαία σειρά
    (board[1] == mark and board[2] == mark and board[3] == mark) or # Κάτω σειρά
    (board[7] == mark and board[4] == mark and board[1] == mark) or # Αριστερή στήλη
    (board[8] == mark and board[5] == mark and board[2] == mark) or # Μεσαία στήλη
    (board[9] == mark and board[6] == mark and board[3] == mark) or # Δεξιά στήλη
    (board[7] == mark and board[5] == mark and board[3] == mark) or # Διαγώνιος 1
    (board[1] == mark and board[5] == mark and board[9] == mark)) # Διαγώνιος 2
 
def copy_board(board):
    # Αντιγράφουμε την λίστα του board και την επιστρέφουμε.
    boardCopy = []
    for i in board:
        boardCopy.append(i)
    return boardCopy
 
def free_space(board, move):
    # Έλεγχος για ελεύθερη κίνηση.
    return board[move] == ' '
 
def player_move(board):
    # Ο παίκτης διαλέγει κίνηση.
    move = ' '
    while move not in '1 2 3 4 5 6 7 8 9'.split() or not free_space(board, int(move)):
        print('Ποιά είναι η επόμενη σας κίνηση; [1-9]: ')
        move = input()
    return int(move)
 
def random_move(board, movesList):
    # Επιστρέφει μια επιτρεπτή κίνηση και None αν δεν υπάρχει τέτοια.
    possibleMoves = []
    for i in movesList:
        if free_space(board, i):
            possibleMoves.append(i)
 
    if len(possibleMoves) != 0:
        return random.choice(possibleMoves)
    else:
        return None
 
def computer_move(board, computerLetter):
    # Με βάση τον πίνακα και το γράμμα του Η/Υ επιστρέφει την κίνηση του.
    if computerLetter == 'X':
        playerLetter = 'O'
    else:
        playerLetter = 'X'
 
    # Εδώ ξεκινά το AI:
    # Έλεγχος αν μπορεί να νικήσει το computer στην επόμενη κίνηση.
    for i in range(1, 10):
        boardCopy = copy_board(board)
        if free_space(boardCopy, i):
            make_move(boardCopy, computerLetter, i)
            if win(boardCopy, computerLetter):
                return i
 
    # Αν ο παίκτης νικάει με επόμενη κίνηση, τότε τον μπλοκάρουμε.
    for i in range(1, 10):
        boardCopy = copy_board(board)
        if free_space(boardCopy, i):
            make_move(boardCopy, playerLetter, i)
            if win(boardCopy, playerLetter):
                return i
 
    # Επιλέγουμε μια από τις γωνίες αν είναι ελεύθερη.
    move = random_move(board, [1, 3, 7, 9])
    if move != None:
        return move
 
    # Επιλογή του κέντρου.
    if free_space(board, 5):
        return 5
 
    # Επιλογή στις πλευρές.
    return random_move(board, [2, 4, 6, 8])
 
def full_board(board):
    # Επιστρέφει True αν ΔΕΝ υπάρχει ελεύθερος χώρος στο board ή False στην αντίθετη περίπτωση.
    for i in range(1, 10):
        if free_space(board, i):
            return False
    return True
 
 
print('Καλωσήρθατε στην Τρίλιζα!')
 
while True:
    # Αρχικοποίηση του board
    theBoard = [' '] * 10
    playerLetter, computerLetter = player_sign()
    turn = whos_turn()
    print('Πρώτος παίζει: ' + turn)
    gameIsPlaying = True
 
    while gameIsPlaying:
        if turn == 'player':
            # Σειρά του Παίκτη.
            draw_board(theBoard)
            move = player_move(theBoard)
            make_move(theBoard, playerLetter, move)
 
            if win(theBoard, playerLetter):
                draw_board(theBoard)
                print('Συγχαρητήρια! Νίκησες.')
                gameIsPlaying = False
            else:
                if full_board(theBoard):
                    draw_board(theBoard)
                    print('Ισοπαλία!')
                    break
                else:
                    turn = 'computer'
 
        else:
            # Σειρά του H/Υ.
            move = computer_move(theBoard, computerLetter)
            make_move(theBoard, computerLetter, move)
 
            if win(theBoard, computerLetter):
                draw_board(theBoard)
                print('Το computer νίκησε! Λυπάμαι αλλά έχασες.')
                gameIsPlaying = False
            else:
                if full_board(theBoard):
                    draw_board(theBoard)
                    print('Ισοπαλία!')
                    break
                else:
                    turn = 'player'
 
    print('Θέλετε να ξαναπαίξετε; (Ναι/Όχι): ')
    if not input().lower().startswith('ν'):
        break