def lancejeu():
"""Routine de lancement du jeu"""
print('OTHELLO avec une IA')
#
#########joueur VS joueur #######################
jblanc = joueur.Joueur('Blanc', 'o')
jnoir = joueur.Joueur('Noir', 'x')
jeu = po.Othello(jblanc, jnoir)
# ####### joueur VS ia_faible #####################
# jblanc = joueur.Joueur('Blanc', 'o')
# ia_faib = iaf.IAFaible('iafaible','x')
# jeu = po.Othello(jblanc,ia_faib)
# ####### joueur VS ia_forte ######################
# jblanc = joueur.Joueur('Blanc', 'o')
# ia_fort = iaF.IAForte('iaforte','x')
# jeu = po.Othello(jblanc,ia_fort)
# ####### ia_faible VS ia_forte ###################
# ia_faib = iaf.IAFaible('iafaible','o')
# ia_fort = iaF.IAForte('iaforte','x')
# jeu = po.Othello(ia_faib,ia_fort)
# #################################################
#
jeu.info()
jeu.jeu()
def init_othello(self, row, col, first_p, wincond, b_list, w_list):
'''
This initializes an othello object.
'''
board = othello.make_board(row, col, b_list, w_list)
self.oth = othello.Othello(row, col, first_p, wincond, board)
self.oth.is_there_winner()
self.oth.corner_case()
def main():
root = othello.tk.Tk()
computer1 = player.Player(3, -1)
computer2 = player.Player(4, 1)
game = othello.Othello(computer1, computer2, master=root)
game.mainloop()
def __init__(self, master=None, couleur=oth.NOIR, table=None):
tk.Frame.__init__(self, master)
self.master = master
self.jeu = oth.Othello(table)
# self.joueur est la couleur du joueur physique,
# self.jeu.joueur est le joueur dont c'est le tour
self.joueur = couleur
self.create_widgets()
def __init__(self):
super().__init__()
self.images = {} # image resources
self.keys_down = {} # records of down-keys
# create game object
self.game = othello.Othello()
self.debug = False # True for debugging
def main():
# Initializes the game
game = othello.Othello()
game.draw_board()
game.initialize_board()
# Starts playing the game
# The user makes a move by clicking one of the squares on the board
# The computer makes a random legal move every time
# Game is over when there are no more lagal moves or the board is full
game.run()
def _start_game() -> 'Othello':
'''
This function starts the interaction with the user by asking for the size of
the gameboard they wish to play Othello on, the player with the
first turn and how the game is won. This information is used to create
an Othello object with those specifications.
'''
print('FULL')
info_list = []
while (len(info_list) == 0):
try:
row = int(input())
if (row % 2 == 1 or row < 4 or row > 16):
print('ERROR')
continue
info_list.append(row)
column = int(input())
if (column % 2 == 1 or column < 4 or column > 16):
print('ERROR')
info_list = []
continue
info_list.append(column)
first_turn_player = input().upper()
if not (first_turn_player == 'B' or first_turn_player == 'W'):
print('ERROR')
info_list = []
continue
info_list.append(first_turn_player)
win_condition = input()
if not (win_condition == '>' or win_condition == '<'):
print('ERROR')
info_list = []
continue
info_list.append(win_condition)
except ValueError:
print('ERROR')
info_list = []
continue
return othello.Othello(info_list[0], info_list[1], info_list[2],
info_list[3])
def __init__(self : 'CounterPositions', rows : int, columns : int,
first_turn_player : str, win_condition : str) \
-> 'CounterPositions':
'''
The constructor for the CounterPositions class. It holds an Othello
object to handle the game logic of Othello. The counter locations
held what and where the counters were placed on the board. Spot
coordinates hold the positions of each grid within the Othello board.
Initial setup holds the information for the initial gameboard state.
'''
self.gameboard = othello.Othello(rows, columns, first_turn_player,
win_condition)
self.counter_locations = []
self.spot_coordinates = []
self.initial_setup = []
for row_index in range(rows):
self.initial_setup.append([])
self.spot_coordinates.append([])
for column_index in range(columns):
new_spot = othello_point.from_frac(
(row_index + row_index + 1) / (2 * rows),
(column_index + column_index + 1) / (2 * columns))
if (1/rows) <= (1/columns):
end_point = othello_point.from_frac(
row_index / rows,
(column_index + column_index + 1) / (2 * columns))
else:
end_point = othello_point.from_frac(
(row_index + row_index + 1) / (2 * rows),
column_index / columns)
new_radius = new_spot.distance_from_frac(end_point)
new_counter = Counter(new_spot, new_radius,
1 / (2 * rows), 1 / (2 * columns))
self.spot_coordinates[row_index].append(new_counter)
self.initial_setup[row_index].append('.')
def _run_game():
'''run the game, play the game, takes in 2 players, they alternate'''
print("\nFULL")
col = choose_num_col()
row = choose_num_row()
'''Asks user input for turn and winning criteria'''
turn = input()
winning_criteria = input()
#board = get_board(col, row)
board = [['.', '.', '.', '.'], ['.', 'B', 'B', '.'], ['.', 'B', 'B', '.'],
['.', '.', '.', '.']]
'''creates an object of the class Othello'''
ogame = othello.Othello(col, row, winning_criteria, turn, board)
while True:
'''principle while loop that runs through the steps of thello printing
number of tiles, the board, current turn, and switching tiles'''
try:
if not ogame.no_more_empty_spaces():
ogame.print_num_tiles()
ogame.print_screen()
ogame.print_player_turn()
while not ogame.check_and_switch(get_coord()):
print("INVALID")
print("VALID")
ogame.change_player_turn()
elif ogame.winner() == ogame.BLACK:
ogame.print_num_tiles()
ogame.print_screen()
print("WINNER:", ogame_BLACK)
break
elif ogame.winner() == ogame.WHITE:
ogame.print_num_tiles()
ogame.print_screen()
print("WINNER:", ogame.WHITE)
break
elif ogame.winner() == ogame.NONE:
ogame.print_num_tiles()
ogame.print_screen()
print("WINNER: NONE")
break
except IndexError:
pass
col_input = move[1]
othello_game.get_list_moves(row_input, col_input)
while (othello_game.check_valid() == False):
print("INVALID")
move = get_move(othello_game)
row_input = move[0]
col_input = move[1]
othello_game.get_list_moves(row_input, col_input)
print("VALID")
othello_game.turn_disks(row_input, col_input)
othello_game.change_turn()
othello_game.count_disks()
print("B: " + str(othello_game.bcount) + " W: " +
str(othello_game.wcount))
othello_game.print_board()
othello_game.print_winner()
if __name__ == "__main__":
print("FULL")
try:
rows, columns, turn, mode, start_board = get_user_info()
othello_game = othello.Othello(rows, columns, turn, mode, start_board)
play_game(othello_game)
except:
pass
'''
Created on May 17, 2017
@author: jonathanlin
'''
import othello
obj = othello.Othello(
3, 5, "B", ">",
[". . . . . .", "B W W W W .", ". . . . . .", ". . . . . ."])
try:
coord = obj._check_left(1, 5)
assert (coord == (1, 0))
print("Left 1 Passed")
except:
print("Left 1 Failed")
obj = othello.Othello(
5, 3, "B", ">",
[". . . .", "B W W .", ". . . .", ". . . .", ". . . .", ". . . ."])
try:
coord = obj._check_left(1, 3)
assert (coord == (1, 0))
print("Left 2 Passed")
except:
print("Left 2 Failed")
obj = othello.Othello(
3, 5, "B", ">",
[". . . . . .", ". W W W W B", ". . . . . .", ". . . . . ."])
def __init__(self, master=None, couleur=oth.NOIR):
tk.Frame.__init__(self, master)
self.master = master
self.jeu = oth.Othello()
self.joueur = couleur #self.joueur est la couleur du joueur, self.jeu.joueur est la couleur de celui dont c'est le tour
self.create_widgets()
# This file is executed on every boot (including wake-boot from deepsleep)
import gc
#import webrepl
import network
import esp
import othello
esp.osdebug(None)
#webrepl.start()
gc.collect()
st_if = network.WLAN(network.STA_IF)
ap_if = network.WLAN(network.AP_IF)
ap_if.ifconfig(('6.6.6.1', '255.255.255.128', '6.6.6.1', '8.8.8.8'))
ap_if.config(essid='esp_mpc')
ap_if.config(password='******')
#st_if.active(1)
#st_if.connect('ESSID', 'password')
game1 = othello.Othello()
game1srv = othello.OthelloServer(game1)
# Fonts
OPEN_SANS = "./assets/OpenSans-Regular.ttf"
UNIQUE = "./assets/Unique.ttf"
smallFont = pygame.font.Font(OPEN_SANS, 20)
mediumFont = pygame.font.Font(UNIQUE, 28)
largeFont = pygame.font.Font(UNIQUE, 40)
# Compute board size
BOARD_PADDING = 20
board_width = ((2 / 3) * width) - (BOARD_PADDING * 2)
board_height = height - (BOARD_PADDING * 2)
cell_size = int(min(board_width / 8, board_height / 8))
board_origin = (BOARD_PADDING, BOARD_PADDING)
game = o.Othello()
ai_turn = False
version = "Beta 1.0.0 v2"
user = None
Instructions = False
i = [
"Take turns against the AI",
"Make a move by clicking on an empty tile",
"All pieces between your move and any other friendly piece will convert",
"Your move must convert at least one other tile",
"Win by ending the game with the most pieces of your color on the board",
"The game ends when either all tiles are filled or no moves are left",
def _on_version_label(self) -> None:
# When the user clicks the FULL button, we pop up a GameDialog.
# Since we've already encapsulate all of that in the GameDialog
# class, all we need to do is create a GameDialog object, ask it
# to show itself, and then ask it afterward what happened.
#
# Note that the call to show() isn't going to return until the user
# has dismissed the dialog box.
dialog = GameDialog()
dialog.show()
# After the dialog box is dismissed, we'll check if it was the PLAY
# or the QUIT button that got clicked. If PLAY was clicked, we'll
# change the version label's text by setting its control variable.
if dialog.was_play_clicked():
self.row_num = dialog.return_row()
self.col_num = dialog.return_col()
self.player_turn = dialog.return_turn()
self.win_crit = dialog.return_win_crit()
self.white_placed = dialog.return_white_placed()
self.black_placed = dialog.return_white_placed()
self.ogame = othello.Othello(self.col_num, self.row_num,
self.win_crit, self.player_turn)
self.white_counter = 0
self.black_counter = 0
self.game_over = False
self.version_button.destroy()
self._canvas = tkinter.Canvas(master=self._root_window,
width=self.col_num * 100,
height=self.row_num * 100,
background="GREEN")
self._canvas.grid(row=1,
column=0,
columnspan=3,
padx=10,
pady=10,
sticky=tkinter.N + tkinter.S + tkinter.E +
tkinter.W)
self.width = self._canvas.winfo_width()
self.height = self._canvas.winfo_height()
self.turn = tkinter.StringVar()
self.turn.set("TURN: {}".format(self.ogame.get_turn()))
self.bscore = tkinter.StringVar()
self.bscore.set("B: {}".format(self.ogame.count_black_tiles()))
self.wscore = tkinter.StringVar()
self.wscore.set("W: {}".format(self.ogame.count_white_tiles()))
self.turn_label = tkinter.Label(master=self._root_window,
textvariable=self.turn)
self.turn_label.grid(row=0,
column=0,
pady=5,
sticky=tkinter.N + tkinter.S + tkinter.E +
tkinter.W)
self._root_window.rowconfigure(0, weight=0)
self._root_window.columnconfigure(0, weight=1)
self.bscore_label = tkinter.Label(master=self._root_window,
textvariable=self.bscore)
self.bscore_label.grid(row=0,
column=1,
pady=5,
sticky=tkinter.N + tkinter.S + tkinter.E +
tkinter.W)
self._root_window.rowconfigure(0, weight=0)
self._root_window.columnconfigure(1, weight=1)
self.wscore_label = tkinter.Label(master=self._root_window,
textvariable=self.wscore)
self.wscore_label.grid(row=0,
column=2,
pady=5,
sticky=tkinter.N + tkinter.S + tkinter.E +
tkinter.W)
self._root_window.rowconfigure(0, weight=0)
self._root_window.columnconfigure(2, weight=1)
self._canvas.bind("<Configure>", self.adjust_screen_dimensions)
self._canvas.bind("<Button-1>", self.check_and_switch)
def __init__(self, parent=None):
super().__init__(parent)
self.GameName = QLabel()
self.GameName.setText("Othello Game")
self.GameName.setAlignment(Qt.AlignCenter)
self.turnstatus = QLabel()
self.turnstatus.setText("흑돌 차례")
self.turnstatus.setAlignment(Qt.AlignCenter)
self.gameerror = QLabel()
self.gameerror.setAlignment(Qt.AlignCenter)
self.blackplayer = QLabel()
self.blackplayer.setText("●")
self.whiteplayer = QLabel()
self.whiteplayer.setText("○")
self.blackstatus = QLabel()
self.blackstatus.setText(str(2))
self.whitestatus = QLabel()
self.whitestatus.setText(str(2))
self.statusLayout = QHBoxLayout()
self.statusLayout.addWidget(self.blackplayer)
self.statusLayout.addWidget(self.blackstatus)
self.statusLayout.addWidget(self.whiteplayer)
self.statusLayout.addWidget(self.whitestatus)
self.buttonList = [[QToolButton() for i in range(8)] for j in range(8)]
self.buttonLayout = QGridLayout()
for i in range(8):
for j in range(8):
self.buttonLayout.addWidget(self.buttonList[i][j], i, j)
self.buttonLayout.setSizeConstraint(QLayout.SetFixedSize)
for i in range(8):
for j in range(8):
self.buttonList[i][j].clicked.connect(self.ButtonClicked)
self.x = i
self.y = j
self.undoButton = QPushButton()
self.undoButton.setText("실행취소")
self.newgameButton = QPushButton()
self.newgameButton.setText("새 게임")
self.settingLayout = QHBoxLayout()
self.settingLayout.addWidget(self.undoButton)
self.settingLayout.addWidget(self.newgameButton)
mainLayout = QGridLayout()
mainLayout.addWidget(self.GameName, 0, 0)
mainLayout.addWidget(self.turnstatus, 1, 0)
mainLayout.addWidget(self.gameerror, 2, 0)
mainLayout.addLayout(self.statusLayout, 3, 0)
mainLayout.addLayout(self.buttonLayout, 4, 0)
mainLayout.addLayout(self.settingLayout, 5, 0)
self.game = othello.Othello()
self.undogame = undogame.UndoTurn()
self.newgameButton.clicked.connect(self.settingNewGame)
self.undoButton.clicked.connect(self.UndoGame)
self.game.New_Game() # 게임을 시작한다
self.setBoardGUI(self.game.getboard())
self.setLayout(mainLayout)
self.setWindowTitle("Othello")