def parse_bytes(self, daide_bytes): """ Builds the request from DAIDE bytes """ super(SendMessageRequest, self).parse_bytes(daide_bytes) # Parsing lead_token, daide_bytes = parse_bytes(SingleToken, daide_bytes) assert str(lead_token) == 'SND', 'Expected SND request' # Turn turn, daide_bytes = parse_bytes(Turn, daide_bytes, on_error='ignore') # Powers powers = [] powers_group_bytes, daide_bytes = break_next_group(daide_bytes) powers_group_bytes = strip_parentheses(powers_group_bytes) while powers_group_bytes: power, powers_group_bytes = parse_bytes(Power, powers_group_bytes) powers += [power] assert powers, 'Expected a group of `power`. Request is malformed' # Press message or reply message_group_bytes, daide_bytes = break_next_group(daide_bytes) message_group_bytes = strip_parentheses(message_group_bytes) assert message_group_bytes, 'Expected a `press_message` or a `reply`. Request is malformed' assert not daide_bytes, '%s bytes remaining. Request is malformed' % len(daide_bytes) # Setting properties self.phase = '' if not turn else str(turn) self.powers = [str(power) for power in powers] self.message_bytes = message_group_bytes
def parse_bytes(self, daide_bytes): """ Builds the request from DAIDE bytes """ super(IAmRequest, self).parse_bytes(daide_bytes) # Parsing lead_token, daide_bytes = parse_bytes(SingleToken, daide_bytes) assert str(lead_token) == 'IAM', 'Expected IAM request' # Power power_group_bytes, daide_bytes = break_next_group(daide_bytes) power_group_bytes = strip_parentheses(power_group_bytes) power, power_group_bytes = parse_bytes(Power, power_group_bytes) assert not power_group_bytes, '%s bytes remaining in power group. Request is malformed' % len( power_group_bytes) # Passcode passcode_group_bytes, daide_bytes = break_next_group(daide_bytes) passcode_group_bytes = strip_parentheses(passcode_group_bytes) passcode, passcode_group_bytes = parse_bytes(SingleToken, passcode_group_bytes) assert not passcode_group_bytes, '%s bytes remaining in passcode group. Req. error' % len( passcode_group_bytes) assert not daide_bytes, '%s bytes remaining. Request is malformed' % len( daide_bytes) # Setting properties self.power_name = str(power) self.passcode = str(passcode)
def _build_retreat_phase(self, power): """ Builds the missing orders response for a retreat phase """ units_bytes_buffer = [] units_with_no_order = { unit: retreat_provinces for unit, retreat_provinces in power.retreats.items() } # Removing units for which we have orders for key, value in power.orders.items(): unit = key # Regular game {e.g. 'A PAR': '- BUR') if key[0] in 'RIO': # No-check game (key is INVALID, ORDER x, REORDER x) unit = ' '.join(value.split()[:2]) if unit in units_with_no_order: del units_with_no_order[unit] # Sorting by the unit's province ASC so results are deterministic for unit, retreat_provinces in sorted( units_with_no_order.items(), key=lambda key_val: key_val[0].split()[-1]): unit_clause = parse_string(Unit, '%s %s' % (power.name, unit)) retreat_clauses = [ parse_string(Province, province) for province in retreat_provinces ] units_bytes_buffer += [ add_parentheses( strip_parentheses(bytes(unit_clause)) + bytes(tokens.MRT) + add_parentheses(b''.join( [bytes(province) for province in retreat_clauses]))) ] self._bytes = bytes(tokens.MIS) + b''.join(units_bytes_buffer)
def parse_bytes(self, daide_bytes): """ Builds the request from DAIDE bytes """ super(ParenthesisErrorRequest, self).parse_bytes(daide_bytes) # Parsing lead_token, daide_bytes = parse_bytes(SingleToken, daide_bytes) message_bytes, daide_bytes = break_next_group(daide_bytes) if message_bytes: message_bytes = strip_parentheses(message_bytes) else: message_bytes = strip_parentheses(daide_bytes) daide_bytes = b'' assert str(lead_token) == 'PRN', 'Expected PRN request' assert not daide_bytes, '%s bytes remaining. Request is malformed' % len(daide_bytes) # Setting properties self.message_bytes = message_bytes
def parse_bytes(self, daide_bytes): """ Builds the request from DAIDE bytes """ super(RejectRequest, self).parse_bytes(daide_bytes) # Parsing lead_token, daide_bytes = parse_bytes(SingleToken, daide_bytes) response_bytes, daide_bytes = break_next_group(daide_bytes) response_bytes = strip_parentheses(response_bytes) assert str(lead_token) == 'REJ', 'Expected REJ request' assert not daide_bytes, '%s bytes remaining. Request is malformed' % len(daide_bytes) # Setting properties self.response_bytes = response_bytes
def parse_bytes(self, daide_bytes): """ Builds the request from DAIDE bytes """ super(NotRequest, self).parse_bytes(daide_bytes) # Parsing lead_token, daide_bytes = parse_bytes(SingleToken, daide_bytes) request_group_bytes, daide_bytes = break_next_group(daide_bytes) assert str(lead_token) == 'NOT', 'Expected NOT request' # Request request_group_bytes = strip_parentheses(request_group_bytes) request = RequestBuilder.from_bytes(request_group_bytes) assert not daide_bytes, '%s bytes remaining. Request is malformed' % len(daide_bytes) # Setting properties self.request = request
def parse_bytes(self, daide_bytes): """ Builds the request from DAIDE bytes """ super(TimeToDeadlineRequest, self).parse_bytes(daide_bytes) # Parsing lead_token, daide_bytes = parse_bytes(SingleToken, daide_bytes) seconds_group_bytes, daide_bytes = break_next_group(daide_bytes) assert str(lead_token) == 'TME', 'Expected TME request' # Seconds if seconds_group_bytes: seconds_group_bytes = strip_parentheses(seconds_group_bytes) seconds, daide_bytes = parse_bytes(Number, seconds_group_bytes) assert not daide_bytes, '%s bytes remaining. Request is malformed' % len(daide_bytes) # Setting properties self.seconds = None if not seconds_group_bytes else int(seconds)
def parse_bytes(self, daide_bytes): """ Builds the request from DAIDE bytes """ super(DrawRequest, self).parse_bytes(daide_bytes) powers = [] # Parsing lead_token, daide_bytes = parse_bytes(SingleToken, daide_bytes) assert str(lead_token) == 'DRW', 'Expected DRW request' # Powers powers_group_bytes, daide_bytes = break_next_group(daide_bytes) if powers_group_bytes: powers_group_bytes = strip_parentheses(powers_group_bytes) while powers_group_bytes: power, powers_group_bytes = parse_bytes(Power, powers_group_bytes) powers += [power] assert not daide_bytes, '%s bytes remaining. Request is malformed' % len(daide_bytes) # Setting properties self.powers = [str(power) for power in powers]
def __init__(self, phase_name, powers_units, powers_retreats, **kwargs): """ Builds the response :param phase_name: The name of the current phase (e.g. 'S1901M') :param powers: A list of `diplomacy.engine.power.Power` objects """ super(CurrentPositionResponse, self).__init__(**kwargs) units_bytes_buffer = [] # Turn turn_clause = parse_string(Turn, phase_name) # Units for power_name, units in sorted(powers_units.items()): # Regular units for unit in units: unit_clause = parse_string(Unit, '%s %s' % (power_name, unit)) units_bytes_buffer += [bytes(unit_clause)] # Dislodged units for unit, retreat_provinces in sorted( powers_retreats[power_name].items()): unit_clause = parse_string(Unit, '%s %s' % (power_name, unit)) retreat_clauses = [ parse_string(Province, province) for province in retreat_provinces ] units_bytes_buffer += [ add_parentheses( strip_parentheses(bytes(unit_clause)) + bytes(tokens.MRT) + add_parentheses(b''.join( [bytes(province) for province in retreat_clauses]))) ] # Storing full response self._bytes = bytes( tokens.NOW) + bytes(turn_clause) + b''.join(units_bytes_buffer)