def __init__(self):
self.ref = Referee()
self.HOST, self.PORT, self.DEFPATH = self.fetch_config()
self.s = None
self.conn = self.create_connection()
self.default_player = StateProxy(self.setup_default_player())
self.remote_player = StateProxy(RemoteProxy(self.conn))
def __init__(self):
self.ref = Referee()
self.HOST, self.PORT, self.DEFPATH = self.fetch_config()
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# self.conn = self.create_connection()
# self.default_player = StateProxy(self.setup_default_player())
# self.remote_player = StateProxy(RemoteProxy(self.conn))
self.t_style, self.n_remote = self.fetch_tournament_details()
self.remote_connections = []
self.n_default = 0
self.player_map = {}
def main(args):
print "----- Parámetros -----"
print "columnas: \t", args.columns
print "filas: \t\t", args.rows
print "duración: \t\t", args.steps
print "----------------------"
assert len(args.quites_A) == 3
assert len(args.quites_B) == 3
if args.team_B is not None:
executable = args.team_B.pop(0)
team_B = PlayerCommunicator(executable, args.team_B, B, A)
else:
team_B = GeneticTeam(B, A, DEFAULT_GENOME)
if args.team_A is not None:
executable = args.team_A.pop(0)
team_A = PlayerCommunicator(executable, args.team_A, A, B)
else:
team_A = GeneticTeam(A, B, DEFAULT_GENOME)
ref = Referee(args.columns, args.rows, args.steps, team_A, team_B,
args.quites_A, args.quites_B)
if args.first == A:
ref.runPlay(A)
elif args.first == B:
ref.runPlay(B)
else:
ref.runPlay(choice([A, B]))
class Driver:
def __init__(self):
self.ref = Referee()
self.playerOne = StateProxy(Default())
self.playerTwo = StateProxy(Default())
def testOnInputs(self):
inputs = abstract_front_end()
output = []
if isinstance(inputs[0], str):
self.playerOne.register(inputs[0])
self.ref.playerOneName = inputs[0]
output.append(self.ref.playerOneStone)
if isinstance(inputs[1], str):
self.playerTwo.register(inputs[1])
self.ref.playerTwoName = inputs[1]
output.append(self.ref.playerTwoStone)
for i, move in enumerate(inputs[2:]):
output.append(copy.deepcopy(self.ref.boardHistory))
winner = self.ref.handleMove(move)
if winner:
output.append(winner)
break
# for i,n in enumerate(output):
# print(n)
# print('\n\n\n\n\n')
return json.dumps(output)
def main(args):
assert args.c <= args.columns and args.c <= args.rows
#print "----- Parámetros -----"
#print "columnas: \t", args.columns
#print "filas: \t\t", args.rows
#print "c: \t\t", args.c
#print "p: \t\t", args.p
#print "----------------------"
if args.blue_player is None:
blue_player = HumanPlayer(BLUE)
else:
executable = args.blue_player.pop(0)
blue_player = PlayerCommunicator(executable, args.blue_player, BLUE,
RED)
if args.red_player is None:
red_player = HumanPlayer(RED)
else:
executable = args.red_player.pop(0)
red_player = PlayerCommunicator(executable, args.red_player, RED, BLUE)
ref = Referee(args.columns,
args.rows,
args.c,
args.p,
blue_player,
red_player,
show_ui=args.ui)
iteration = 0
while args.iterations is None or args.iterations > iteration:
iteration += 1
if args.first == BLUE:
ref.runPlay(blue_player)
elif args.first == RED:
ref.runPlay(red_player)
else:
ref.runPlay(choice([blue_player, red_player]))
ref.exit()
class Admin:
def __init__(self):
self.ref = Referee()
self.HOST, self.PORT, self.DEFPATH = self.fetch_config()
self.s = None
self.conn = self.create_connection()
self.default_player = StateProxy(self.setup_default_player())
self.remote_player = StateProxy(RemoteProxy(self.conn))
def fetch_config(self):
json_string = FrontEnd().input_receiver('go.config')
python_obj = json.loads(json_string)
return python_obj["IP"], python_obj["port"], python_obj["default-player"]
def create_connection(self):
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.s.bind((self.HOST, self.PORT))
self.s.listen()
conn, _ = self.s.accept()
return conn
def game_start(self):
winner = self.ref.play_game(self.default_player, self.remote_player)
if winner:
return json.dumps(winner)
# self.conn.send(json.dumps(a).encode())
# self.conn.close()
def setup_default_player(self):
player_module = SourceFileLoader("Default", self.DEFPATH).load_module()
default_player = player_module.Default()
return default_player
def send_and_receive(self,json_data):
try:
if len(json_data) == 1 and json_data[0] == "register":
name = self.remote_player.register()
return name
elif len(json_data) == 2 and json_data[0] == "receive-stones":
stone = json_data[1]
GoBoard().stone_checker(stone)
self.remote_player.receive_stones(stone)
elif len(json_data) == 2 and json_data[0] == "make-a-move":
history = json_data[1]
for i,board in enumerate(history):
GoBoard().board_checker(board)
move = self.remote_player.make_a_move(history)
return move
else:
return "GO has gone crazy!"
except (ValueError,TypeError):
return "GO has gone crazy!"
def driver(self):
output_list = []
input = FrontEnd().getJson()
for i,json_data in enumerate(input):
output = self.send_and_receive(json_data)
if output and output != "GO has gone crazy!":
output_list.append(output)
elif output == "GO has gone crazy!":
output_list.append(output)
self.conn.close()
return json.dumps(output_list)
self.conn.close()
return json.dumps(output_list)
label = my_font.render(name, 1, (255, 200, 200))
Display.screen.blit(label, (new, 232))
def launch_game(self, sizeX, sizeY):
# Marge of the window
marge = 5
# Create IA Minmax
minmax = Minmax.Minmax(self.rule_5brk, self.rule_2b3, self.rule_capt)
# Create token list
token = [[case.Case(x, y, 0) for x in range(sizeX)]
for y in range(sizeY)]
# Create Referee
Judge = Referee.Referee(self.rule_5brk, self.rule_2b3, self.rule_capt)
# Create displayer
Display = Displayer.Displayer(sizeX, sizeY, self.skinsquare,
self.skinred, self.skinblue, self.md,
self.mu, self.w1, self.w2, self.wia,
self.skinblue_t, self.skinred_t, marge)
# Container for historic
self.histo = []
self.turn = 0
self.end = 0
Display.draw_background()
pygame.display.flip()
def __init__(self):
self.ref = Referee()
self.playerOne = StateProxy(Default())
self.playerTwo = StateProxy(Default())
Used for testing.
Add code here and run the game in gamemode "testing" to run this code.
"""
pass
if __name__ == "__main__":
#Check if terminal supports chess characters. Use lettering for characters if not.
use_symbols = True
try:
print(King().symbol, )
except UnicodeEncodeError:
use_symbols = False
referees = {
"fair": Referee(),
"0": CheatingReferee(cheating_player_id=0),
"1": CheatingReferee(cheating_player_id=1),
"laxx": LaxxReferee(),
}
player_types = {
"human": HumanPlayer,
"random": RandomPlayer,
}
game_modes = {
"pvp": pvp,
"debug": debug,
"testing": testing,
}
step_save = 10000
step_draw = 100
step_check_crossenropy = 100
k_filter = input_stack * 4
training_iters = 540002
seed = 23
ai=None
openfile = 520000
Data = DataCenter.MongoDB("Gamedata")
Cnn = Policy.PolicyNetwork(learning_rate, input_stack, k_filter,seed)
judge = Referee.referee()
def buttonClicked():
global color
global ai
global level
global openfile
if(radiobutton1.isChecked()):
color = 1
if(lvradiobutton1.isChecked()):
openfile = 100000
level = 1
elif(lvradiobutton2.isChecked()):
openfile = 520000
level = 2
if __name__ == "__main__":
run_event = threading.Event()
run_event.set()
communication = Communication()
communication.connect()
# ------------------------------------------------------
# Run the referee
main = Main(0, "Main", communication, run_event)
# ------------------------------------------------------
# Run the referee
referee = Referee(1, "Referee", "B", "B", main, run_event)
referee.connect()
main.start()
referee.start()
try:
while 1:
pass
except KeyboardInterrupt:
print "attempting to close threads"
run_event.clear()
print "run event cleared"
referee.join()
print "referee thread closed"
from Referee import * ''' print "StupidPlayer player game" Ref = Referee() Ref.add_player(StupidPlayer()) Ref.add_player(StupidPlayer()) Ref.play_game() print "random player game" Ref = Referee() Ref.add_player(RandomPlayer()) Ref.add_player(RandomPlayer()) Ref.play_game() print "SequencePlayer player game" Ref = Referee() Ref.add_player(SequencePlayer()) Ref.add_player(SequencePlayer()) Ref.play_game() ''' print "RandomPlayer vs machine learning game" Ref = Referee() Ref.add_player(MarkovPlayer()) Ref.add_player(RandomPlayer()) Ref.play_game()
from Referee import * ''' print "StupidPlayer player game" Ref = Referee() Ref.add_player(StupidPlayer()) Ref.add_player(StupidPlayer()) Ref.play_game() print "random player game" Ref = Referee() Ref.add_player(RandomPlayer()) Ref.add_player(RandomPlayer()) Ref.play_game() print "SequencePlayer player game" Ref = Referee() Ref.add_player(SequencePlayer()) Ref.add_player(SequencePlayer()) Ref.play_game() ''' print "RandomPlayer vs machine learning game" Ref = Referee() Ref.add_player(MarkovPlayer()) Ref.add_player(RandomPlayer()) Ref.play_game()
class Admin:
def __init__(self):
self.ref = Referee()
self.HOST, self.PORT, self.DEFPATH = self.fetch_config()
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# self.conn = self.create_connection()
# self.default_player = StateProxy(self.setup_default_player())
# self.remote_player = StateProxy(RemoteProxy(self.conn))
self.t_style, self.n_remote = self.fetch_tournament_details()
self.remote_connections = []
self.n_default = 0
self.player_map = {}
# Setup
@staticmethod
def fetch_config():
json_string = FrontEnd().input_receiver('go.config')
python_obj = json.loads(json_string)
return python_obj["IP"], python_obj["port"], python_obj[
"default-player"]
def bind_socket(self):
self.s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
print('Binding the Host:{} Port:{}'.format(self.HOST, str(self.PORT)))
self.s.bind((self.HOST, self.PORT))
self.s.listen(self.n_remote)
@staticmethod
def fetch_tournament_details(self):
if len(sys.argv) != 3:
raise Exception("Incorrect number of arguments")
_, style, n = sys.argv
if style not in ["--league", "--cup"] or not n.isnumeric():
raise Exception("Arguments are incorrect")
return style, int(n)
def accept_connections(self):
for c in self.remote_connections:
c.close()
del self.remote_connections[:]
for i in range(self.n_remote):
try:
conn, _ = self.s.accept()
self.remote_connections.append(conn)
print('Connection has been established')
except:
raise Exception("Error accepting connections")
def total_player_count(self):
i = 0
temp = 2**i if self.n_remote > 2 else 2
while temp < self.n_remote:
i += 1
temp = 2**i
return temp
def setup_default_player(self):
player_module = SourceFileLoader("Default", self.DEFPATH).load_module()
default_player = player_module.Default()
return default_player
def setup_player_map(self):
player_total = self.total_player_count()
self.n_default = player_total - self.n_remote
for i, conn in enumerate(self.remote_connections):
if not conn:
self.n_default += 1
self.n_remote -= 1
else:
remote = StateProxy(RemoteProxy(conn))
remote_name = remote.register() + str(i)
self.player_map[remote_name] = remote
if self.n_default > 0:
for i in range(self.n_default):
default = StateProxy(self.setup_default_player())
default_name = default.register() + str(i)
self.player_map[default_name] = default
# Game
# def create_connection(self):
# self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# self.s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# self.s.bind((self.HOST, self.PORT))
# self.s.listen()
# conn, _ = self.s.accept()
# return conn
def game_start(self):
winner = self.ref.play_game(self.default_player, self.remote_player)
if winner:
return json.dumps(winner)
# self.conn.send(json.dumps(a).encode())
# self.conn.close()
def send_and_receive(self, json_data):
try:
if len(json_data) == 1 and json_data[0] == "register":
name = self.remote_player.register()
return name
elif len(json_data) == 2 and json_data[0] == "receive-stones":
stone = json_data[1]
GoBoard().stone_checker(stone)
self.remote_player.receive_stones(stone)
elif len(json_data) == 2 and json_data[0] == "make-a-move":
history = json_data[1]
for i, board in enumerate(history):
GoBoard().board_checker(board)
move = self.remote_player.make_a_move(history)
return move
else:
return "GO has gone crazy!"
except (ValueError, TypeError):
return "GO has gone crazy!"
def driver(self):
output_list = []
input = FrontEnd().getJson()
for i, json_data in enumerate(input):
output = self.send_and_receive(json_data)
if output and output != "GO has gone crazy!":
output_list.append(output)
elif output == "GO has gone crazy!":
output_list.append(output)
self.conn.close()
return json.dumps(output_list)
self.conn.close()
return json.dumps(output_list)
