async def runClient():
async with websockets.connect('ws://127.0.0.1:5001/sc2api') as websocket:
await websocket.send(makeJoinGameRequest().SerializeToString())
response = sc_pb.Response()
response_bytes = await websocket.recv()
response.ParseFromString(response_bytes)
print("< {}".format(response))
still_going = True
while still_going:
await websocket.send(makeObservationRequest().SerializeToString())
response = sc_pb.Response()
response_bytes = await websocket.recv()
response.ParseFromString(response_bytes)
print("< {}".format(response))
if len(response.observation.player_result) > 0:
still_going = False
await websocket.send(makeStepRequest().SerializeToString())
response = sc_pb.Response()
response_bytes = await websocket.recv()
response.ParseFromString(response_bytes)
print("< {}".format(response))
await websocket.send(makeLeaveRequest().SerializeToString())
response = sc_pb.Response()
response_bytes = await websocket.recv()
response.ParseFromString(response_bytes)
print("< {}".format(response))
async def __request(self, request):
logger.debug(f"Sending request: {request !r}")
try:
await self._ws.send_bytes(request.SerializeToString())
except TypeError:
logger.exception("Cannot send: Connection already closed.")
raise ConnectionAlreadyClosed("Connection already closed.")
logger.debug(f"Request sent")
response = sc_pb.Response()
try:
response_bytes = await self._ws.receive_bytes()
except TypeError:
logger.exception("Cannot receive: Connection already closed.")
raise ConnectionAlreadyClosed("Connection already closed.")
except asyncio.CancelledError:
# If request is sent, the response must be received before reraising cancel
try:
await self._ws.receive_bytes()
except asyncio.CancelledError:
logger.critical(
"Requests must not be cancelled multiple times")
sys.exit(2)
raise
response.ParseFromString(response_bytes)
logger.debug(f"Response received")
return response
async def _execute(self, **kwargs):
assert len(kwargs) == 1, "Only one request allowed"
request = sc_pb.Request(**kwargs)
# if len(repr(request)) < 200:
# print(">", repr(request))
# else:
# print(">", repr(request)[:200]+"...")
await self._ws.send(request.SerializeToString())
response = sc_pb.Response()
response_bytes = await self._ws.recv()
response.ParseFromString(response_bytes)
# if len(repr(response)) < 200:
# print("<", repr(response))
# else:
# print("<", repr(response)[:200])
# print("...")
self._status = Status(response.status)
if response.error:
# if response.HasField("error_details"):
# raise ProtocolError(f"{response.error}: {response.error_details}")
# else:
raise ProtocolError(f"{response.error}")
return response
def doCommand(sc2_socket, command, *arguments):
# log.debug("Attempting to send command %s" % command)
sc2_socket.send(command(*arguments).SerializeToString())
# log.debug("Sent command %s" % command)
response = sc2api_pb2.Response()
# log.debug("Awaiting response from sc2")
response_bytes = sc2_socket.recv()
response.ParseFromString(response_bytes)
# log.debug("Received response:\n%s" % response)
return response
def _read(self):
"""Actually read the response and parse it, returning a Response."""
with sw("read_response"):
with catch_websocket_connection_errors():
response_str = self._sock.recv()
if not response_str:
raise ProtocolError("Got an empty response from SC2.")
response = sc_pb.Response()
with sw("parse_response"):
response.ParseFromString(response_str)
return response
async def __request(self, request):
logger.debug(f"Sending request: {request !r}")
try:
await self._ws.send_bytes(request.SerializeToString())
except TypeError:
logger.exception("Cannot send: Connection already closed.")
raise ConnectionAlreadyClosed("Connection already closed.")
logger.debug(f"Request sent")
response = sc_pb.Response()
try:
response_bytes = await self._ws.receive_bytes()
except TypeError:
logger.exception("Cannot receive: Connection already closed.")
raise ConnectionAlreadyClosed("Connection already closed.")
response.ParseFromString(response_bytes)
logger.debug(f"Response received")
return response
async def parse_response(self, response_bytes):
response = sc_pb.Response()
response.ParseFromString(response_bytes)
if not response.HasField("status"):
logger.critical("Proxy: RESPONSE HAS NO STATUS {response}")
else:
new_status = Status(response.status)
if new_status != self.controller._status:
logger.info(
f"Controller({self.player.name}): {self.controller._status}->{new_status}"
)
self.controller._status = new_status
if self.player_id is None:
if response.HasField("join_game"):
self.player_id = response.join_game.player_id
logger.info(
f"Proxy({self.player.name}): got join_game for {self.player_id}"
)
if self.result is None:
if response.HasField("observation"):
obs: sc_pb.ResponseObservation = response.observation
if obs.player_result:
self.result = {
pr.player_id: Result(pr.result)
for pr in obs.player_result
}
elif (self.timeout_loop and obs.HasField("observation")
and obs.observation.game_loop > self.timeout_loop):
self.result = {i: Result.Tie for i in range(1, 3)}
logger.info(f"Proxy({self.player.name}) timing out")
act = [
sc_pb.Action(action_chat=sc_pb.ActionChat(
message="Proxy: Timing out"))
]
await self.controller._execute(action=sc_pb.RequestAction(
actions=act))
return response
async def _execute(self, **kwargs):
assert len(kwargs) == 1, "Only one request allowed"
request = sc_pb.Request(**kwargs)
await self._ws.send(request.SerializeToString())
response = sc_pb.Response()
try:
response_bytes = await self._ws.recv()
except websockets.exceptions.ConnectionClosed:
raise ProtocolError("Connection already closed.")
response.ParseFromString(response_bytes)
self._status = Status(response.status)
if response.error:
# if response.HasField("error_details"):
# raise ProtocolError(f"{response.error}: {response.error_details}")
# else:
raise ProtocolError(f"{response.error}")
return response
def read(self):
response_str = self.conn.recv()
response = sc_pb.Response()
response.ParseFromString(response_str)
return response
