class StartQt4(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self,parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.view = BoardView(self.ui.graphicsView)
self.opponent = Ai()
#event bindings
QtCore.QObject.connect(self.ui.newGameButton,QtCore.SIGNAL("clicked()"),self.newGame)
def newGame(self):
self.view.clearBoard()
self.board = None
self.ui.winnerLabel.setText("Player goes first")
def mousePressEvent(self, event):
"""
Event executed after every mouse press; All internal game loop logic contained here
"""
if self.view.winCheck():
self.playerWin()
#AI move
self.opponent.updateBoard(self.view.boardMatrix)
self.opponent.move()
#check win
def playerWin(self):
self.ui.winnerLabel.setText("Congratulations! You won!")
def runAI_2(self, weights, limitPiece):
self.gameover = False
self.paused = False
#dont_burn_my_cpu = pygame.time.Clock()
while 1:
if (self.nbPiece >= limitPiece
and limitPiece > 0) or (self.moves_left <= 0):
self.gameover = True
if self.playWithUI:
self.gui.update(self)
if self.gameover:
return self.lines * 1000 + self.nbPiece
if not self.computed:
self.computed = True
Ai.choose(self.board, self.stone, self.next_stone,
self.stone_x, weights, self)
if self.playWithUI:
for event in pygame.event.get():
if event.type == pygame.USEREVENT + 1:
self.drop(True)
elif event.type == pygame.QUIT:
self.quit()
elif event.type == pygame.KEYDOWN:
if event.key == eval("pygame.K_s"):
self.speed_up()
elif event.key == eval("pygame.K_p"):
self.toggle_pause()
def test_random(self):
board = Board(tk.Toplevel())
ai = Ai('black', board.squares, board, None, None)
ai.random()
piece = board.squares[(ai.rowpiece, ai.colpiece)]['piece']
if piece is not None:
self.assertTrue(piece.color == 'black')
def __init__(self):
self._board = Board()
self._other_board = Board()
self._game = Game(self._board)
self.control_game = Game(self._other_board)
# Takes the exact board as the displayed game
self._ai = Ai(self.control_game)
def click(self, button):
"""Print symbol in button. Create Ai object, leads the gameplay of player and ai, check wrong moves and draw."""
intel = Ai()
if button['text'] == ' ' and Button.clickable:
if Game.computer_move_quantity < 4:
button['text'] = 'X'
Game.player_move_quantity += 1
Button.clickable = False
gameboardcls.Gameboard.gameboard_obj.check_global_win('X')
if not Button.clickable:
if Game.player_move_quantity <= 4:
intel.move_to_win()
Game.computer_move_quantity += 1
Button.clickable = True
gameboardcls.Gameboard.gameboard_obj.check_global_win(
'O')
else:
messagebox.showinfo(
'Attention',
'It seems to be a draft\n Lets restart game')
self.new_game_button_func()
else:
messagebox.showinfo(
'Attention', 'It seems to be a draft\n Lets restart game')
self.new_game_button_func()
else:
messagebox.showerror(
'Attention',
'Oops... This button has already been pushed\n Choose another one'
)
def __init__(self):
pygame.init()
self.manager = GameManager()
self.enemy = Ai()
pygame.display.set_caption("Tic Tac Toe")
self.WIDTH = 540
self.HEIGHT = 540
self.screen = pygame.display.set_mode((self.WIDTH, self.HEIGHT))
self.background = pygame.Surface((self.WIDTH, self.HEIGHT))
self.background.fill(pygame.Color('#E3E3E3'))
# FONTS
self.playerFont = pygame.font.SysFont('arial', 70)
self.resultFont = pygame.font.SysFont('arial', 60, bold=True)
self.infoFont = pygame.font.SysFont('arial', 30, italic=True)
# define cell dimensions
self.cellWidth = self.WIDTH / 3
self.cellHeight = self.HEIGHT / 3
self.board = []
# to create the 3x3 grid
for i in range(3):
for j in range(3):
self.board.append(
Cell(self.cellWidth * i, self.cellHeight * j, self.cellWidth, self.cellHeight))
self.manager.gameState = 'progress'
self.running = True
def startGame():
'''Start the game.'''
print "The computer makes the first step"
ai = Ai()
started = True
ai.play()
print "The board now looks like this:"
printBoard(convert(status))
def get_move():
fen_str = request.args.get('fen')
print(fen_str)
if fen_str is None:
return "Provide fen"
ai = Ai()
value, move = ai.get_move(fen_str=fen_str)
return move
def index():
rawData = request.get_json()
if rawData:
fetch = [block for block in rawData['boardInfo']['blocks']]
blocks = sorted(fetch, key=lambda k: k['x'])
ai = Ai(blocks, rawData['side'])
#logging.debug('EXPECT:' + str(ai.expect_score))
move = ai.get_move_score()
#logging.debug('MOVE:' + str(move))
keep = ai.get_keep_score()
#logging.debug('KEEP:' + str(keep))
flip = ai.get_flip_score()
#logging.debug('FLIP:' + str(flip))
collector = {'move': move, 'keep': keep, 'flip': flip}
scores = {
'move': move['score'],
'keep': keep['score'],
'flip': flip['score']
}
action = max(scores, key=scores.get)
if action == 'keep':
scores.pop('keep')
action = max(scores, key=scores.get)
result = collector[action]
logging.error(
str({
'EXPECT': ai.expect_score,
'MOVE': move,
'KEEP': keep,
'FLIP': flip,
'RESULT': result,
'DETAIL': {
'move': move['detail'],
'keep': keep['detail'],
'flip': flip['detail']
}
}))
if result['action'] == 'move':
return jsonify({
'pid': result['from']['id'],
'type': 'move',
'x': result['block']['x'],
'y': result['block']['y']
})
elif result['action'] == 'flip':
return jsonify({
'pid': result['block']['id'],
'type': 'flip',
'x': None,
'y': None
})
else:
# TODO
return jsonify({'pid': None, 'type': 'keep', 'x': None, 'y': None})
def runAI_1(self, weights, limitPiece):
key_actions1 = {
'ESCAPE': self.quit,
'LEFT': lambda: self.move(-1),
'RIGHT': lambda: self.move(+1),
'DOWN': lambda: self.drop(True),
'UP': self.rotate_stone,
'p': self.toggle_pause,
'SPACE': self.start_game,
'RETURN': self.insta_drop
}
key_actions2 = {
'ESCAPE': self.quit,
'a': lambda: self.move(-1),
'd': lambda: self.move(+1),
's': lambda: self.drop(True),
'w': self.rotate_stone,
'p': self.toggle_pause,
'SPACE': self.start_game,
'LSHIFT': self.insta_drop
}
self.gameover = False
self.paused = False
#slow it down
pygame.time.set_timer(pygame.USEREVENT + 1, 750)
dont_burn_my_cpu = pygame.time.Clock()
while 1:
if (self.nbPiece >= limitPiece
and limitPiece > 0) or (self.moves_left <= 0):
self.gameover = True
if self.playWithUI:
self.gui.update(self)
if self.gameover:
return self.lines * 1000 + self.nbPiece
if not self.computed:
self.computed = True
Ai.choose(self.board, self.stone, self.next_stone,
self.stone_x, weights, self)
if self.playWithUI:
for event in pygame.event.get():
if event.type == pygame.USEREVENT + 1:
self.drop(True)
elif event.type == pygame.QUIT:
self.quit()
elif event.type == pygame.KEYDOWN:
if self.player == 1:
if event.key == eval("pygame.K_p"):
self.toggle_pause()
elif self.player == 2:
for key in key_actions2:
if event.key == eval("pygame.K_" + key):
key_actions2[key]()
def init_players(self):
self.bot = Ai(self.choices[randint(0,1)]);
self.player = "X" if self.bot.choice == "O" else "O"
if randint(0,1) == 1:
self.bot.make_move(self.board, self.winning_combos)
greeting = "Hello Player! Bot plays first! You are playing with \"" + self.player + "\""
else:
greeting = "Hello Player! You are playing with \"" + self.player + "\""
self.popup_message(greeting)
class Connect4():
def __init__(self):
self.game_board = board.Board()
self.moves = self.game_board.moves
self.player1 = Ai(self.moves)
self.player2 = Ai(self.moves)
def test(self, input_values):
def mock_input(s):
print(s)
return input_values.pop(0)
human.input = mock_input
def start(self):
self.players()
player = 2
not_over = True
turn = 1
while not_over and turn <= 42:
if player == 1:
player = 2
self.game_board.make_move(2, self.player2.move())
else:
player = 1
self.game_board.make_move(1, self.player1.move())
self.show_board()
not_over = not self.gameover()
turn += 1
if not_over == True:
print("It's a Draw!")
else:
self.show_board()
print(f'Player {player} wins')
def show_board(self):
string = ""
i = len(self.game_board.game_board) - 1
while i > -1:
row = self.game_board.game_board[i]
for token in row:
string += f'|{token}|'
string += "\n"
i -= 1
print(string)
def gameover(self):
return self.game_board.moves.check_win()
def players(self):
if input("Player 1 is a Human or AI?") == "Human":
self.player1 = human.Human(self.moves)
if input("Player 2 is a Human or AI?") == "Human":
self.player2 = human.Human(self.moves)
return
def __init__(self, root):
self.__root = root
self.__board = Board(root)
self.__bag = Bag()
self.__human = Human(root)
self.__ai = Ai(root, self.__board, self.__bag)
self.__turn = 1
self.__player = self.__human
self.__human_score = StringVar()
self.__ai_score = StringVar()
def predict():
# Getting the data transmitted in a JSON by the POST request
parameters = request.get_json(force=True)
# Creating the AI
ai = Ai()
# Checking if the POST request was made from Postman
if str(parameters['image'])[0] == '/':
predicted_value: int = ai.predict(parameters['image'], True)
else:
# Collecting image from JSON
picture_request = str(parameters['image'])
starter = picture_request.find(',')
image_data = picture_request[starter + 1:]
image_data = bytes(image_data, encoding="ascii")
# The image has been transferred encoded in base64 model, the line just below decode it and create an image form it
with open('./assets/image.jpeg', 'wb') as fh:
fh.write(base64.decodebytes(image_data))
# Launching the prediction
predicted_value: int = ai.predict("./assets/image.jpeg", True)
# Creating the data for the JSON file to be returned
data_set = {
"image": {
"name": parameters['image'],
"reshaped size": "28*28",
"color scale": "grey scale"
},
"Multi-Layers Perceptron spec": {
"hidden_layer_sizes": "(200,)",
"activation": "logistic",
"alpha": "1e-4",
"solver": "sgd",
"tol": "1e-4",
"random_state": 2,
"max_iter": 200,
"learning_rate_init": .0001,
"verbose": "True"
},
"ML algorithm score on NMIST digits": {
"time": "0:05:53",
"accuracy score on training data": "0.960970871012443"
},
"Predicted value": predicted_value
}
# Creating the JSON
json_to_be_returned = json.dumps(data_set)
# Returning the JSON
return json_to_be_returned
def define_contestants(self):
# prompts user to pick a human or ai opponent
self.opening_statement()
opponent = input("\nPress 1 to play against a Human or type anything else to play against an AI"
"\n >")
if opponent == '1':
self.player_one = Human()
self.player_two = Human()
else:
self.player_one = Human()
self.player_two = Ai()
def action(self, ai: ai.Ai, radblock: randomwall.Radblock,
beans: randomwall.Beans, wall: randomwall.Wall):
self.__move(ai.points, wall.points1, radblock.points2)
if self.__point == beans.point3:
ai.exchange = 1
radblock.init_points(ai.points, self.__point)
beans.quickly_move(ai.points, radblock.points2, self.__point)
def main():
pb = PiecesBank()
app = UI()
### DO NOT F*****G REMOVE THIS. I DARE YOU. ###
app.preloadPieces(pb.pieceslist)
ai = Ai()
arbiter = Arbiter()
board = Board()
app.setBatchMethod(lambda loop, fitness, mutation: ai.main_function(
pb, app, arbiter, board, loop, fitness, mutation))
# app.drawTable(board)
app.drawTable(generatedSolvedPuzzle(pb))
### DO NOT F*****G REMOVE THIS EITHER. ###
app.mainloop()
def test_can_not_place_in_a_full_collum():
class Moves():
def __init__(self):
self.legal_moves = [
"Full", [1, 0], [2, 0], [3, 0], [4, 0], [5, 0], [6, 0]
]
move_array = [0, 1]
def mock_move():
return move_array.pop(0)
computer = Ai(Moves())
computer.select_move = mock_move
i = 0
assert computer.move() == 1
def __init__(self, parent=None):
QtGui.QWidget.__init__(self,parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.view = BoardView(self.ui.graphicsView)
self.opponent = Ai()
#event bindings
QtCore.QObject.connect(self.ui.newGameButton,QtCore.SIGNAL("clicked()"),self.newGame)
def __init__(self, rows=None, cols=None):
self.rows = rows or 6
self.cols = cols or 7
self.board = Board(self.rows, self.cols)
player = input("Player 1 human or cpu?(h/c)")
if player == 'h':
self.players.append(Player("O"))
else:
self.players.append(Ai("O", 4))
player = input("Player 2 human or cpu?(h/c)")
if player == 'h':
self.players.append(Player("X"))
else:
self.players.append(Ai("X", 4))
self.currentTurn = self.players[0]
def initGame():
global MINE_LEFT
mines = initMines()
numbers = initNumbers(mines)
marked = initMarked()
revealed = initRevealed()
ai = Ai(mines, revealed, marked, numbers, TILE_H_NUMBER, TILE_V_NUMBER,
MINE_COUNT)
MINE_LEFT = MINE_COUNT
return mines, numbers, revealed, marked, ai
def test():
newB = B()
newS = s(newB)
newAi = AI(newB, newS)
newS.move(0, 0, 1)
assert newB.get_b(0, 0) == 1
count = 0
for i in range(6):
for j in range(6):
if newB.get_b(i, j) == 1:
count += 1
assert count == 1
newS.move(0, 1, 1)
newS.move(0, 2, 1)
newS.move(0, 3, 1)
assert newS.Order_won() == False
newS.move(0, 4, 1)
assert newS.Order_won() == True
assert newAi.free_moves() == 6 * 6 - 5
def start():
g = Game()
try:
choice2 = (int(input("Write 1 to reload or 0 to have a new game:")))
if choice2 == 1:
g.service.read_file()
elif choice2 != 0:
print("Wrong number!")
except Exception as e:
print(e)
print(g)
ai = Ai(g.board, g.service)
while True:
try:
g.input()
if g.service.Order_won() == True:
raise ex.HumanWon("Order has Won!!!")
ai.random_move()
if g.service.Order_won() == True:
raise ex.HumanWon("Order has Won!!!")
print(g)
ai.free_moves()
except ex.HumanWon as e:
print(e)
break
except Exception as e:
print(e)
def __init__(self,tablero,jugador1,jugador2,con_jugadas_posibles=True,nivel=Ai.FACIL, write_path=""):
#self.__gui = Gui()
#self.__tablero = self.__gui.init_board().get_board()
self.__tablero_g = tablero
self.__tablero = tablero.get_logical_board()
#Iniciliazo la inteligencia para la PC
self.__pc = Ai(nivel)
#Inicializo un vector de jugadores
self.__jugadores = [jugador1,jugador2]
self.__ganador = ""
self.__nro_turno = 0
self.__termino_juego = False
self.__juego_mesh = False
self.__con_jugadas_posibles = con_jugadas_posibles
self.__lista_jugadas_posibles = []
if write_path != "":
#Imprimo en el log la configuracion del juego que se inicia
try:
f = open(os.path.abspath(write_path + "/data/game.log"),'r')
f.close()
self.__log_file = open(os.path.abspath(write_path + "/data/game.log"),'a')
print >> self.__log_file, '\nGAME LOG: ' + time.asctime()
except:
self.__log_file = open(os.path.abspath(write_path + "/data/game.log"),'w')
print >> self.__log_file, 'GAME LOG: ' + time.asctime()
print >> self.__log_file, 'Tablero: ' + str(self.__tablero.get_dimension()) + 'x' + str(self.__tablero.get_dimension())
if jugador1.get_color() == board.BLANCO and jugador1.get_name() == PC:
print >> self.__log_file, 'PC: Blanco'
print >> self.__log_file, 'Jugador: Negro'
elif jugador1.get_name() == HUMANO and jugador2.get_name() == HUMANO:
if jugador1.get_color() == board.BLANCO:
print >> self.__log_file, 'Jugador1: Blanco'
print >> self.__log_file, 'Jugador2: Negro'
else:
print >> self.__log_file, 'Jugador1: Negro'
print >> self.__log_file, 'Jugador2: Blanco'
else:
print >> self.__log_file, 'PC: Negro'
print >> self.__log_file, 'Jugador: Blanco'
def __init__(self, root, parent, port, ip=None):
self.game_obj = Game()
self._ai_mode = False
print('parent:', parent)
print('port:', port)
"""
Initializes the GUI and connects the communicator.
:param parent: the tkinter root.
:param ip: the ip to connect to.
:param port: the port to connect to.
:param server: true if the communicator is a server, otherwise false.
"""
self._root = root
self._parent = parent
self.__communicator = Communicator(root, port, ip)
self.__communicator.connect()
self.__communicator.bind_action_to_message(self.__handle_message)
self.__place_widgets()
#self.frame = t.Frame(self._parent, width=800, height=800)
self._canvas = t.Canvas(root, width=700, height=600, bg='blue')
self._grid = t.Grid()
#self.frame.pack()
self._canvas.pack()
self._create_circle()
if parent == 'ai':
self.ai_obj = Ai()
self._ai_mode = True
if (server == True and self.game_obj.get_current_player()
== 0) or (server == False
and self.game_obj.get_current_player() == 1):
self.ai_move()
else:
self._canvas.bind("<Button-1>", self.callback)
def __init__(self, players, board_length, board_height, goal, gravity,
depth, win):
self.players = players
self.board_length = board_length
self.board_height = board_height
self.goal = goal
self.gravity = gravity
self.win = win
self.win_size = win.get_size()
self.tile_length = int(self.win_size[0] * 0.9 / board_length)
self.tile_height = int(self.win_size[1] * 0.9 / board_height)
self.length_offset = int(self.win_size[0] * 0.05)
self.height_offset = int(self.win_size[1] * 0.05)
self.game_board = self.get_game_board()
self.event = None
self.turn = 0
self.winner = None
self.ai = Ai(self.game_board, gravity, goal, players, depth)
def MainMenu(self):
userInput = input(
"Press 1 for Human vs AI, Press 2 for Human vs Human")
if userInput != '1' and userInput != '2':
self.MainMenu()
if userInput == "1":
self.p1 = Human("P1")
self.p2 = Ai("P2", random)
#console clear
self.PlayGame()
else:
self.p1 = Human("P1")
self.p2 = Human("P2")
#console clear
self.PlayGame()
def run():
pygame.init()
screen = pygame.display.set_mode(Settings.resolution)
pygame.display.set_caption('Snake')
generate_all_positions(screen)
wall = Wall(screen)
snake = Snake(screen)
food = Food(screen, snake)
ai = Ai(screen, snake, food)
Settings.ai = ai
Settings.ai.get_shortest_path(food.rect.x, food.rect.y)
Settings.ai.set_new_path()
while True:
check_events(screen, snake)
update(screen, snake, food, ai, wall)
time.sleep(0.01)
def create_player(self):
"""P1 is blue, P2 is Yellow, P3 is Red, P4 is Green, P5 is Purple."""
color_idx = len(constants.COLORS) - 1
for i in range(self.humans):
x, y = self.get_random_coord()
self.players.append(
Player("P" + str(i + 1), x, y, constants.COLORS[color_idx]))
color_idx -= 1
for i in range(self.bots):
x, y = self.get_random_coord()
self.players.append(
Ai(
"COM" + str(i + 1),
x,
y,
constants.COLORS[color_idx],
self.difficulty,
))
color_idx -= 1
def __init__(self, tablero, jugador1, jugador2, con_jugadas_posibles=True, nivel=Ai.FACIL, write_path=""):
# self.__gui = Gui()
# self.__tablero = self.__gui.init_board().get_board()
self.__tablero_g = tablero
self.__tablero = tablero.get_logical_board()
# Iniciliazo la inteligencia para la PC
self.__pc = Ai(nivel)
# Inicializo un vector de jugadores
self.__jugadores = [jugador1, jugador2]
self.__ganador = ""
self.__nro_turno = 0
self.__termino_juego = False
self.__juego_mesh = False
self.__con_jugadas_posibles = con_jugadas_posibles
self.__lista_jugadas_posibles = []
if write_path != "":
# Imprimo en el log la configuracion del juego que se inicia
try:
f = open(os.path.abspath(write_path + "/data/game.log"), "r")
f.close()
self.__log_file = open(os.path.abspath(write_path + "/data/game.log"), "a")
print >> self.__log_file, "\nGAME LOG: " + time.asctime()
except:
self.__log_file = open(os.path.abspath(write_path + "/data/game.log"), "w")
print >> self.__log_file, "GAME LOG: " + time.asctime()
print >> self.__log_file, "Tablero: " + str(self.__tablero.get_dimension()) + "x" + str(
self.__tablero.get_dimension()
)
if jugador1.get_color() == board.BLANCO and jugador1.get_name() == PC:
print >> self.__log_file, "PC: Blanco"
print >> self.__log_file, "Jugador: Negro"
elif jugador1.get_name() == HUMANO and jugador2.get_name() == HUMANO:
if jugador1.get_color() == board.BLANCO:
print >> self.__log_file, "Jugador1: Blanco"
print >> self.__log_file, "Jugador2: Negro"
else:
print >> self.__log_file, "Jugador1: Negro"
print >> self.__log_file, "Jugador2: Blanco"
else:
print >> self.__log_file, "PC: Negro"
print >> self.__log_file, "Jugador: Blanco"
def computer_v_computer(current_state, player1, player2):
game_over = False
while game_over is False:
Ui.msg(BoardPresenter.display_terminal_board(current_state))
computers_move = Ai.make_move(current_state)
BoardState.update_state(current_state, User.current_player,
computers_move)
if EndStates.did_a_player_win(current_state, User.current_player,
win_config.winning_combos):
Ui.msg(BoardPresenter.display_terminal_board(current_state))
Ui.msg('Game Over: ' + User.current_player + ' WINS!')
return True
if EndStates.is_draw(current_state):
Ui.msg('DRAW. GameOver')
return True
if User.current_player == player1:
User.switch_current_user(User.current_player, player2)
else:
User.switch_current_user(User.current_player, player1)
def human_v_computer(current_state, player1, player2):
game_over = False
while game_over is False:
if User.current_player == player2:
Ui.msg("Computer has moved")
computers_move = Ai.make_move(current_state)
BoardState.update_state(current_state, User.current_player,
computers_move)
if User.current_player == player1:
User.switch_current_user(User.current_player, player2)
User.switch_current_user(User.current_player, player1)
else:
response = False
while response is False:
Ui.msg(
BoardPresenter.display_terminal_board(current_state))
response = CommandLinePrompt.get_input(
"Enter a number from 1-9: ")
response = UserActions.make_move(current_state, response)
BoardState.update_state(current_state, User.current_player,
response)
if EndStates.did_a_player_win(current_state,
User.current_player,
win_config.winning_combos):
Ui.msg(
BoardPresenter.display_terminal_board(current_state))
Ui.msg('Game Over: ' + User.current_player + ' WINS!')
return True
if EndStates.is_draw(current_state):
Ui.msg('DRAW. GameOver')
return True
if User.current_player == player1:
User.switch_current_user(User.current_player, player2)
else:
User.switch_current_user(User.current_player, player1)
def post(self):
print("Test")
i = "input.jpg"
lan = "hi"
text, interface_lang, label_, arr_all = Core(i, lan)
find, aware, type_, certain_tag, awarness = Ai(interface_lang, label_)
img = cv.imread('p3/' + i)
for i in arr_all:
pts = np.array(i, np.int32)
pts = pts.reshape((-1, 1, 2))
cv.polylines(img, [pts], True, (0, 0, 255), 5)
cv.imwrite('static/test_img.jpg', img)
assign_cluster = 0
analysis = {
"regional_language": str(text),
"translated_text": str(interface_lang),
"cluster": assign_cluster,
"tags": label_,
"type": type_
}
print(analysis)
return jsonify(analysis)
class Game():
def __init__(self):
self.ai = Ai()
self.board = Board(9)
self.player = Player()
self.on_turn = self.player
def start(self):
in_progres = True
while in_progres:
if self.on_turn == self.player:
player_choice = self.player.ask_for_move(self.board)
try:
self.board.make_move(player_choice, self.player.symbol)
except ValueError:
return self.player.ask_for_move(self.board)
self.on_turn = self.ai
print(self.board.draw())
else:
print('Ai move:')
ai_move = self.ai.get_ai_move(self.board)
self.board.make_move(ai_move, self.ai.symbol)
self.on_turn = self.player
print(self.board.draw())
if self.board.check_winning(self.player.symbol):
print('Congrats, You win!!!')
break
elif self.board.check_winning(self.ai.symbol):
print('You are LOOOOOOOOOOSER :P')
break
elif self.board.is_full():
print('TIE')
in_progres = not self.board.is_full()
def loop(self, screen):
screen.blit(self.text, self.textRect)
screen.blit(self.text2, self.textRect2)
clock = pygame.time.Clock()
self.snake = Snake(self.display, -(Config['snake']['width']))
self.snake2 = Snake(self.display, (Config['snake']['width']))
apple = Apple(self.display)
ai = Ai()
x_change = Config['snake']['speed']
y_change = 0
x_change2 = -Config['snake']['speed']
y_change2 = 0
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT and x_change == 0:
x_change = -Config['snake']['speed']
y_change = 0
elif event.key == pygame.K_RIGHT and x_change == 0:
x_change = Config['snake']['speed']
y_change = 0
elif event.key == pygame.K_UP and y_change == 0:
x_change = 0
y_change = -Config['snake']['speed']
elif event.key == pygame.K_DOWN and y_change == 0:
x_change = 0
y_change = Config['snake']['speed']
if event.key == pygame.K_a and x_change2 == 0:
x_change2 = -Config['snake']['speed']
y_change2 = 0
elif event.key == pygame.K_d and x_change2 == 0:
x_change2 = Config['snake']['speed']
y_change2 = 0
elif event.key == pygame.K_w and y_change2 == 0:
x_change2 = 0
y_change2 = -Config['snake']['speed']
elif event.key == pygame.K_s and y_change2 == 0:
x_change2 = 0
y_change2 = Config['snake']['speed']
snake_rect = self.snake.draw(Config['colors']['blue'])
snake_rect2 = self.snake2.draw(Config['colors']['green'])
apple_rect = apple.draw()
ai.update(pos=(snake_rect[0], snake_rect[1]),
apple=(apple_rect[0], apple_rect[1]),
size=self.snake.max_size)
move = ai.action()
bumper_x = Config['game']['width'] - Config['game']['bumper_size']
bumper_y = Config['game']['height'] - Config['game']['bumper_size']
if apple_rect.colliderect(snake_rect):
apple.remove()
apple.randomize()
self.snake.eat()
elif apple_rect.colliderect(snake_rect2):
apple.remove()
apple.randomize()
self.snake2.eat()
snakehit = self.snake.hit(self.snake2.body, bumper_x, bumper_y)
snakehit2 = self.snake2.hit(self.snake.body, bumper_x, bumper_y)
if (snakehit or snakehit2):
if (snakehit and snakehit2):
print("Tie")
elif snakehit:
self.snake2.score += 1
self.player2score += 1
else:
self.snake.score += 1
self.player1score += 1
apple.remove()
# snake.remove()
self.map(screen)
self.loop(screen)
self.snake.move(x_change, y_change)
self.snake2.move(x_change2, y_change2)
pygame.display.update()
clock.tick(Config['game']['fps'])
class Game:
def __init__(self, tablero, jugador1, jugador2, con_jugadas_posibles=True, nivel=Ai.FACIL, write_path=""):
# self.__gui = Gui()
# self.__tablero = self.__gui.init_board().get_board()
self.__tablero_g = tablero
self.__tablero = tablero.get_logical_board()
# Iniciliazo la inteligencia para la PC
self.__pc = Ai(nivel)
# Inicializo un vector de jugadores
self.__jugadores = [jugador1, jugador2]
self.__ganador = ""
self.__nro_turno = 0
self.__termino_juego = False
self.__juego_mesh = False
self.__con_jugadas_posibles = con_jugadas_posibles
self.__lista_jugadas_posibles = []
if write_path != "":
# Imprimo en el log la configuracion del juego que se inicia
try:
f = open(os.path.abspath(write_path + "/data/game.log"), "r")
f.close()
self.__log_file = open(os.path.abspath(write_path + "/data/game.log"), "a")
print >> self.__log_file, "\nGAME LOG: " + time.asctime()
except:
self.__log_file = open(os.path.abspath(write_path + "/data/game.log"), "w")
print >> self.__log_file, "GAME LOG: " + time.asctime()
print >> self.__log_file, "Tablero: " + str(self.__tablero.get_dimension()) + "x" + str(
self.__tablero.get_dimension()
)
if jugador1.get_color() == board.BLANCO and jugador1.get_name() == PC:
print >> self.__log_file, "PC: Blanco"
print >> self.__log_file, "Jugador: Negro"
elif jugador1.get_name() == HUMANO and jugador2.get_name() == HUMANO:
if jugador1.get_color() == board.BLANCO:
print >> self.__log_file, "Jugador1: Blanco"
print >> self.__log_file, "Jugador2: Negro"
else:
print >> self.__log_file, "Jugador1: Negro"
print >> self.__log_file, "Jugador2: Blanco"
else:
print >> self.__log_file, "PC: Negro"
print >> self.__log_file, "Jugador: Blanco"
def __del__(self):
try:
self.__log_file.close()
except:
log.debug("Problemas al cerrar el descriptor de archivo. (Game Class)")
def get_game_log_file(self):
return self.__log_file
def get_turn(self):
return self.__jugadores[self.__turno]
def set_turn(self, jugador):
if jugador.equal(self.__jugadores[0]):
self.__turno = 0
elif jugador.equal(self.__jugadores[1]):
self.__turno = 1
else:
raise Exception("No se pudo asignar el turno, el jugador no existe! (Game Class)")
self.update_possible_moves()
def update_possible_moves(self):
self.__lista_jugadas_posibles = Referee.possibles_moves(self.get_turn().get_color(), self.__tablero)
def increase_turn_number(self):
self.__nro_turno += 1
def get_turn_number(self):
return self.__nro_turno
def __next_turn(self):
color = self.__jugadores[self.__turno].get_color()
# Veo si hay jugada posible para el turno siguiente, es decir si era Blanco para el Negro
if Referee.is_at_least_one_move(color * -1, self.__tablero):
return True
else:
return False
def with_possibles_moves(self):
return self.__con_jugadas_posibles
def change_turn(self):
# if self.__next_turn():
self.__turno = (self.__turno - 1) * -1
self.increase_turn_number()
# return True
# else:
# return False
def is_over(self):
if Referee.is_at_least_one_move(board.BLANCO, self.__tablero):
return False
elif Referee.is_at_least_one_move(board.NEGRO, self.__tablero):
return False
else:
return True
def init_next_turn(self):
pass
def __print_log(self, mensaje):
try:
print >> self.__log_file, mensaje
except:
print mensaje
def get_mesh_game(self):
return self.__juego_mesh
def set_mesh_game(self, valor):
self.__juego_mesh = valor
def play(self, coord="", audio="", marcador="", ventana="", extra=""):
pc_manual = False
if not self.is_over():
jugadas_posibles_real = len(self.__lista_jugadas_posibles)
self.__ultima_jugada_humano = ""
if jugadas_posibles_real > 0:
nombre_de_turno = self.get_turn().get_name()
color_de_turno = self.get_turn().get_color()
if nombre_de_turno == HUMANO or nombre_de_turno == VIRTUAL:
if coord == "":
coord = self.__tablero_g.get_coord_selected_cell()
if color_de_turno == board.BLANCO:
pudo_jugar = self.__tablero_g.set_piece(coord, color_de_turno, "blanco", audio, ventana)
sonido_voltear = "voltear_negro"
else:
pudo_jugar = self.__tablero_g.set_piece(coord, color_de_turno, "negro", audio, ventana)
sonido_voltear = "voltear_blanco"
if pudo_jugar:
marcador.render_numbers(self.__tablero, self.get_turn().get_color(), ventana)
self.__ultima_jugada_humano = coord
self.__print_log("JUGADOR jugo en: " + str(self.__ultima_jugada_humano))
if nombre_de_turno == VIRTUAL:
self.__tablero_g.set_coord_selected_cell(coord)
elif nombre_de_turno == PC:
if coord == "":
pudo_jugar = self.play_pc()
else:
pudo_jugar = self.__tablero_g.set_piece(coord, color_de_turno, "blanco", audio, ventana)
sonido_voltear = "voltear_negro"
pc_manual = True
if pudo_jugar:
if coord == "":
coord = self.get_last_pc_move()
self.__tablero_g.set_coord_selected_cell(coord)
if not pc_manual:
if color_de_turno == board.BLANCO:
pudo_jugar = self.__tablero_g.set_piece(coord, color_de_turno, "blanco", audio, ventana)
sonido_voltear = "voltear_negro"
else:
pudo_jugar = self.__tablero_g.set_piece(coord, color_de_turno, "negro", audio, ventana)
sonido_voltear = "voltear_blanco"
marcador.render_numbers(self.__tablero, self.get_turn().get_color(), ventana)
self.__print_log("PC jugo en: " + str(coord))
if pudo_jugar:
audio.wait_sound_end()
self.__tablero_g.do_line_animation(coord, color_de_turno, sonido_voltear, audio, marcador, ventana)
else:
pudo_jugar = True
audio.play_voice_sound("game", "pasa_el_turno")
audio.wait_sound_end()
# extra = {"play_turn_sound":False}
if pudo_jugar:
if not self.is_over():
self.change_turn()
self.update_possible_moves()
if self.__con_jugadas_posibles:
if extra == "" or (not extra == "" and not "update_possibles_moves" in extra):
self.__tablero_g.lista_jugadas = self.__lista_jugadas_posibles
if not extra == "":
if not "change_score_color" in extra:
marcador.render_all(self.__tablero, self.get_turn().get_color(), ventana)
if not "play_turn_sound" in extra:
audio.play_init_turn_sounds(self.__tablero_g, self)
else:
audio.play_init_turn_sounds(self.__tablero_g, self)
marcador.render_all(self.__tablero, self.get_turn().get_color(), ventana)
if self.__con_jugadas_posibles:
self.__tablero_g.render_list_possible_moves(ventana)
pygame.display.update()
else:
self.__lista_jugadas_posibles = []
if extra == "":
self.__termino_juego = True
marcador.render_all(self.__tablero, self.get_turn().get_color(), ventana)
pygame.display.update()
audio.play_end_game_sounds(self.__tablero_g, self)
else:
audio.play_end_game_sounds(self.__tablero_g, self)
self.__termino_juego = True
return pudo_jugar
def game_ended(self):
return self.__termino_juego
def play_pc(self):
return self.__make_a_move()
def __make_a_move(self):
if self.__pc.play(self.__tablero, self.__jugadores[self.__turno].get_color()):
self.__ultima_jugada_pc = self.__pc.get_last_move()
return True
else:
return False
def get_player_by_color(self, color=board.BLANCO):
for jugador in self.__jugadores:
if jugador.get_color() == color:
return jugador
def get_player_by_name(self, nombre=PC):
for jugador in self.__jugadores:
if jugador.get_name() == nombre:
return jugador
def get_final_result(self):
if self.__tablero.get_can_fichas_blancas() > self.__tablero.get_can_fichas_negras():
return self.get_player_by_color(board.BLANCO)
elif self.__tablero.get_can_fichas_blancas() < self.__tablero.get_can_fichas_negras():
return self.get_player_by_color(board.NEGRO)
else:
return ""
def get_last_pc_move(self):
return self.__ultima_jugada_pc
def get_last_human_move(self):
return self.__ultima_jugada_humano
def get_players(self):
""" Retorna un vector con los datos de los jugadores."""
jugador1 = self.__jugadores[0]
jugador2 = self.__jugadores[1]
return [
{"nombre": jugador1.get_name(), "color": jugador1.get_color()},
{"nombre": jugador2.get_name(), "color": jugador2.get_color()},
]
def get_board_configuration(self):
""" Retorna un diccionario con la configuracion actual del tablero."""
return {"dimension": self.__tablero.get_dimension(), "configuracion": self.__tablero.get_casillas()}
def get_board(self):
return self.__tablero
def shorcut_lose_game(self):
jug_humano = self.get_player_by_name(HUMANO)
if jug_humano.get_color() == board.BLANCO:
self.__tablero.set_can_fichas_blancas(0)
self.__tablero.set_can_fichas_negras(1)
else:
self.__tablero.set_can_fichas_blancas(1)
self.__tablero.set_can_fichas_negras(0)
def shorcut_win_game(self):
jug_humano = self.get_player_by_name(HUMANO)
if jug_humano.get_color() == board.BLANCO:
self.__tablero.set_can_fichas_blancas(1)
self.__tablero.set_can_fichas_negras(0)
else:
self.__tablero.set_can_fichas_blancas(0)
self.__tablero.set_can_fichas_negras(1)
def shorcut_draw_game(self):
self.__tablero.set_can_fichas_blancas(1)
self.__tablero.set_can_fichas_negras(1)
def get_list_possible_moves(self):
return self.__lista_jugadas_posibles
def __init__(self):
self.ai = Ai()
self.board = Board(9)
self.player = Player()
self.on_turn = self.player
