def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient("127.0.0.1", 31001)
self.token = "0000000000000000"
def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient("127.0.0.1", 31001)
self.token = "0000000000000000"
def test_defult_example():
remote_process_client = RemoteProcessClient('wgforge-srv.wargaming.net',
443)
assert remote_process_client.login("Test12345")[0] == 0
assert remote_process_client.move(Move(1, 1, 0))[0] == 0
assert remote_process_client.map(1)[0] == 0
assert remote_process_client.turn()[0] == 0
remote_process_client.logout()
remote_process_client.close()
def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(
sys.argv[1], int(sys.argv[2]))
self.name = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient(
'wgforge-srv.wargaming.net', 443)
self.name = "Mickey"
def __init__(self):
sleep(4)
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient("localhost", 31001)
self.token = "0000000000000000"
#next line enables my custom debugger window
debuggerEnabled = True
def __init__(self, codeballRunner, port=31001, team=1):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(
sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient(
"127.0.0.1", port)
self.token = "0000000000000000"
self.manager = codeballRunner
self.team = team
def __init__(self):
self.reload = True
self.freeze = False
self.debug_client = DebugClient()
self.input_event = EventEmitter()
self.strategies = []
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(
sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient(
"127.0.0.1", 31001)
self.token = "0000000000000000"
class Runner:
def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(
sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient(
"127.0.0.1", 31000)
self.token = "0000000000000000"
def run(self):
try:
self.remote_process_client.write_token(self.token)
team_size = self.remote_process_client.read_team_size()
strategies = []
tank_types = []
for strategy_index in xrange(team_size):
strategy = MyStrategy()
strategies.append(strategy)
tank_types.append(
strategy.select_tank(strategy_index, team_size))
self.remote_process_client.write_selected_tanks(tank_types)
while True:
player_context = self.remote_process_client.read_player_context(
)
if player_context is None:
break
player_tanks = player_context.tanks
if player_tanks.__len__() != team_size:
break
moves = []
for strategy_index in xrange(team_size):
move = Move()
moves.append(move)
strategies[strategy_index].move(
player_tanks[strategy_index], player_context.world,
move)
self.remote_process_client.write_moves(moves)
finally:
self.remote_process_client.close()
def test_login():
remote_process_client = RemoteProcessClient('wgforge-srv.wargaming.net',
443)
try:
remote_process_client.write_message('LOGIN', {"name": "Test_Conway"})
finally:
remote_process_client.write_message('LOGOUT')
remote_process_client.close()
def test_defult_actions():
try:
remote_process_client = RemoteProcessClient(
'wgforge-srv.wargaming.net', 443)
assert remote_process_client.login("Test12345")
assert remote_process_client.map(1)[0] == 0
assert remote_process_client.map(0)[0] == 0
assert remote_process_client.turn()[0] == 0
finally:
remote_process_client.logout()
remote_process_client.close()
def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
for _ in xrange(20):
try:
self.remote_process_client = RemoteProcessClient("127.0.0.1", 31001)
except socket.error as ex:
if ex.errno == ERRNO_REFUSED:
time.sleep(0.1)
continue
raise
else:
break
self.token = "0000000000000000"
def __init__(self, name="Mickey"):
self.player = None
self.map_graph = None
self.objects = None
self.is_gui = True
self.multi = False
self.name = name
if len(sys.argv) >= 2:
if '-gui' in sys.argv:
self.is_gui = True
if '-m' in sys.argv:
self.multi = True
self.name = input("Name:")
self.game = input("Game name:")
self.num_players = int(input("Num of players:"))
self.process_client = RemoteProcessClient('wgforge-srv.wargaming.net',
443)
def test_write_message():
remote_process_client = RemoteProcessClient('wgforge-srv.wargaming.net',
443)
assert remote_process_client.write_message('LOGIN',
{"name": "Test_Conway"})[0] == 0
remote_process_client.write_message('LOGOUT')
remote_process_client.close()
class Runner:
def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient("localhost", 31000)
self.token = "0000000000000000"
def run(self):
try:
self.remote_process_client.write_token(self.token)
team_size = self.remote_process_client.read_team_size()
strategies = []
tank_types = []
for strategy_index in xrange(team_size):
strategy = MyStrategy()
strategies.append(strategy)
tank_types.append(strategy.select_tank(strategy_index, team_size))
self.remote_process_client.write_selected_tanks(tank_types)
while True:
player_context = self.remote_process_client.read_player_context()
if player_context is None:
break
player_tanks = player_context.tanks
if player_tanks.__len__() != team_size:
break
moves = []
for strategy_index in xrange(team_size):
move = Move()
moves.append(move)
strategies[strategy_index].move(player_tanks[strategy_index], player_context.world, move)
self.remote_process_client.write_moves(moves)
finally:
self.remote_process_client.close()
class Runner:
def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(
sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient(
"127.0.0.1", 31001)
self.token = "0000000000000000"
def run(self):
strategy = MyStrategy()
self.remote_process_client.write_token(self.token)
rules = self.remote_process_client.read_rules()
while True:
game = self.remote_process_client.read_game()
if game is None:
break
actions = {}
for robot in game.robots:
if robot.is_teammate:
action = Action()
strategy.act(robot, rules, game, action)
actions[robot.id] = action
self.remote_process_client.write(actions,
strategy.custom_rendering())
class Runner:
def __init__(self):
sleep(4)
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient("localhost", 31001)
self.token = "0000000000000000"
#next line enables my custom debugger window
debuggerEnabled = True
def run(self):
try:
self.remote_process_client.write_token(self.token)
team_size = self.remote_process_client.read_team_size()
self.remote_process_client.write_protocol_version()
game = self.remote_process_client.read_game_context()
strategies = []
for strategy_index in xrange(team_size):
strategies.append(MyStrategy())
while True:
player_context = self.remote_process_client.read_player_context()
if player_context is None:
break
player_trooper = player_context.trooper
move = Move()
strategies[player_trooper.teammate_index].move(player_trooper, player_context.world, game, move)
self.remote_process_client.write_move(move)
finally:
self.remote_process_client.close()
class Runner:
def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient("127.0.0.1", 31001)
self.token = "0000000000000000"
def run(self):
try:
self.remote_process_client.write_token_message(self.token)
team_size = self.remote_process_client.read_team_size_message()
self.remote_process_client.write_protocol_version_message()
game = self.remote_process_client.read_game_context_message()
strategies = []
for strategy_index in xrange(team_size):
strategies.append(MyStrategy())
while True:
player_context = self.remote_process_client.read_player_context_message()
if player_context is None:
break
player_hockeyists = player_context.hockeyists
if player_hockeyists is None or player_hockeyists.__len__() != team_size:
break
moves = []
for hockeyist_index in xrange(team_size):
player_hockeyist = player_hockeyists[hockeyist_index]
move = Move()
moves.append(move)
strategies[player_hockeyist.teammate_index].move(player_hockeyist, player_context.world, game, move)
self.remote_process_client.write_moves_message(moves)
finally:
self.remote_process_client.close()
class Runner:
def __init__(self):
self.reload = True
self.freeze = False
self.debug_client = DebugClient()
self.input_event = EventEmitter()
self.strategies = []
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(
sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient(
"127.0.0.1", 31001)
self.token = "0000000000000000"
def run(self):
try:
self.remote_process_client.write_token_message(self.token)
self.remote_process_client.write_protocol_version_message()
team_size = self.remote_process_client.read_team_size_message()
game = self.remote_process_client.read_game_context_message()
self.strategies = []
self.start_input()
world_time = 0
while True:
while self.freeze:
time.sleep(0.5)
if self.reload:
print(f'actually reloading at {world_time}')
for module in [
x for x in sys.modules if x.startswith('aicup2016')
]:
del sys.modules[module]
from aicup2016.strategy import Strategy
self.strategies = []
for _ in range(team_size):
self.strategies.append(
Strategy(debug_client=self.debug_client,
input_event=self.input_event))
self.reload = False
player_context = self.remote_process_client.read_player_context_message(
)
if player_context is None:
break
world_time = player_context.world.tick_index
player_wizards = player_context.wizards
if player_wizards is None or player_wizards.__len__(
) != team_size:
break
moves = []
for wizard_index in range(team_size):
player_wizard = player_wizards[wizard_index]
move = Move()
moves.append(move)
self.strategies[wizard_index].move(player_wizard,
player_context.world,
game, move)
self.remote_process_client.write_moves_message(moves)
finally:
self.remote_process_client.close()
def start_input(self):
Thread(target=self.worker, daemon=False).start()
def worker(self):
while True:
self.handle_input(input())
def handle_input(self, input):
if input == 'r':
self.reload = True
print('reloading')
elif input == 'p':
self.freeze = not self.freeze
print('pause')
else:
self.input_event.emit(input)
class Runner:
def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(
sys.argv[1], int(sys.argv[2]))
self.name = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient(
'wgforge-srv.wargaming.net', 443)
self.name = "Mickey"
def run(self):
status, start_data = self.remote_process_client.login(self.name)
try:
map_graph = self.remote_process_client.read_map()
objects = self.remote_process_client.read_objects()
strategy = Strategy(start_data)
while strategy.in_progress:
self.remote_process_client.update_objects(objects)
moves = strategy.get_moves(objects, map_graph)
if moves:
for move in moves:
self.remote_process_client.move(move)
self.remote_process_client.turn()
finally:
self.remote_process_client.logout()
self.remote_process_client.close()
class Runner:
def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(
sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient(
"127.0.0.1", 31001)
self.token = "0000000000000000"
def run(self):
try:
self.remote_process_client.write_token_message(self.token)
team_size = self.remote_process_client.read_team_size_message()
self.remote_process_client.write_protocol_version_message()
game = self.remote_process_client.read_game_context_message()
strategies = []
for _ in xrange(team_size):
strategies.append(MyStrategy())
while True:
player_context = self.remote_process_client.read_player_context_message(
)
if player_context is None:
break
player_cars = player_context.cars
if player_cars is None or player_cars.__len__() != team_size:
break
moves = []
for car_index in xrange(team_size):
player_car = player_cars[car_index]
move = Move()
moves.append(move)
strategies[player_car.teammate_index].move(
player_car, player_context.world, game, move)
self.remote_process_client.write_moves_message(moves)
finally:
self.remote_process_client.close()
class Runner:
def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
for _ in xrange(20):
try:
self.remote_process_client = RemoteProcessClient("127.0.0.1", 31001)
except socket.error as ex:
if ex.errno == ERRNO_REFUSED:
time.sleep(0.1)
continue
raise
else:
break
self.token = "0000000000000000"
def run(self):
try:
self.remote_process_client.write_token_message(self.token)
team_size = self.remote_process_client.read_team_size_message()
self.remote_process_client.write_protocol_version_message()
game = self.remote_process_client.read_game_context_message()
strategies = []
for _ in xrange(team_size):
strategies.append(MyStrategy())
while True:
player_context = self.remote_process_client.read_player_context_message()
if player_context is None:
break
player_cars = player_context.cars
if player_cars is None or player_cars.__len__() != team_size:
break
moves = []
for car_index in xrange(team_size):
player_car = player_cars[car_index]
move = Move()
moves.append(move)
strategies[player_car.teammate_index].move(player_car, player_context.world, game, move)
self.remote_process_client.write_moves_message(moves)
except socket.error as ex:
if ex.errno != ERRNO_RESET:
raise
except KeyboardInterrupt:
pass
finally:
self.remote_process_client.close()
class Runner:
def __init__(self):
if sys.argv.__len__() == 4:
self.remote_process_client = RemoteProcessClient(sys.argv[1], int(sys.argv[2]))
self.token = sys.argv[3]
else:
self.remote_process_client = RemoteProcessClient("127.0.0.1", 31001)
self.token = "0000000000000000"
def run(self):
try:
self.remote_process_client.write_token_message(self.token)
self.remote_process_client.write_protocol_version_message()
self.remote_process_client.read_team_size_message()
game = self.remote_process_client.read_game_context_message()
strategy = MyStrategy()
while True:
player_context = self.remote_process_client.read_player_context_message()
if player_context is None:
break
player = player_context.player
if player is None:
break
move = Move()
strategy.move(player, player_context.world, game, move)
self.remote_process_client.write_move_message(move)
finally:
self.remote_process_client.close()
def test_speed():
try:
process_client = RemoteProcessClient('wgforge-srv.wargaming.net', 443)
player = process_client.login("Test12345")
map_graph = process_client.read_map()
map_graph.pos = dict(
[(cord['idx'], (cord['x'] / 200, cord['y'] / 200))
for cord in process_client.read_position()["coordinate"]])
objects = process_client.read_objects()
process_client.update_objects(objects, map_graph, player)
process_client.move(Move(1, 1, 1))
process_client.turn()
process_client.turn()
process_client.update_objects(objects, map_graph, player)
train = objects.trains[1]
print(" pos - ", train.position, " speed - ", train.speed)
process_client.move(Move(1, 0, 1))
process_client.move(Move(1, -1, 1))
process_client.turn()
process_client.update_objects(objects, map_graph, player)
print(" pos - ", train.position, " speed - ", train.speed)
finally:
process_client.logout()
process_client.close()
from RemoteProcessClient import RemoteProcessClient
remote_process_client = RemoteProcessClient('wgforge-srv.wargaming.net', 443)
player = remote_process_client.write_message('LOGIN', {"name": "qwert"})
remote_process_client.logout()
remote_process_client.close()
class Runner:
def __init__(self, name="Mickey"):
self.player = None
self.map_graph = None
self.objects = None
self.is_gui = True
self.multi = False
self.name = name
if len(sys.argv) >= 2:
if '-gui' in sys.argv:
self.is_gui = True
if '-m' in sys.argv:
self.multi = True
self.name = input("Name:")
self.game = input("Game name:")
self.num_players = int(input("Num of players:"))
self.process_client = RemoteProcessClient('wgforge-srv.wargaming.net',
443)
def run(self):
try:
try:
if self.multi == False:
self.player = self.process_client.login(self.name)
else:
self.player = self.process_client.multi_login(
self.name, self.game, self.num_players)
except LoginError:
self.process_client.logout()
print('BAD LOGIN\nTRY AGAIN')
exit()
self.init_world()
strategy = Strategy(self.player, self.map_graph, self.objects)
if self.is_gui:
self.gui = GUI(self.player, self.map_graph, self.objects, strategy)
while self.player.is_alive:
self.process_client.update_objects(self.objects,
self.map_graph, self.player)
# self.print_state()
if self.is_gui:
self.gui.turn()
if (not self.gui.paused) or self.gui.onestep:
self.move(strategy)
else:
self.move(strategy)
finally:
self.process_client.logout()
self.process_client.close()
return self.player.is_alive # for testing
def init_world(self):
self.map_graph = self.process_client.read_map()
self.map_graph.pos = dict(
[(cord['idx'], (cord['x'] / 200, cord['y'] / 200))
for cord in self.process_client.read_position()["coordinate"]])
self.objects = self.process_client.read_objects()
# self.map_graph.define_points(self.objects)
self.player.settle(self.map_graph, self.objects)
def move(self, strategy): # move == ход
moves = strategy.get_moves()
if moves:
for move in moves:
self.process_client.move(move)
up_obj = strategy.get_upgrade()
if up_obj:
self.process_client.upgrade(up_obj)
self.process_client.turn()
self.objects.tick += 1
def print_state(self):
str_post = []
for town in self.objects.towns.values():
str_post.append(
[town.name, town.product, town.armor, town.population])
for market in self.objects.markets.values():
str_post.append([market.name, market.product, '-', '-'])
for storage in self.objects.storages.values():
str_post.append([storage.name, '-', storage.armor, '-'])
print(
tabulate(
str_post, headers=['name', 'product', 'armor', 'population']),
'\n')
for train in self.objects.trains.values():
print(
tabulate(
[[
train.idx, train.goods, train.post_type,
train.line_idx, train.speed, train.position
]],
headers=[
'Train_id', 'product', 'post_type', 'line_idx',
'speed', 'position'
]))
