# ==============================================================================
# Copyright (C) 2019 - Philip Paquette
#
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU Affero General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option) any
# later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
# details.
#
# You should have received a copy of the GNU Affero General Public License along
# with this program. If not, see <https://www.gnu.org/licenses/>.
# ==============================================================================
""" DAIDE Responses - Contains a list of responses sent by the server to the client """
from diplomacy import Map
from diplomacy.communication.responses import _AbstractResponse
from diplomacy.daide.clauses import String, Power, Province, Turn, Unit, add_parentheses, strip_parentheses, \
parse_string
from diplomacy.daide import tokens
from diplomacy.daide.tokens import Token
from diplomacy.daide.utils import bytes_to_str
from diplomacy.utils.splitter import OrderSplitter
class DaideResponse(_AbstractResponse):
""" Represents a DAIDE response. """
def __init__(self, **kwargs):
""" Constructor """
self._bytes = b''
super(DaideResponse, self).__init__(**kwargs)
def __bytes__(self):
""" Returning the bytes representation of the response """
return self._bytes
def __str__(self):
""" Returning the string representation of the response """
return bytes_to_str(self._bytes)
class MapNameResponse(DaideResponse):
""" Represents a MAP DAIDE response. Sends the name of the current map to the client.
Syntax:
MAP ('name')
"""
def __init__(self, map_name, **kwargs):
""" Builds the response
:param map_name: String. The name of the current map.
"""
super(MapNameResponse, self).__init__(**kwargs)
self._bytes = bytes(tokens.MAP) \
+ bytes(parse_string(String, map_name))
class MapDefinitionResponse(DaideResponse):
""" Represents a MDF DAIDE response. Sends configuration of a map to a client
Syntax:
MDF (powers) (provinces) (adjacencies)
powers syntax:
power power ...
power syntax:
AUS # Austria
ENG # England
FRA # France
GER # Germany
ITA # Italy
RUS # Russia
TUR # Turkey
provinces syntax:
(supply_centres) (non_supply_centres)
supply_centres syntax:
(power centre centre ...) (power centre centre ...) ...
supply_centres power syntax:
(power power ...) # This is currently not supported
AUS # Austria
ENG # England
FRA # France
GER # Germany
ITA # Italy
RUS # Russia
TUR # Turkey
UNO # Unknown power
non_supply_centres syntax:
province province ... # List of provinces
adjacencies syntax:
(prov_adjacencies) (prov_adjacencies) ...
prov_adjacencies syntax:
province (unit_type adjacent_prov adjacent_prov ...) (unit_type adjacent_prov adjacent_prov ...) ...
unit_type syntax:
AMY # List of provinces an army can move to
FLT # List of provinces a fleet can move to
(FLT coast) # List of provinces a fleet can move to from the given coast
adjacent_prov syntax:
province # A province which can be moved to
(province coast) # A coast of a province that can be moved to
"""
def __init__(self, map_name, **kwargs):
""" Builds the response
:param map_name: The name of the map
"""
super(MapDefinitionResponse, self).__init__(**kwargs)
game_map = Map(map_name)
# (Powers): (power power ...)
# (Provinces): ((supply_centers) (non_supply_centres))
# (Adjacencies): ((prov_adjacencies) (prov_adjacencies) ...)
powers_clause = self._build_powers_clause(game_map)
provinces_clause = self._build_provinces_clause(game_map)
adjacencies_clause = self._build_adjacencies_clause(game_map)
self._bytes = bytes(tokens.MDF) \
+ powers_clause \
+ provinces_clause \
+ adjacencies_clause
@staticmethod
def _build_powers_clause(game_map):
""" Build the powers clause
Syntax:
(powers)
powers syntax:
power power ...
power syntax:
AUS # Austria
ENG # England
FRA # France
GER # Germany
ITA # Italy
RUS # Russia
TUR # Turkey
"""
power_names = game_map.powers[:]
power_names.sort()
# (Powers): (power power ...)
powers_clause = [bytes(parse_string(Power, power_name)) for power_name in power_names]
powers_clause = add_parentheses(b''.join(powers_clause))
return powers_clause
@staticmethod
def _build_provinces_clause(game_map):
""" Build the provinces clause
Syntax:
(provinces)
provinces syntax:
(supply_centres) (non_supply_centres)
supply_centres syntax:
(power centre centre ...) (power centre centre ...) ...
supply_centres power syntax:
(power power ...) # This is currently not supported
AUS # Austria
ENG # England
FRA # France
GER # Germany
ITA # Italy
RUS # Russia
TUR # Turkey
UNO # Unknown power
non_supply_centres syntax:
province province ... # List of provinces
"""
unowned_scs = game_map.scs[:]
unowned_scs.sort()
# (Supply centers): ((power centre centre ...) (power centre centre ...) ...)
# (Non supply centres): (province province ...)
scs_clause = []
non_scs_clause = []
power_names_centers = [(power_name, centers[:]) for power_name, centers in game_map.centers.items()]
power_names_centers.sort(key=lambda power_name_center: power_name_center[0])
# Parsing each power centers
for power_name, centers in power_names_centers:
centers.sort()
power_scs_clause = [bytes(parse_string(Power, power_name))]
for center in centers:
power_scs_clause.append(bytes(parse_string(Province, center)))
unowned_scs.remove(center)
# (Power supply centers): (power centre centre ...)
power_scs_clause = add_parentheses(b''.join(power_scs_clause))
scs_clause.append(power_scs_clause)
# (Power supply centers): (power centre centre ...)
power_scs_clause = [bytes(tokens.UNO)]
power_scs_clause += [bytes(parse_string(Province, center)) for center in unowned_scs]
power_scs_clause = add_parentheses(b''.join(power_scs_clause))
# (Supply centers): ((power centre centre ...) (power centre centre ...) ...)
scs_clause.append(power_scs_clause)
scs_clause = add_parentheses(b''.join(scs_clause))
provinces = game_map.locs[:]
provinces.sort()
for province in provinces:
if game_map.area_type(province) == 'SHUT':
continue
province = province[:3].upper()
province_clause = bytes(parse_string(Province, province))
if province_clause not in non_scs_clause and province not in game_map.scs:
non_scs_clause.append(province_clause)
# (Non supply centres): (province province ...)
non_scs_clause = add_parentheses(b''.join(non_scs_clause))
# (Provinces): ((supply_centers) (non_supply_centres))
provinces_clause = [scs_clause, non_scs_clause]
provinces_clause = add_parentheses(b''.join(provinces_clause))
return provinces_clause
@staticmethod
def _build_adjacencies_clause(game_map):
""" Build the adjacencies clause
Syntax:
(adjacencies)
adjacencies syntax:
(prov_adjacencies) (prov_adjacencies) ...
prov_adjacencies syntax:
province (unit_type adjacent_prov adjacent_prov ...) (unit_type adjacent_prov adjacent_prov ...) ...
unit_type syntax:
AMY # List of provinces an army can move to
FLT # List of provinces a fleet can move to
(FLT coast) # List of provinces a fleet can move to from the given coast
adjacent_prov syntax:
province # A province which can be moved to
(province coast) # A coast of a province that can be moved to
"""
adjacencies = {} # {province: {'A': [], 'F': [], '/': []} army abuts, fleet abuts, / abuts
# For each province
for province in sorted([loc.upper() for loc in game_map.locs if '/' not in loc]):
province_type = game_map.area_type(province)
if province_type == 'SHUT':
continue
# Creating empty list of adjacent provinces
adjacencies.setdefault(province, {})
adjacencies[province].setdefault('A', []) # List of adjacent provinces where armies can move
for province_w_coast in sorted(game_map.find_coasts(province)):
coast = province_w_coast[3:]
adjacencies[province].setdefault(coast, []) # List of adjacent provinces where fleets can move
# Building list of adjacent provinces
for coast in adjacencies[province]: # 'A', '', '/NC', '/SC', '/EC', '/WC'
# Army adjacencies
if coast == 'A':
for dest in sorted(game_map.dest_with_coasts[province]):
if game_map.abuts('A', province, '-', dest):
adjacencies[province]['A'].append(bytes(parse_string(Province, dest)))
# Fleet adjacencies
else:
for dest in sorted(game_map.dest_with_coasts[province + coast]):
if game_map.abuts('F', province + coast, '-', dest):
adjacencies[province][coast].append(bytes(parse_string(Province, dest)))
# If province has coasts ('/NC', '/SC'), removing the adjacency for fleets without coast
if len(adjacencies[province]) > 2:
del adjacencies[province]['']
# Building adjacencies clause
adjacencies_clause = []
for province in sorted(adjacencies):
prov_adjacencies_clause = [bytes(parse_string(Province, province))]
for coast in ('A', '', '/EC', '/NC', '/SC', '/WC'):
if coast not in adjacencies[province]:
continue
if not adjacencies[province][coast]:
continue
# (Army adjacencies): (AMY adjacent_prov adjacent_prov ...)
if coast == 'A':
amy_adjacencies_clause = [bytes(tokens.AMY)] + adjacencies[province][coast]
amy_adjacencies_clause = add_parentheses(b''.join(amy_adjacencies_clause))
prov_adjacencies_clause.append(amy_adjacencies_clause)
# (Fleet provinces): (FLT adjacent_prov adjacent_prov ...)
elif coast == '':
flt_adjacencies_clause = [bytes(tokens.FLT)] + adjacencies[province][coast]
flt_adjacencies_clause = add_parentheses(b''.join(flt_adjacencies_clause))
prov_adjacencies_clause.append(flt_adjacencies_clause)
# (Fleet coast): (FLT coast)
# (Fleet coast provinces): ((FLT coast) adjacent_prov adjacent_prov ...)
else:
flt_clause = bytes(tokens.FLT)
coast_clause = bytes(parse_string(Province, coast))
coast_flt_adjacencies_clause = [add_parentheses(flt_clause + coast_clause)] \
+ adjacencies[province][coast]
coast_flt_adjacencies_clause = add_parentheses(b''.join(coast_flt_adjacencies_clause))
prov_adjacencies_clause.append(coast_flt_adjacencies_clause)
# (Province adjacencies): (province (unit_type adjacent_prov adjacent_prov ...)
# (unit_type adjacent_prov adjacent_prov ...) ...)
prov_adjacencies_clause = add_parentheses(b''.join(prov_adjacencies_clause))
adjacencies_clause.append(prov_adjacencies_clause)
# (Adjacencies): ((prov_adjacencies) (prov_adjacencies) ...)
adjacencies_clause = add_parentheses(b''.join(adjacencies_clause))
return adjacencies_clause
class HelloResponse(DaideResponse):
""" Represents a HLO DAIDE response. Sends the power to be played by the client with the passcode to rejoin the
game and the details of the game.
Syntax:
HLO (power) (passcode) (variant) (variant) ...
Variant syntax:
LVL n # Level of the syntax accepted
MTL seconds # Movement time limit
RTL seconds # Retreat time limit
BTL seconds # Build time limit
DSD # Disables the time limit when a client disconects
AOA # Any orders accepted
LVL 10:
Variant syntax:
PDA # Accept partial draws
NPR # No press during retreat phases
NPB # No press during build phases
PTL seconds # Press time limit
"""
def __init__(self, power_name, passcode, level, deadline, rules, **kwargs):
""" Builds the response
:param power_name: The name of the power being played.
:param passcode: Integer. A passcode to rejoin the game.
:param level: Integer. The daide syntax level of the game
:param deadline: Integer. The number of seconds per turn (0 to disable)
:param rules: The list of game rules.
"""
super(HelloResponse, self).__init__(**kwargs)
power = parse_string(Power, power_name)
passcode = Token(from_int=passcode)
if 'NO_PRESS' in rules:
level = 0
variants = add_parentheses(bytes(tokens.LVL) + bytes(Token(from_int=level)))
if deadline > 0:
variants += add_parentheses(bytes(tokens.MTL) + bytes(Token(from_int=deadline)))
variants += add_parentheses(bytes(tokens.RTL) + bytes(Token(from_int=deadline)))
variants += add_parentheses(bytes(tokens.BTL) + bytes(Token(from_int=deadline)))
if 'NO_CHECK' in rules:
variants += add_parentheses(bytes(tokens.AOA))
self._bytes = bytes(tokens.HLO) \
+ add_parentheses(bytes(power)) \
+ add_parentheses(bytes(passcode)) \
+ add_parentheses(bytes(variants))
class SupplyCenterResponse(DaideResponse):
""" Represents a SCO DAIDE response. Sends the current supply centre ownership.
Syntax:
SCO (power centre centre ...) (power centre centre ...) ...
"""
def __init__(self, powers_centers, map_name, **kwargs):
""" Builds the response
:param powers_centers: A dict of {power_name: centers} objects
:param map_name: The name of the map
"""
super(SupplyCenterResponse, self).__init__(**kwargs)
remaining_scs = Map(map_name).scs[:]
all_powers_bytes = []
# Parsing each power
for power_name in sorted(powers_centers):
centers = sorted(powers_centers[power_name])
power_clause = parse_string(Power, power_name)
power_bytes = bytes(power_clause)
for center in centers:
sc_clause = parse_string(Province, center)
power_bytes += bytes(sc_clause)
remaining_scs.remove(center)
all_powers_bytes += [power_bytes]
# Parsing unowned center
uno_token = tokens.UNO
power_bytes = bytes(uno_token)
for center in remaining_scs:
sc_clause = parse_string(Province, center)
power_bytes += bytes(sc_clause)
all_powers_bytes += [power_bytes]
# Storing full response
self._bytes = bytes(tokens.SCO) \
+ b''.join([add_parentheses(power_bytes) for power_bytes in all_powers_bytes])
class CurrentPositionResponse(DaideResponse):
""" Represents a NOW DAIDE response. Sends the current turn, and the current unit positions.
Syntax:
NOW (turn) (unit) (unit) ...
Unit syntax:
power unit_type province
power unit_type province MRT (province province ...)
"""
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)
class ThanksResponse(DaideResponse):
""" Represents a THX DAIDE response. Sends the result of an order after submission.
Syntax:
THX (order) (note)
Note syntax:
MBV # Order is OK.
FAR # Not adjacent.
NSP # No such province
NSU # No such unit
NAS # Not at sea (for a convoying fleet)
NSF # No such fleet (in VIA section of CTO or the unit performing a CVY)
NSA # No such army (for unit being ordered to CTO or for unit being CVYed)
NYU # Not your unit
NRN # No retreat needed for this unit
NVR # Not a valid retreat space
YSC # Not your supply centre
ESC # Not an empty supply centre
HSC # Not a home supply centre
NSC # Not a supply centre
CST # No coast specified for fleet build in StP, or an attempt
to build a fleet inland, or an army at sea.
NMB # No more builds allowed
NMR # No more removals allowed
NRS # Not the right season
"""
def __init__(self, order_bytes, results, **kwargs):
""" Builds the response
:param order_bytes: The bytes received for the order
:param results: An array containing the error codes.
"""
super(ThanksResponse, self).__init__(**kwargs)
if not results or 0 in results: # Order success response
note_clause = tokens.MBV
else: # Generic order failure response
note_clause = tokens.NYU
# Storing full response
self._bytes = bytes(tokens.THX) + order_bytes + add_parentheses(bytes(note_clause))
class MissingOrdersResponse(DaideResponse):
""" Represents a MIS DAIDE response. Sends the list of unit for which an order is missing or indication about
required disbands or builds.
Syntax:
MIS (unit) (unit) ...
MIS (unit MRT (province province ...)) (unit MRT (province province ...)) ...
MIS (number)
"""
def __init__(self, phase_name, power, **kwargs):
""" Builds the response
:param phase_name: The name of the current phase (e.g. 'S1901M')
:param power: The power to check for missing orders
:type power: diplomacy.engine.power.Power
"""
super(MissingOrdersResponse, self).__init__(**kwargs)
assert phase_name[-1] in 'MRA', 'Invalid phase "%s"' & phase_name
{'M': self._build_movement_phase,
'R': self._build_retreat_phase,
'A': self._build_adjustment_phase}[phase_name[-1]](power)
def _build_movement_phase(self, power):
""" Builds the missing orders response for a movement phase """
units_with_no_order = [unit for unit in power.units]
# 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:
units_with_no_order.remove(unit)
# Storing full response
self._bytes = bytes(tokens.MIS) + \
b''.join([bytes(parse_string(Unit, '%s %s' % (power.name, unit)))
for unit in units_with_no_order])
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 _build_adjustment_phase(self, power):
""" Builds the missing orders response for a build phase """
adjusts = [OrderSplitter(adjust) for adjust in power.adjust]
build_cnt = sum(1 for adjust in adjusts if adjust.order_type == 'B')
disband_cnt = sum(1 for adjust in adjusts if adjust.order_type == 'D')
disbands_status = (len(power.units) + build_cnt) - (len(power.centers) + disband_cnt)
if disbands_status < 0:
available_homes = power.homes[:]
# Removing centers for which it's impossible to build
for unit in [unit.split() for unit in power.units]:
province = unit[1]
if province in available_homes:
available_homes.remove(province)
disbands_status = max(-len(available_homes), disbands_status)
self._bytes += bytes(tokens.MIS) + add_parentheses(bytes(Token(from_int=disbands_status)))
class OrderResultResponse(DaideResponse):
""" Represents a ORD DAIDE response. Sends the result of an order after the turn has been processed.
Syntax:
ORD (turn) (order) (result)
ORD (turn) (order) (result RET)
Result syntax:
SUC # Order succeeded (can apply to any order).
BNC # Move bounced (only for MTO, CTO or RTO orders).
CUT # Support cut (only for SUP orders).
DSR # Move via convoy failed due to dislodged convoying fleet (only for CTO orders).
NSO # No such order (only for SUP, CVY or CTO orders).
RET # Unit was dislodged and must retreat.
"""
def __init__(self, phase_name, order_bytes, results, **kwargs):
""" Builds the response
:param phase_name: The name of the current phase (e.g. 'S1901M')
:param order_bytes: The bytes received for the order
:param results: An array containing the error codes.
"""
super(OrderResultResponse, self).__init__(**kwargs)
turn_clause = parse_string(Turn, phase_name)
if not results or 0 in results: # Order success response
result_clause = tokens.SUC
else: # Generic order failure response
result_clause = tokens.NSO
self._bytes = bytes(tokens.ORD) + bytes(turn_clause) + add_parentheses(order_bytes) + \
add_parentheses(bytes(result_clause))
class TimeToDeadlineResponse(DaideResponse):
""" Represents a TME DAIDE response. Sends the time to the next deadline.
Syntax:
TME (seconds)
"""
def __init__(self, seconds, **kwargs):
""" Builds the response
:param seconds: Integer. The number of seconds before deadline
"""
super(TimeToDeadlineResponse, self).__init__(**kwargs)
self._bytes = bytes(tokens.TME) + add_parentheses(bytes(Token(from_int=seconds)))
class AcceptResponse(DaideResponse):
""" Represents a YES DAIDE request.
Syntax:
YES (TME (seconds)) # Accepts to set the time when a
TME message will be sent
YES (NOT (TME)) # Accepts to cancel all requested time messages
YES (NOT (TME (seconds))) # Accepts to cancel a specific requested time message
YES (GOF) # Accepts to wait until the deadline before processing
the orders for the turn
YES (NOT (GOF)) # Accepts to cancel to wait until the deadline before
processing the orders for the turn
YES (DRW) # Accepts to draw
YES (NOT (DRW)) # Accepts to cancel a draw request
LVL 10:
YES (DRW (power power ...)) # Accepts a partial draw
YES (NOT (DRW (power power ...))) # Accepts to cancel a partial draw request
(? not mentinned in the DAIDE doc)
YES (SND (power power ...) (press_message)) # Accepts a press message
YES (SND (turn) (power power ...) (press_message)) # Accepts a press message
"""
def __init__(self, request_bytes, **kwargs):
""" Builds the response
:param request_bytes: The bytes received for the request
"""
super(AcceptResponse, self).__init__(**kwargs)
self._bytes = bytes(tokens.YES) + add_parentheses(request_bytes)
class RejectResponse(DaideResponse):
""" Represents a REJ DAIDE request.
Syntax:
REJ (NME ('name') ('version')) # Rejects a client in the game
REJ (IAM (power) (passcode)) # Rejects a client to rejoin the game
REJ (HLO) # Rejects to send the HLO message
REJ (HST (turn)) # Rejects to send a copy of a previous
ORD, SCO and NOW messages
REJ (SUB (order) (order)) # Rejects a submition of orders
REJ (SUB (turn) (order) (order)) # Rejects a submition of orders
REJ (NOT (SUB (order))) # Rejects a cancellation of a submitted order
REJ (MIS) # Rejects to send a copy of the current MIS message
REJ (GOF) # Rejects to wait until the deadline before processing
the orders for the turn
REJ (NOT (GOF)) # Rejects to cancel to wait until the deadline before
processing the orders for the turn
REJ (TME (seconds)) # Rejects to set the time when a
TME message will be sent
REJ (NOT (TME)) # Rejects to cancel all requested time messages
REJ (NOT (TME (seconds))) # Rejects to cancel a specific requested time message
REJ (ADM ('name') ('message') # Rejects the admin message
REJ (DRW) # Rejects to draw
REJ (NOT (DRW)) # Rejects to cancel a draw request
LVL 10:
REJ (DRW (power power ...)) # Rejects to partially draw
REJ (NOT (DRW (power power ...))) # Rejects to cancel a partial draw request
REJ (SND (power power ...) (press_message)) # Rejects a press message
REJ (SND (turn) (power power ...) (press_message)) # Rejects a press message
"""
def __init__(self, request_bytes, **kwargs):
""" Builds the response
:param request_bytes: The bytes received for the request
"""
super(RejectResponse, self).__init__(**kwargs)
self._bytes = bytes(tokens.REJ) + add_parentheses(request_bytes)
class NotResponse(DaideResponse):
""" Represents a NOT DAIDE response.
Syntax:
NOT (CCD (power))
"""
def __init__(self, response_bytes, **kwargs):
""" Builds the response
:param response_bytes: The bytes received for the request
"""
super(NotResponse, self).__init__(**kwargs)
self._bytes = bytes(tokens.NOT) + add_parentheses(response_bytes)
class PowerInCivilDisorderResponse(DaideResponse):
""" Represents a CCD DAIDE response. Sends the name of the power in civil disorder.
Syntax:
CCD (power)
"""
def __init__(self, power_name, **kwargs):
""" Builds the response
:param power_name: The name of the power being played.
"""
super(PowerInCivilDisorderResponse, self).__init__(**kwargs)
power = parse_string(Power, power_name)
self._bytes = bytes(tokens.CCD) + add_parentheses(bytes(power))
class PowerIsEliminatedResponse(DaideResponse):
""" Represents a OUT DAIDE response. Sends the name of the power eliminated.
Syntax:
OUT (power)
"""
def __init__(self, power_name, **kwargs):
""" Builds the response
:param power_name: The name of the power being played.
"""
super(PowerIsEliminatedResponse, self).__init__(**kwargs)
power = parse_string(Power, power_name)
self._bytes = bytes(tokens.OUT) + add_parentheses(bytes(power))
class ParenthesisErrorResponse(DaideResponse):
""" Represents a PRN DAIDE response.
Syntax:
PRN (message)
"""
def __init__(self, request_bytes, **kwargs):
""" Builds the response
:param request_bytes: The bytes received for the request
"""
super(ParenthesisErrorResponse, self).__init__(**kwargs)
self._bytes = bytes(tokens.PRN) + add_parentheses(request_bytes)
class SyntaxErrorResponse(DaideResponse):
""" Represents a HUH DAIDE response.
Syntax:
HUH (message)
"""
def __init__(self, request_bytes, error_index, **kwargs):
""" Builds the response
:param request_bytes: The bytes received for the request
:param error_index: The index of the faulty token
"""
super(SyntaxErrorResponse, self).__init__(**kwargs)
message_with_err = request_bytes[:error_index] + bytes(tokens.ERR) + request_bytes[error_index:]
self._bytes = bytes(tokens.HUH) + add_parentheses(message_with_err)
class TurnOffResponse(DaideResponse):
""" Represents an OFF DAIDE response. Requests a client to exit
Syntax:
OFF
"""
def __init__(self, **kwargs):
""" Builds the response
"""
super(TurnOffResponse, self).__init__(**kwargs)
self._bytes = bytes(tokens.OFF)
MAP = MapNameResponse
MDF = MapDefinitionResponse
HLO = HelloResponse
SCO = SupplyCenterResponse
NOW = CurrentPositionResponse
THX = ThanksResponse
MIS = MissingOrdersResponse
ORD = OrderResultResponse
TME = TimeToDeadlineResponse
YES = AcceptResponse
REJ = RejectResponse
NOT = NotResponse
CCD = PowerInCivilDisorderResponse
OUT = PowerIsEliminatedResponse
OFF = TurnOffResponse
PRN = ParenthesisErrorResponse
HUH = SyntaxErrorResponse