mirror of
https://github.com/GoodStartLabs/AI_Diplomacy.git
synced 2026-04-19 12:58:09 +00:00
440 lines
29 KiB
Python
440 lines
29 KiB
Python
# ==============================================================================
|
|
# 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/>.
|
|
# ==============================================================================
|
|
""" Contains the list of valid tokens and their byte representation """
|
|
|
|
# Constants
|
|
BYTES_TO_STR = {} # (0x46, 0x04) -> 'ECS'
|
|
STR_TO_BYTES = {} # 'ECS' -> (0x46, 0x04)
|
|
ASCII_BYTE = 0x4B # Byte identifying an ASCII char
|
|
|
|
# Utilities
|
|
class Token:
|
|
""" Contains the representation of a token """
|
|
|
|
def __init__(self, from_str=None, from_int=None, from_bytes=None):
|
|
""" Initialize a token from its string representation, or from its bytes representation
|
|
|
|
:param from_str: The string representation of the token
|
|
:param from_int: The integer representation of the token
|
|
:param from_bytes: The byte representation of the token
|
|
"""
|
|
self.repr_str = ''
|
|
self.repr_int = None
|
|
self.repr_bytes = b''
|
|
|
|
# From string
|
|
if from_str is not None:
|
|
assert from_int is None, 'Cannot provide both a string and an integer'
|
|
assert from_bytes is None, 'Cannot provide both a string and bytes'
|
|
self._load_from_str(str(from_str))
|
|
|
|
# From integer
|
|
elif from_int is not None:
|
|
assert from_bytes is None, 'Cannot provide both an integer and bytes'
|
|
self._load_from_int(int(from_int))
|
|
|
|
# From bytes
|
|
elif from_bytes is not None:
|
|
self._load_from_bytes(from_bytes)
|
|
|
|
else:
|
|
raise ValueError('You must provide a string, integer, or bytes representation')
|
|
|
|
def _load_from_str(self, from_str):
|
|
""" Creates a token from a DAIDE string representation"""
|
|
assert isinstance(from_str, str), 'Expected a string'
|
|
|
|
# 1) Known token
|
|
# 2) ASCII Text
|
|
if from_str in STR_TO_BYTES:
|
|
self.repr_str = BYTES_TO_STR[STR_TO_BYTES[from_str]]
|
|
self.repr_bytes = STR_TO_BYTES[from_str]
|
|
elif len(from_str) == 1 and ord(from_str[0]) <= 255:
|
|
self.repr_str = from_str
|
|
self.repr_bytes = bytes((ASCII_BYTE, ord(from_str[0])))
|
|
else:
|
|
raise ValueError('Unable to parse %s as a token' % from_str)
|
|
|
|
def _load_from_int(self, from_int):
|
|
""" Creates a token from an integer representation """
|
|
assert isinstance(from_int, int), 'Expected an integer'
|
|
|
|
# Integers - Encoded as 14 bits
|
|
if from_int > 8191 or from_int < -8192:
|
|
raise ValueError('Valid values for strings are -8192 to +8191.')
|
|
|
|
# Negative numbers start with a 1
|
|
prefix = '0'
|
|
if from_int < 0:
|
|
prefix = '1'
|
|
from_int += 8192
|
|
|
|
# Encoding the number as 14 bit. + a prefix of '00' for a total of 16 bit
|
|
bit_encoding = bin(from_int)[2:]
|
|
bit_encoding = '00' + prefix + '0' * (13 - len(bit_encoding)) + bit_encoding
|
|
self.repr_str = str(from_int)
|
|
self.repr_int = from_int
|
|
self.repr_bytes = bytes((int(bit_encoding[0:8], 2), int(bit_encoding[8:16], 2)))
|
|
|
|
def _load_from_bytes(self, from_bytes):
|
|
""" Creates a token from its bytes representation """
|
|
if isinstance(from_bytes, tuple):
|
|
from_bytes = bytes(from_bytes)
|
|
if len(from_bytes) != 2:
|
|
raise ValueError('Expected a couple of 2 bytes 0x000xFF. Got [{}]' \
|
|
.format(''.join([hex(b) for b in from_bytes])))
|
|
|
|
# Known token
|
|
if from_bytes in BYTES_TO_STR:
|
|
self.repr_str = BYTES_TO_STR[from_bytes]
|
|
self.repr_bytes = from_bytes
|
|
|
|
# Ascii text
|
|
elif from_bytes[0] == ASCII_BYTE:
|
|
self.repr_str = chr(from_bytes[1])
|
|
self.repr_bytes = from_bytes
|
|
|
|
# Integer
|
|
elif from_bytes[0] < 64:
|
|
bin_0, bin_1 = bin(from_bytes[0])[2:], bin(from_bytes[1])[2:]
|
|
from_binary = '0' * (6 - len(bin_0)) + bin_0 + '0' * (8 - len(bin_1)) + bin_1
|
|
is_negative = int(from_binary[0] == '1')
|
|
self.repr_int = is_negative * -8192 + int(from_binary[1:14], 2)
|
|
self.repr_str = str(self.repr_int)
|
|
self.repr_bytes = from_bytes
|
|
|
|
else:
|
|
# Unknown value
|
|
raise ValueError('Unable to parse bytes %s as a token' % (from_bytes,))
|
|
|
|
def __bytes__(self):
|
|
""" Returns bytes representation """
|
|
return self.repr_bytes
|
|
|
|
def __int__(self):
|
|
""" Returns integer representation """
|
|
return self.repr_int
|
|
|
|
def __str__(self):
|
|
""" Returns string representation """
|
|
return self.repr_str
|
|
|
|
def __eq__(self, other):
|
|
""" Define the equal """
|
|
return isinstance(other, Token) and ((self.repr_int and self.repr_int == other.repr_int)
|
|
or self.repr_str == other.repr_str)
|
|
|
|
def is_ascii_token(token):
|
|
""" Check if the token is an ascii token
|
|
|
|
:param token: An instance of Token
|
|
:return: True if `token` is an acsii token. False otherwise
|
|
"""
|
|
return isinstance(token, Token) and \
|
|
len(token.repr_bytes) == 2 and token.repr_bytes[0] == ASCII_BYTE
|
|
|
|
def is_integer_token(token):
|
|
""" Check if the token is an integer token
|
|
|
|
:param token: An instance of Token
|
|
:return: True if `token` is an integer token. False otherwise
|
|
"""
|
|
return isinstance(token, Token) and \
|
|
len(token.repr_bytes) == 2 and token.repr_bytes[0] < 64
|
|
|
|
def register_token(str_repr, bytes_repr):
|
|
""" Registers a token in the registry
|
|
|
|
:param str_repr: The DAIDE string representation of the token (e.g. 'ECS')
|
|
:param bytes_repr: The bytes representation of the token (i.e. bytes of length 2)
|
|
:return: The token that has been registered
|
|
"""
|
|
if str_repr in STR_TO_BYTES:
|
|
raise ValueError('String %s has already been registered.' % str_repr)
|
|
if bytes_repr in BYTES_TO_STR:
|
|
raise ValueError('Bytes %s have already been registered.' % bytes_repr)
|
|
STR_TO_BYTES[str_repr] = bytes_repr
|
|
BYTES_TO_STR[bytes_repr] = str_repr
|
|
return Token(from_str=str_repr)
|
|
|
|
|
|
# ------------------------
|
|
# Registering tokens
|
|
# Coasts
|
|
ECS = register_token('ECS', b'\x46\x04') # ECS Coast East Coast
|
|
NCS = register_token('NCS', b'\x46\x00') # NCS Coast North Coast
|
|
NEC = register_token('NEC', b'\x46\x02') # NEC Coast North East Coast
|
|
NWC = register_token('NWC', b'\x46\x0E') # NWC Coast North West Coast
|
|
SCS = register_token('SCS', b'\x46\x08') # SCS Coast South Coast
|
|
SEC = register_token('SEC', b'\x46\x06') # SEC Coast South East Coast
|
|
SWC = register_token('SWC', b'\x46\x0A') # SWC Coast South West Coast
|
|
WCS = register_token('WCS', b'\x46\x0C') # WCS Coast West Coast
|
|
COAST_TOKENS = [ECS, NCS, NEC, NWC, SCS, SEC, SWC, WCS]
|
|
|
|
# Orders
|
|
BLD = register_token('BLD', b'\x43\x80') # BLD Order Build Phase Build
|
|
CTO = register_token('CTO', b'\x43\x20') # CTO Order Movement Phase Move by Convoy to
|
|
CVY = register_token('CVY', b'\x43\x21') # CVY Order Movement Phase Convoy
|
|
DSB = register_token('DSB', b'\x43\x40') # DSB Order Retreat Phase Disband
|
|
HLD = register_token('HLD', b'\x43\x22') # HLD Order Movement Phase Hold
|
|
MTO = register_token('MTO', b'\x43\x23') # MTO Order Movement Phase Move To
|
|
REM = register_token('REM', b'\x43\x81') # REM Order Build Phase Remove
|
|
RTO = register_token('RTO', b'\x43\x41') # RTO Order Retreat Phase Retreat to
|
|
SUP = register_token('SUP', b'\x43\x24') # SUP Order Movement Phase Support
|
|
VIA = register_token('VIA', b'\x43\x25') # VIA Order Movement Phase Move via
|
|
WVE = register_token('WVE', b'\x43\x82') # WVE Order Build Phase Waive
|
|
ORDER_TOKENS = [BLD, CTO, CVY, DSB, HLD, MTO, REM, RTO, SUP, VIA, WVE]
|
|
MOVEMENT_ORDER_TOKENS = [CTO, CVY, HLD, MTO, SUP]
|
|
RETREAT_ORDER_TOKENS = [RTO, DSB]
|
|
BUILD_ORDER_TOKENS = [BLD, REM, WVE]
|
|
|
|
# Seasons
|
|
AUT = register_token('AUT', b'\x47\x03') # AUT Phase Fall Retreats
|
|
FAL = register_token('FAL', b'\x47\x02') # FAL Phase Fall Movements
|
|
SPR = register_token('SPR', b'\x47\x00') # SPR Phase Spring Movement
|
|
SUM = register_token('SUM', b'\x47\x01') # SUM Phase Spring Retreats
|
|
WIN = register_token('WIN', b'\x47\x04') # WIN Phase Fall Builds
|
|
SEASON_TOKENS = [AUT, FAL, SPR, SUM, WIN]
|
|
|
|
# Powers
|
|
AUS = register_token('AUS', b'\x41\x00') # AUS Power Austria
|
|
ENG = register_token('ENG', b'\x41\x01') # ENG Power England
|
|
FRA = register_token('FRA', b'\x41\x02') # FRA Power France
|
|
GER = register_token('GER', b'\x41\x03') # GER Power Germany
|
|
ITA = register_token('ITA', b'\x41\x04') # ITA Power Italy
|
|
RUS = register_token('RUS', b'\x41\x05') # RUS Power Russia
|
|
TUR = register_token('TUR', b'\x41\x06') # TUR Power Turkey
|
|
POWER_TOKENS = [AUS, ENG, FRA, GER, ITA, RUS, TUR]
|
|
|
|
# Units
|
|
AMY = register_token('AMY', b'\x42\x00') # AMY Unit Type Army
|
|
FLT = register_token('FLT', b'\x42\x01') # FLT Unit Type Fleet
|
|
|
|
# Symbols
|
|
OPE_PAR = register_token('(', b'\x40\x00') # BRA - ( - Opening Bracket
|
|
CLO_PAR = register_token(')', b'\x40\x01') # KET - ) - Closing Bracket
|
|
|
|
# Provinces
|
|
ADR = register_token('ADR', b'\x52\x0E') # ADR Province Sea Adriatic Sea
|
|
AEG = register_token('AEG', b'\x52\x0F') # AEG Province Sea Aegean Sea
|
|
ALB = register_token('ALB', b'\x54\x21') # ALB Province Coastal Albania
|
|
ANK = register_token('ANK', b'\x55\x30') # ANK Province Coastal Supply Center Ankara
|
|
APU = register_token('APU', b'\x54\x22') # APU Province Coastal Apulia
|
|
ARM = register_token('ARM', b'\x54\x23') # ARM Province Coastal Armenia
|
|
BAL = register_token('BAL', b'\x52\x10') # BAL Province Sea Baltic Sea
|
|
BAR = register_token('BAR', b'\x52\x11') # BAR Province Sea Barents Sea
|
|
BEL = register_token('BEL', b'\x55\x31') # BEL Province Coastal Supply Center Belgium
|
|
BER = register_token('BER', b'\x55\x32') # BER Province Coastal Supply Center Berlin
|
|
BLA = register_token('BLA', b'\x52\x12') # BLA Province Sea Black Sea
|
|
BOH = register_token('BOH', b'\x50\x00') # BOH Province Inland Bohemia
|
|
BRE = register_token('BRE', b'\x55\x33') # BRE Province Coastal Supply Center Brest
|
|
BUD = register_token('BUD', b'\x51\x07') # BUD Province Inland Supply Center Budapest
|
|
BUL = register_token('BUL', b'\x57\x48') # BUL Province Bicoastal Supply Center Bulgaria
|
|
BUR = register_token('BUR', b'\x50\x01') # BUR Province Inland Burgundy
|
|
CLY = register_token('CLY', b'\x54\x24') # CLY Province Coastal Clyde
|
|
CON = register_token('CON', b'\x55\x34') # CON Province Coastal Supply Center Constantinople
|
|
DEN = register_token('DEN', b'\x55\x35') # DEN Province Coastal Supply Center Denmark
|
|
EAS = register_token('EAS', b'\x52\x13') # EAS Province Sea Eastern Mediterranean Sea
|
|
ECH = register_token('ECH', b'\x52\x14') # ECH Province Sea English Channel
|
|
EDI = register_token('EDI', b'\x55\x36') # EDI Province Coastal Supply Center Edinburgh
|
|
FIN = register_token('FIN', b'\x54\x25') # FIN Province Coastal Finland
|
|
GAL = register_token('GAL', b'\x50\x02') # GAL Province Inland Galecia
|
|
GAS = register_token('GAS', b'\x54\x26') # GAS Province Coastal Gascony
|
|
GOB = register_token('GOB', b'\x52\x15') # GOB Province Sea Gulf of Bothnia
|
|
GOL = register_token('GOL', b'\x52\x16') # GOL Province Sea Gulf of Lyons
|
|
GRE = register_token('GRE', b'\x55\x37') # GRE Province Coastal Supply Center Greece
|
|
HEL = register_token('HEL', b'\x52\x17') # HEL Province Sea Helgoland Bight
|
|
HOL = register_token('HOL', b'\x55\x38') # HOL Province Coastal Supply Center Holland
|
|
ION = register_token('ION', b'\x52\x18') # ION Province Sea Ionian Sea
|
|
IRI = register_token('IRI', b'\x52\x19') # IRI Province Sea Irish Sea
|
|
KIE = register_token('KIE', b'\x55\x39') # KIE Province Coastal Supply Center Kiel
|
|
LON = register_token('LON', b'\x55\x3A') # LON Province Coastal Supply Center London
|
|
LVN = register_token('LVN', b'\x54\x27') # LVN Province Coastal Livonia
|
|
LVP = register_token('LVP', b'\x55\x3B') # LVP Province Coastal Supply Center Liverpool
|
|
MAO = register_token('MAO', b'\x52\x1A') # MAO Province Sea Mid Atlantic Ocean
|
|
MAR = register_token('MAR', b'\x55\x3C') # MAR Province Coastal Supply Center Marseilles
|
|
MOS = register_token('MOS', b'\x51\x08') # MOS Province Inland Supply Center Moscow
|
|
MUN = register_token('MUN', b'\x51\x09') # MUN Province Inland Supply Center Munich
|
|
NAF = register_token('NAF', b'\x54\x28') # NAF Province Coastal North Africa
|
|
NAO = register_token('NAO', b'\x52\x1B') # NAO Province Sea North Atlantic Ocean
|
|
NAP = register_token('NAP', b'\x55\x3D') # NAP Province Coastal Supply Center Naples
|
|
NTH = register_token('NTH', b'\x52\x1C') # NTH Province Sea North Sea
|
|
NWG = register_token('NWG', b'\x52\x1D') # NWG Province Sea Norwegian Sea
|
|
NWY = register_token('NWY', b'\x55\x3E') # NWY Province Coastal Supply Center Norway
|
|
PAR = register_token('PAR', b'\x51\x0A') # PAR Province Inland Supply Center Paris
|
|
PIC = register_token('PIC', b'\x54\x29') # PIC Province Coastal Picardy
|
|
PIE = register_token('PIE', b'\x54\x2A') # PIE Province Coastal Piedmont
|
|
POR = register_token('POR', b'\x55\x3F') # POR Province Coastal Supply Center Portugal
|
|
PRU = register_token('PRU', b'\x54\x2B') # PRU Province Coastal Prussia
|
|
ROM = register_token('ROM', b'\x55\x40') # ROM Province Coastal Supply Center Rome
|
|
RUH = register_token('RUH', b'\x50\x03') # RUH Province Inland Ruhr
|
|
RUM = register_token('RUM', b'\x55\x41') # RUM Province Coastal Supply Center Rumania
|
|
SER = register_token('SER', b'\x51\x0B') # SER Province Inland Supply Center Serbia
|
|
SEV = register_token('SEV', b'\x55\x42') # SEV Province Coastal Supply Center Sevastopol
|
|
SIL = register_token('SIL', b'\x50\x04') # SIL Province Inland Silesia
|
|
SKA = register_token('SKA', b'\x52\x1E') # SKA Province Sea Skaggerack
|
|
SMY = register_token('SMY', b'\x55\x43') # SMY Province Coastal Supply Center Smyrna
|
|
SPA = register_token('SPA', b'\x57\x49') # SPA Province Bicoastal Supply Center Spain
|
|
STP = register_token('STP', b'\x57\x4A') # STP Province Bicoastal Supply Center St Petersburg
|
|
SWE = register_token('SWE', b'\x55\x44') # SWE Province Coastal Supply Center Sweden
|
|
SYR = register_token('SYR', b'\x54\x2C') # SYR Province Coastal Syria
|
|
TRI = register_token('TRI', b'\x55\x45') # TRI Province Coastal Supply Center Trieste
|
|
TUN = register_token('TUN', b'\x55\x46') # TUN Province Coastal Supply Center Tunis
|
|
TUS = register_token('TUS', b'\x54\x2D') # TUS Province Coastal Tuscany
|
|
TYR = register_token('TYR', b'\x50\x05') # TYR Province Inland Tyrolia
|
|
TYS = register_token('TYS', b'\x52\x1F') # TYS Province Sea Tyrrhenian Sea
|
|
UKR = register_token('UKR', b'\x50\x06') # UKR Province Inland Ukraine
|
|
VEN = register_token('VEN', b'\x55\x47') # VEN Province Coastal Supply Center Venice
|
|
VIE = register_token('VIE', b'\x51\x0C') # VIE Province Inland Supply Center Vienna
|
|
WAL = register_token('WAL', b'\x54\x2E') # WAL Province Coastal Wales
|
|
WAR = register_token('WAR', b'\x51\x0D') # WAR Province Inland Supply Center Warsaw
|
|
WES = register_token('WES', b'\x52\x20') # WES Province Sea Western Mediterranean Sea
|
|
YOR = register_token('YOR', b'\x54\x2F') # YOR Province Coastal Yorkshire
|
|
PROVINCE_TOKENS = [ADR, AEG, ALB, ANK, APU, ARM, BAL, BAR,
|
|
BEL, BER, BLA, BOH, BRE, BUD, BUL, BUR,
|
|
CLY, CON, DEN, EAS, ECH, EDI, FIN, GAL,
|
|
GAS, GOB, GOL, GRE, HEL, HOL, ION, IRI,
|
|
KIE, LON, LVN, LVP, MAO, MAR, MOS, MUN,
|
|
NAF, NAO, NAP, NTH, NWG, NWY, PAR, PIC,
|
|
PIE, POR, PRU, ROM, RUH, RUM, SER, SEV,
|
|
SIL, SKA, SMY, SPA, STP, SWE, SYR, TRI,
|
|
TUN, TUS, TYR, TYS, UKR, VEN, VIE, WAL,
|
|
WAR, WES, YOR]
|
|
|
|
# Commands
|
|
ADM = register_token('ADM', b'\x48\x1D') # AMD Command / Press Client <-> Server Admin Messages
|
|
CCD = register_token('CCD', b'\x48\x00') # CCD Command Server to Client Power in Civil Disorder
|
|
DRW = register_token('DRW', b'\x48\x01') # DRW Command / Press Client <-> Server Draw + NOT(DRW)
|
|
FRM = register_token('FRM', b'\x48\x02') # FRM Command / Press Server to Client Message From
|
|
GOF = register_token('GOF', b'\x48\x03') # GOF Command Client to Server Go Flag + NOT(GOF)
|
|
HLO = register_token('HLO', b'\x48\x04') # HLO Command Server to Client Hello (Start of Game)
|
|
HST = register_token('HST', b'\x48\x05') # HST Command Client to Server History
|
|
HUH = register_token('HUH', b'\x48\x06') # HUH Command / Press Server to Client Syntax Error
|
|
IAM = register_token('IAM', b'\x48\x07') # IAM Command Client to Server I am
|
|
LOD = register_token('LOD', b'\x48\x08') # LOD Command Server to Client Load Game
|
|
MAP = register_token('MAP', b'\x48\x09') # MAP Cmd Server to Client Map to be used for this game
|
|
MDF = register_token('MDF', b'\x48\x0A') # MDF Command Client <---> Server Map definition
|
|
MIS = register_token('MIS', b'\x48\x0B') # MIS Command Server to Client Missing Orders
|
|
NME = register_token('NME', b'\x48\x0C') # NME Command Client to Server Name
|
|
NOT = register_token('NOT', b'\x48\x0D') # NOT Command / Press Client <---> Server Logical NOT
|
|
NOW = register_token('NOW', b'\x48\x0E') # NOW Command Client <---> Server Current Position
|
|
OBS = register_token('OBS', b'\x48\x0F') # OBS Command Client to Server Observer
|
|
OFF = register_token('OFF', b'\x48\x10') # OFF Command Server to Client Turn Off (Exit)
|
|
ORD = register_token('ORD', b'\x48\x11') # ORD Command Server to Client Order Results
|
|
OUT = register_token('OUT', b'\x48\x12') # OUT Command Server to Client Power is Eliminated
|
|
PRN = register_token('PRN', b'\x48\x13') # PRN Command Server to Client Parenthesis error
|
|
REJ = register_token('REJ', b'\x48\x14') # REJ Command / Press Server to Client Reject
|
|
SCO = register_token('SCO', b'\x48\x15') # SCO Command Client <-> Server Supply Center Ownership
|
|
SLO = register_token('SLO', b'\x48\x16') # SLO Command Server to Client Solo
|
|
SMR = register_token('SMR', b'\x48\x1E') # SMR Command Server to Client Summary
|
|
SND = register_token('SND', b'\x48\x17') # SND Command / Press Client to Server Send Message
|
|
SUB = register_token('SUB', b'\x48\x18') # SUB Command Client to Server Submit Order
|
|
SVE = register_token('SVE', b'\x48\x19') # SVE Command Server to Client Save Game
|
|
THX = register_token('THX', b'\x48\x1A') # THX Command Server to Client Thanks for the order
|
|
TME = register_token('TME', b'\x48\x1B') # TME Command Client <---> Server Time to Deadline
|
|
YES = register_token('YES', b'\x48\x1C') # YES Command / Press Server to Client Accept
|
|
|
|
# Order Notes (ORD)
|
|
BNC = register_token('BNC', b'\x45\x01') # BNC Order Note ORD Move Bounced
|
|
CUT = register_token('CUT', b'\x45\x02') # CUT Order Note ORD Support Cut
|
|
DSR = register_token('DSR', b'\x45\x03') # DSR Order Note ORD Convoy Disrupted
|
|
FLD = register_token('FLD', b'\x45\x04') # FLD Order Note ORD REMOVED
|
|
NSO = register_token('NSO', b'\x45\x05') # NSO Order Note ORD No Such Order
|
|
RET = register_token('RET', b'\x45\x06') # RET Order Note ORD Unit must retreat
|
|
SUC = register_token('SUC', b'\x45\x00') # SUC Order Note ORD Order Succeeds
|
|
ORDER_RESULT_TOKENS = [BNC, CUT, DSR, NSO, SUC]
|
|
|
|
# Order Notes (THX)
|
|
BPR = register_token('BPR', b'\x44\x01') # BPR Order Note THX REMOVED
|
|
CST = register_token('CST', b'\x44\x02') # CST Order Note THX No Coast Specified
|
|
ESC = register_token('ESC', b'\x44\x03') # ESC Order Note THX Not an Empty Supply Center
|
|
FAR = register_token('FAR', b'\x44\x04') # FAR Order Note THX Not Adjacent
|
|
HSC = register_token('HSC', b'\x44\x05') # HSC Order Note THX Not a Home Supply Center
|
|
MBV = register_token('MBV', b'\x44\x00') # MBV Order Note THX Might Be Valid
|
|
NAS = register_token('NAS', b'\x44\x06') # NAS Order Note THX Not At Sea
|
|
NMB = register_token('NMB', b'\x44\x07') # NMB Order Note THX No More Builds Allowed
|
|
NMR = register_token('NMR', b'\x44\x08') # NMR Order Note THX No More Retreats Allowed
|
|
NRN = register_token('NRN', b'\x44\x09') # NRN Order Note THX No Retreat Needed
|
|
NRS = register_token('NRS', b'\x44\x0A') # NRS Order Note THX Not the Right Season
|
|
NSA = register_token('NSA', b'\x44\x0B') # NSA Order Note THX No Such Army
|
|
NSC = register_token('NSC', b'\x44\x0C') # NSC Order Note THX Not a Supply Center
|
|
NSF = register_token('NSF', b'\x44\x0D') # NSF Order Note THX No Such Fleet
|
|
NSP = register_token('NSP', b'\x44\x0E') # NSP Order Note THX No Such Province
|
|
NSU = register_token('NSU', b'\x44\x10') # NSU Order Note THX No Such Unit
|
|
NVR = register_token('NVR', b'\x44\x11') # NVR Order Note THX Not a Valid Retreat
|
|
NYU = register_token('NYU', b'\x44\x12') # NYU Order Note THX Not Your Unit
|
|
YSC = register_token('YSC', b'\x44\x13') # YSC Order Note THX Not Your Supply Center
|
|
ORDER_NOTE_TOKENS = [MBV, FAR, NSP, NSU, NAS, NSF, NSA, NYU,
|
|
NRN, NVR, YSC, ESC, HSC, NSC, CST, NMB,
|
|
NMR, NRS, FLD]
|
|
|
|
# Parameters
|
|
AOA = register_token('AOA', b'\x49\x00') # AOA Parameter HLO Any Orders Allowed
|
|
BTL = register_token('BTL', b'\x49\x01') # BTL Parameter HLO Build Time Limit
|
|
DSD = register_token('DSD', b'\x49\x0D') # DSD Parameter HLO Deadline stops on disconnect
|
|
ERR = register_token('ERR', b'\x49\x02') # ERR Parameter HUH Error location
|
|
LVL = register_token('LVL', b'\x49\x03') # LVL Parameter HLO Level (Language Level)
|
|
MRT = register_token('MRT', b'\x49\x04') # MRT Parameter NOW Must Retreat to
|
|
MTL = register_token('MTL', b'\x49\x05') # MTL Parameter HLO Movement Time Limit
|
|
NPB = register_token('NPB', b'\x49\x06') # NPB Parameter HLO No Press During Builds
|
|
NPR = register_token('NPR', b'\x49\x07') # NPR Parameter HLO No Press During Retreats
|
|
PDA = register_token('PDA', b'\x49\x08') # PDA Parameter HLO Partial Draws Allowed
|
|
PTL = register_token('PTL', b'\x49\x09') # PTL Parameter HLO Press Time Limit
|
|
RTL = register_token('RTL', b'\x49\x0A') # RTL Parameter HLO Retreat Time Limit
|
|
UNO = register_token('UNO', b'\x49\x0B') # UNO Parameter SCO Unowned
|
|
|
|
# Valid tokens for variant option
|
|
VARIANT_OPT_NUM_TOKENS = [LVL, MTL, RTL, BTL, PTL]
|
|
VARIANT_OPT_NO_NUM_TOKENS = [AOA, DSD, PDA, NPR, NPB]
|
|
|
|
# Press
|
|
ALY = register_token('ALY', b'\x4A\x00') # ALY Press Ally
|
|
AND = register_token('AND', b'\x4A\x01') # AND Press Logical AND
|
|
BCC = register_token('BCC', b'\x4A\x23') # BCC Press Request to Blind Carbon Copy
|
|
BWX = register_token('BWX', b'\x4A\x02') # BWX Press None of Your Business
|
|
CCL = register_token('CCL', b'\x4A\x26') # CCL Press Cancel
|
|
CHO = register_token('CHO', b'\x4A\x22') # CHO Press Choose
|
|
DMZ = register_token('DMZ', b'\x4A\x03') # DMZ Press Demilitarised Zone
|
|
ELS = register_token('ELS', b'\x4A\x04') # ELS Press IFF Else
|
|
EXP = register_token('EXP', b'\x4A\x05') # EXP Press Explain
|
|
FCT = register_token('FCT', b'\x4A\x06') # FCT Press Fact
|
|
FOR = register_token('FOR', b'\x4A\x07') # FOR Press For specified Turn
|
|
FWD = register_token('FWD', b'\x4A\x08') # FWD Press Request to Forward
|
|
HOW = register_token('HOW', b'\x4A\x09') # HOW Press How to attack
|
|
IDK = register_token('IDK', b'\x4A\x0A') # IDK Press I Do Not Know
|
|
IFF = register_token('IFF', b'\x4A\x0B') # IFF Press If
|
|
INS = register_token('INS', b'\x4A\x0C') # INS Press Insist
|
|
NAR = register_token('NAR', b'\x4A\x25') # NAR Press No Agreement
|
|
OCC = register_token('OCC', b'\x4A\x0E') # OCC Press Occupy
|
|
ORR = register_token('ORR', b'\x4A\x0F') # ORR Press Logical OR
|
|
PCE = register_token('PCE', b'\x4A\x10') # PCE Press Peace
|
|
POB = register_token('POB', b'\x4A\x11') # POB Press Position on Board
|
|
PRP = register_token('PRP', b'\x4A\x13') # PRP Press Propose
|
|
QRY = register_token('QRY', b'\x4A\x14') # QRY Press Query
|
|
SCD = register_token('SCD', b'\x4A\x15') # SCD Press Supply Center Distribution
|
|
SRY = register_token('SRY', b'\x4A\x16') # SRY Press Sorry
|
|
SUG = register_token('SUG', b'\x4A\x17') # SUG Press Suggest
|
|
THK = register_token('THK', b'\x4A\x18') # THK Press Think
|
|
THN = register_token('THN', b'\x4A\x19') # THN Press IFF Then
|
|
TRY = register_token('TRY', b'\x4A\x1A') # TRY Press Try the following tokens
|
|
UNT = register_token('UNT', b'\x4A\x24') # UNT Press OCC Unit
|
|
VSS = register_token('VSS', b'\x4A\x1C') # VSS Press ALY Versus
|
|
WHT = register_token('WHT', b'\x4A\x1D') # WHT Press What to do with
|
|
WHY = register_token('WHY', b'\x4A\x1E') # WHY Press Why
|
|
XDO = register_token('XDO', b'\x4A\x1F') # XDO Press Moves to do
|
|
XOY = register_token('XOY', b'\x4A\x20') # XOY Press X owes Y
|
|
YDO = register_token('YDO', b'\x4A\x21') # YDO Press You provide the order for these units
|