def test_sequence_type():
""" Test sequence type. """
# With default sequence builder.
checker = parsing.SequenceType(int)
checker.validate((1, 2, 3))
checker.validate([1, 2, 3])
checker.validate({1, 2, 3})
checker.validate(SortedSet(int))
checker.validate(SortedSet(int, (1, 2, 3)))
assert_raises(lambda: checker.validate((1, 2, 3.0)),
exceptions.TypeException)
assert_raises(lambda: checker.validate((1.0, 2.0, 3.0)),
exceptions.TypeException)
assert isinstance(checker.to_type((1, 2, 3)), list)
# With SortedSet as sequence builder.
checker = parsing.SequenceType(float)
checker.validate((1.0, 2.0, 3.0))
checker.validate([1.0, 2.0, 3.0])
checker.validate({1.0, 2.0, 3.0})
assert_raises(lambda: checker.validate((1, 2, 3.0)),
exceptions.TypeException)
assert_raises(lambda: checker.validate((1.0, 2.0, 3)),
exceptions.TypeException)
checker = parsing.SequenceType(int,
sequence_builder=SortedSet.builder(int))
initial_list = (1, 2, 7, 7, 1)
checker.validate(initial_list)
updated_list = checker.update(initial_list)
assert isinstance(updated_list,
SortedSet) and updated_list.element_type is int
assert updated_list == SortedSet(int, (1, 2, 7))
assert checker.to_json(updated_list) == [1, 2, 7]
assert checker.to_type([7, 2, 1, 1, 7, 1, 7]) == updated_list
class GamePhaseData(Jsonable):
""" Small class to represent data for a game phase:
phase name, state, orders, orders results and messages for this phase.
"""
__slots__ = ['name', 'state', 'orders', 'results', 'messages']
model = {
strings.NAME:
str,
strings.STATE:
dict,
strings.ORDERS:
parsing.DictType(str,
parsing.OptionalValueType(parsing.SequenceType(str))),
strings.RESULTS:
parsing.DictType(
str,
parsing.SequenceType(parsing.StringableType(
common.StringableCode))),
strings.MESSAGES:
MESSAGES_TYPE,
}
def __init__(self, name, state, orders, results, messages):
""" Constructor. """
self.name = ''
self.state = {}
self.orders = {}
self.results = {}
self.messages = {}
super(GamePhaseData, self).__init__(name=name,
state=state,
orders=orders,
results=results,
messages=messages)
class SetGameState(_AbstractGameRequest):
""" Game request to set a game state (for exper users). Require game master privileges.
:param state: game state
:param orders: dictionary mapping a power name to a list of orders strings
:param results: dictionary mapping a unit to a list of order result strings
:param messages: dictionary mapping a timestamp to a message
:type state: dict
:type orders: dict
:type results: dict
:type messages: dict
:return: None
"""
__slots__ = ['state', 'orders', 'results', 'messages']
params = {
strings.STATE:
dict,
strings.ORDERS:
parsing.DictType(str, parsing.SequenceType(str)),
strings.RESULTS:
parsing.DictType(str, parsing.SequenceType(str)),
strings.MESSAGES:
parsing.DictType(int, parsing.JsonableClassType(Message),
SortedDict.builder(int, Message)),
}
def __init__(self, **kwargs):
self.state = {}
self.orders = {}
self.results = {}
self.messages = {} # type: SortedDict
super(SetGameState, self).__init__(**kwargs)
class MyJsonable(Jsonable):
""" Example of class derived from Jsonable. """
__slots__ = ('field_a', 'field_b', 'field_c', 'field_d', 'field_e',
'field_f', 'field_g')
model = {
'field_a':
bool,
'field_b':
str,
'field_c':
parsing.OptionalValueType(float),
'field_d':
parsing.DefaultValueType(str, 'super'),
'field_e':
parsing.SequenceType(int),
'field_f':
parsing.SequenceType(float, sequence_builder=SortedSet.builder(float)),
'field_g':
parsing.DefaultValueType(
parsing.DictType(str, int, SortedDict.builder(str, int)),
{'x': -1})
}
def __init__(self, **kwargs):
""" Constructor """
self.field_a = None
self.field_b = None
self.field_c = None
self.field_d = None
self.field_e = None
self.field_f = None
self.field_g = {}
super(MyJsonable, self).__init__(**kwargs)
class JoinPowers(_AbstractChannelRequest):
""" Channel request to join many powers of a game with one request.
This request is mostly identical to :class:`.JoinGame`, except that list of power names
is mandatory. It's useful to allow the user to control many powers while still working
with 1 client game instance.
:param game_id: ID of game to join
:param power_names: list of power names to join
:param registration_password: password to join the game
:type game_id: str
:type power_names: list, optional
:type registration_password: str, optionl
:return: None. If request succeeds, then the user is registered as player for all
given power names. The user can then simply join game to one of these powers (by sending
a :class:`.JoinGame` request), and he will be able to manage all the powers through
the client game returned by :class:`.JoinGame`.
"""
__slots__ = ['game_id', 'power_names', 'registration_password']
params = {
strings.GAME_ID: str,
strings.POWER_NAMES: parsing.SequenceType(str, sequence_builder=set),
strings.REGISTRATION_PASSWORD: parsing.OptionalValueType(str)
}
def __init__(self, **kwargs):
self.game_id = None
self.power_names = None
self.registration_password = None
super(JoinPowers, self).__init__(**kwargs)
class SetOrders(_AbstractGameRequest):
""" Game request to set orders for a power.
:param power_name: power name. If not given, request user must be a game player,
and power is inferred from request game role.
:param orders: list of power orders.
:param wait: if provided, wait flag to set for this power.
:type power_name: str, optional
:type orders: list
:type wait: bool, optional
:return: None
"""
__slots__ = ['power_name', 'orders', 'wait']
params = {
strings.POWER_NAME:
parsing.OptionalValueType(str), # required only for game master.
strings.ORDERS: parsing.SequenceType(str),
strings.WAIT: parsing.OptionalValueType(bool)
}
def __init__(self, **kwargs):
self.power_name = None
self.orders = None
self.wait = None
super(SetOrders, self).__init__(**kwargs)
class DataGamePhases(UniqueData):
""" Unique data containing a list of :class:`.GamePhaseData` objects. """
__slots__ = []
params = {
strings.DATA:
parsing.SequenceType(parsing.JsonableClassType(GamePhaseData))
}
class DataGames(UniqueData):
""" Unique data containing a list of :class:`.DataGameInfo` objects. """
__slots__ = []
params = {
# list of game info.
strings.DATA:
parsing.SequenceType(parsing.JsonableClassType(DataGameInfo))
}
class PowerOrdersUpdate(_GameNotification):
""" Notification about a power order update. """
__slots__ = ['orders']
params = {
strings.ORDERS: parsing.OptionalValueType(parsing.SequenceType(str)),
}
def __init__(self, **kwargs):
self.orders = None # type: set
super(PowerOrdersUpdate, self).__init__(**kwargs)
class GetGamesInfo(_AbstractChannelRequest):
""" Request used to get info for a given list of game IDs.
Expected response: responses.DataGames
Expected response handler result: responses.DataGames
"""
__slots__ = ['games']
params = {strings.GAMES: parsing.SequenceType(str)}
def __init__(self, **kwargs):
self.games = []
super(GetGamesInfo, self).__init__(**kwargs)
class SubmitOrdersRequest(DaideRequest):
""" Represents a SUB DAIDE request. Sent by the client to submit orders.
Syntax: ::
SUB (order) (order) ...
SUB (turn) (order) (order) ...
order syntax: ::
(unit) HLD # Hold
(unit) MTO province # Move to
(unit) SUP (unit) # Support
(unit) SUP (unit) MTO (prov_no_coast) # Support to move
(unit) CVY (unit) CTO province # Convoy
(unit) CTO province VIA (sea_prov sea_prov ...) # Convoy to via provinces
(unit) RTO province # Retreat to
(unit) DSB # Disband (R phase)
(unit) BLD # Build
(unit) REM # Remove (A phase)
(unit) WVE # Waive
"""
__slots__ = ['power_name', 'orders']
params = {
strings.POWER_NAME: parsing.OptionalValueType(str),
strings.ORDERS: parsing.SequenceType(str)
}
def __init__(self, **kwargs):
""" Constructor """
self.power_name = None
self.phase = ''
self.orders = []
super(SubmitOrdersRequest, self).__init__(power_name='', orders=[], **kwargs)
def parse_bytes(self, daide_bytes):
""" Builds the request from DAIDE bytes """
super(SubmitOrdersRequest, self).parse_bytes(daide_bytes)
orders = []
# Parsing
lead_token, daide_bytes = parse_bytes(SingleToken, daide_bytes)
turn, daide_bytes = parse_bytes(Turn, daide_bytes, on_error='ignore')
while daide_bytes:
order, daide_bytes = parse_bytes(Order, daide_bytes)
orders += [order]
assert str(lead_token) == 'SUB', 'Expected SUB request'
assert not daide_bytes, '%s bytes remaining. Request is malformed' % len(daide_bytes)
# Setting properties
self.phase = '' if not turn else str(turn)
self.power_name = None if not orders or not orders[0].power_name else str(orders[0].power_name)
self.orders = [str(order) for order in orders]
class DataPossibleOrders(_AbstractResponse):
""" Response containing information about possible orders for a game at its current phase.
Properties:
- **possible_orders**: dictionary mapping a location short name to all possible orders here
- **orderable_locations**: dictionary mapping a power name to its orderable locations
"""
__slots__ = ['possible_orders', 'orderable_locations']
params = {
# {location => [orders]}
strings.POSSIBLE_ORDERS:
parsing.DictType(str, parsing.SequenceType(str)),
# {power name => [locations]}
strings.ORDERABLE_LOCATIONS:
parsing.DictType(str, parsing.SequenceType(str)),
}
def __init__(self, **kwargs):
self.possible_orders = {}
self.orderable_locations = {}
super(DataPossibleOrders, self).__init__(**kwargs)
class SetGameState(_AbstractGameRequest):
""" Request to set a game state.
Expected response: responses.Ok
Expected response handler result: None
"""
__slots__ = ['state', 'orders', 'results', 'messages']
params = {
strings.STATE:
dict,
strings.ORDERS:
parsing.DictType(str, parsing.SequenceType(str)),
strings.RESULTS:
parsing.DictType(str, parsing.SequenceType(str)),
strings.MESSAGES:
parsing.DictType(int, parsing.JsonableClassType(Message),
SortedDict.builder(int, Message)),
}
def __init__(self, **kwargs):
self.state = {}
self.orders = {}
self.results = {}
self.messages = {} # type: SortedDict
super(SetGameState, self).__init__(**kwargs)
class GetGamesInfo(_AbstractChannelRequest):
""" Channel request to get information for a given list of game indices.
:param games: list of game ID.
:type games: list
:return:
- Server: :class:`.DataGames`
- Client: a list of :class:`.DataGameInfo` objects.
"""
__slots__ = ['games']
params = {strings.GAMES: parsing.SequenceType(str)}
def __init__(self, **kwargs):
self.games = []
super(GetGamesInfo, self).__init__(**kwargs)
class SetDummyPowers(_AbstractGameRequest):
""" SetDummyPowers request.
Expected response: responses.Ok
Expected response handler result: None
"""
__slots__ = ['username', 'power_names']
params = {
strings.USERNAME: parsing.OptionalValueType(str),
strings.POWER_NAMES:
parsing.OptionalValueType(parsing.SequenceType(str)),
}
def __init__(self, **kwargs):
self.username = None
self.power_names = None
super(SetDummyPowers, self).__init__(**kwargs)
class JoinPowers(_AbstractChannelRequest):
""" JoinPowers request to join many powers of a game with one query.
Useful to control many powers while still working only with 1 client game instance.
Expected response: responses.Ok
Expected response handler result: None
"""
__slots__ = ['game_id', 'power_names', 'registration_password']
params = {
strings.GAME_ID: str,
strings.POWER_NAMES: parsing.SequenceType(str, sequence_builder=set),
strings.REGISTRATION_PASSWORD: parsing.OptionalValueType(str)
}
def __init__(self, **kwargs):
self.game_id = None
self.power_names = None
self.registration_password = None
super(JoinPowers, self).__init__(**kwargs)
class SetOrders(_AbstractGameRequest):
""" SetOrders request.
Expected response: responses.Ok
Expected response handler result: None
"""
__slots__ = ['power_name', 'orders', 'wait']
params = {
strings.POWER_NAME:
parsing.OptionalValueType(str), # required only for game master.
strings.ORDERS: parsing.SequenceType(str),
strings.WAIT: parsing.OptionalValueType(bool)
}
def __init__(self, **kwargs):
self.power_name = None
self.orders = None
self.wait = None
super(SetOrders, self).__init__(**kwargs)
class DrawRequest(DaideRequest):
""" Represents a DRW DAIDE request. Sent by the client to notify that the client would accept a draw.
Syntax: ::
DRW
LVL 10: ::
DRW (power power ...)
"""
__slots__ = ['powers']
params = {
strings.POWERS: parsing.SequenceType(str)
}
def __init__(self, **kwargs):
""" Constructor """
self.powers = []
super(DrawRequest, self).__init__(powers=[], **kwargs)
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]
class Version3(Jsonable):
""" Version 1 with a modified, b removed, e added.
To parse a dict between Version3 and Version1:
- a must be convertible in both versions.
- b must be optional in Version1.
- e must be optional in Version3.
"""
model = {
'a': parsing.ConverterType(str, converter_function=str),
'c': float,
'd': bool,
'e': parsing.OptionalValueType(parsing.SequenceType(int))
}
def __init__(self, **kwargs):
self.a = None
self.c = None
self.d = None
self.e = None
super(Version3, self).__init__(**kwargs)
class SetDummyPowers(_AbstractGameRequest):
""" Game request to set dummy powers. Require game master privileges.
If given powers are controlled, related players are kicked
and powers become dummy (uncontrolled).
:param power_names: list of power names to set dummy. If not provided, will be all map power names.
:param username: if provided, only power names controlled by this user will be set dummy.
:type power_names: list, optional
:type user_name: str, optional
:return: None
"""
__slots__ = ['username', 'power_names']
params = {
strings.USERNAME: parsing.OptionalValueType(str),
strings.POWER_NAMES:
parsing.OptionalValueType(parsing.SequenceType(str)),
}
def __init__(self, **kwargs):
self.username = None
self.power_names = None
super(SetDummyPowers, self).__init__(**kwargs)
class CreateGame(_AbstractChannelRequest):
""" CreateGame request.
Expected response: responses.DataGame
Expected response handler result: diplomacy.client.network_game.NetworkGame
"""
__slots__ = [
'game_id', 'power_name', 'state', 'map_name', 'rules', 'n_controls',
'deadline', 'registration_password'
]
params = {
strings.GAME_ID:
parsing.OptionalValueType(str),
strings.N_CONTROLS:
parsing.OptionalValueType(int),
strings.DEADLINE:
parsing.DefaultValueType(int, 300), # 300 seconds. Must be >= 0.
strings.REGISTRATION_PASSWORD:
parsing.OptionalValueType(str),
strings.POWER_NAME:
parsing.OptionalValueType(str),
strings.STATE:
parsing.OptionalValueType(dict),
strings.MAP_NAME:
parsing.DefaultValueType(str, 'standard'),
strings.RULES:
parsing.OptionalValueType(
parsing.SequenceType(str, sequence_builder=set)),
}
def __init__(self, **kwargs):
self.game_id = ''
self.n_controls = 0
self.deadline = 0
self.registration_password = ''
self.power_name = ''
self.state = {}
self.map_name = ''
self.rules = set()
super(CreateGame, self).__init__(**kwargs)
class ServerGame(Game):
""" ServerGame class.
Properties:
- **server**: (optional) server (Server object) that handles this game.
- **omniscient_usernames** (only for server games):
set of usernames allowed to be omniscient observers for this game.
- **moderator_usernames** (only for server games):
set of usernames allowed to be moderators for this game.
- **observer** (only for server games):
special Power object (diplomacy.Power) used to manage observer tokens.
- **omniscient** (only for server games):
special Power object (diplomacy.Power) used to manage omniscient tokens.
"""
__slots__ = [
'server', 'omniscient_usernames', 'moderator_usernames', 'observer',
'omniscient'
]
model = parsing.update_model(
Game.model, {
strings.MODERATOR_USERNAMES:
parsing.DefaultValueType(
parsing.SequenceType(str, sequence_builder=set), ()),
strings.OBSERVER:
parsing.OptionalValueType(parsing.JsonableClassType(Power)),
strings.OMNISCIENT:
parsing.OptionalValueType(parsing.JsonableClassType(Power)),
strings.OMNISCIENT_USERNAMES:
parsing.DefaultValueType(
parsing.SequenceType(str, sequence_builder=set), ()),
})
def __init__(self, server=None, **kwargs):
# Reference to a Server instance.
self.server = server # type: diplomacy.Server
self.omniscient_usernames = None # type: set
self.moderator_usernames = None # type: set
self.observer = None # type: Power
self.omniscient = None # type: Power
super(ServerGame, self).__init__(**kwargs)
assert self.is_server_game()
# Initialize special powers.
self.observer = self.observer or Power(self,
name=strings.OBSERVER_TYPE)
self.omniscient = self.omniscient or Power(
self, name=strings.OMNISCIENT_TYPE)
self.observer.set_controlled(strings.OBSERVER_TYPE)
self.omniscient.set_controlled(strings.OBSERVER_TYPE)
# Server-only methods.
def get_related_power_names(self, power_name):
""" Return list of power names controlled by the controlled of given power name. """
related_power_names = []
if self.has_power(power_name):
related_power_names = [power_name]
related_power = self.get_power(power_name)
if related_power.is_controlled():
related_power_names = self.get_controlled_power_names(
related_power.get_controller())
return related_power_names
def filter_phase_data(self, phase_data, role, is_current):
""" Return a filtered version of given phase data for given gam role.
:param phase_data: GamePhaseData object to filter.
:param role: game role to filter phase data for.
:param is_current: Boolean. Indicate if given phase data is for a current phase (True), or for a pase phase.
:return: a new GamePhaseData object suitable for given game role.
:type phase_data: GamePhaseData
"""
if role == strings.OMNISCIENT_TYPE:
# Nothing to filter.
return phase_data
if role == strings.OBSERVER_TYPE:
# Filter messages.
return GamePhaseData(name=phase_data.name,
state=phase_data.state,
orders=phase_data.orders,
results=phase_data.results,
messages=self.filter_messages(
phase_data.messages, role))
# Filter for power roles.
related_power_names = self.get_related_power_names(role)
# Filter messages.
messages = self.filter_messages(phase_data.messages,
related_power_names)
# We filter orders only if phase data is for a current phase.
if is_current:
orders = {
power_name: phase_data.orders[power_name]
for power_name in related_power_names
if power_name in phase_data.orders
}
else:
orders = phase_data.orders
# results don't need to be filtered: it should be provided empty for current phase,
# and it should be kept for a past phase/
return GamePhaseData(name=phase_data.name,
state=phase_data.state,
orders=orders,
messages=messages,
results=phase_data.results)
def game_can_start(self):
""" Return True if server game can start.
A game can start if all followings conditions are satisfied:
- Game has not yet started.
- Game can start automatically (no rule START_MASTER).
- Game has expected number of controlled powers.
:return: a boolean
:rtype: bool
"""
return self.is_game_forming and not self.start_master and self.has_expected_controls_count(
)
def get_messages(self, game_role, timestamp_from=None, timestamp_to=None):
""" Return a filtered dict of current messages for given output game role.
See method filter_messages() about parameters.
"""
return self.filter_messages(self.messages, game_role, timestamp_from,
timestamp_to)
def get_message_history(self, game_role):
""" Return a filtered dict of whole message history for given game role. """
return {
str(short_phase): self.filter_messages(messages, game_role)
for short_phase, messages in self.message_history.items()
}
def get_user_power_names(self, username):
""" Return list of power names controlled by given user name. """
return [
power.name for power in self.powers.values()
if power.is_controlled_by(username)
]
def new_system_message(self, recipient, body):
""" Create a system message (immediately dated) to be sent by server and add it to message history.
To be used only by server game.
:param recipient: recipient description (string). Either:
- a power name.
- 'GLOBAL' (all game tokens)
- 'OBSERVER' (all special tokens [observers and omniscient observers])
- 'OMNISCIENT' (all omniscient tokens only)
:param body: message body (string).
:return: a new GameMessage object.
:rtype: Message
"""
assert (recipient in {GLOBAL, OBSERVER, OMNISCIENT}
or self.has_power(recipient))
message = Message(phase=self.current_short_phase,
sender=SYSTEM,
recipient=recipient,
message=body)
# Message timestamp will be generated when adding message.
self.add_message(message)
return message
def as_power_game(self, power_name):
""" Return a player game data object copy of this game for given power name. """
for_username = self.get_power(power_name).get_controller()
game = Game.from_dict(self.to_dict())
game.error = []
game.message_history = self.get_message_history(power_name)
game.messages = self.get_messages(power_name)
game.phase_abbr = game.current_short_phase
related_power_names = self.get_related_power_names(power_name)
for power in game.powers.values(): # type: Power
power.role = power.name
power.tokens.clear()
if power.name not in related_power_names:
power.vote = strings.NEUTRAL
power.orders.clear()
game.role = power_name
game.controlled_powers = self.get_controlled_power_names(for_username)
game.observer_level = self.get_observer_level(for_username)
game.daide_port = self.server.get_daide_port(
self.game_id) if self.server else None
return game
def as_omniscient_game(self, for_username):
""" Return an omniscient game data object copy of this game. """
game = Game.from_dict(self.to_dict())
game.message_history = self.get_message_history(
strings.OMNISCIENT_TYPE)
game.messages = self.get_messages(strings.OMNISCIENT_TYPE)
game.phase_abbr = game.current_short_phase
for power in game.powers.values(): # type: Power
power.role = strings.OMNISCIENT_TYPE
power.tokens.clear()
game.role = strings.OMNISCIENT_TYPE
game.controlled_powers = self.get_controlled_power_names(for_username)
game.observer_level = self.get_observer_level(for_username)
game.daide_port = self.server.get_daide_port(
self.game_id) if self.server else None
return game
def as_observer_game(self, for_username):
""" Return an observer game data object copy of this game. """
game = Game.from_dict(self.to_dict())
game.error = []
game.message_history = self.get_message_history(strings.OBSERVER_TYPE)
game.messages = self.get_messages(strings.OBSERVER_TYPE)
game.phase_abbr = game.current_short_phase
for power in game.powers.values(): # type: Power
power.role = strings.OBSERVER_TYPE
power.tokens.clear()
power.vote = strings.NEUTRAL
game.role = strings.OBSERVER_TYPE
game.controlled_powers = self.get_controlled_power_names(for_username)
game.observer_level = self.get_observer_level(for_username)
game.daide_port = self.server.get_daide_port(
self.game_id) if self.server else None
return game
def cast(self, role, for_username):
""" Return a copy of this game for given role
(either observer role, omniscient role or a power role).
"""
assert strings.role_is_special(role) or self.has_power(role)
if role == strings.OBSERVER_TYPE:
return self.as_observer_game(for_username)
if role == strings.OMNISCIENT_TYPE:
return self.as_omniscient_game(for_username)
return self.as_power_game(role)
def is_controlled_by(self, power_name, username):
""" (for server game) Return True if given power name is controlled by given username. """
return self.get_power(power_name).is_controlled_by(username)
def get_observer_level(self, username):
""" Return the highest observation level allowed for given username.
:param username: name of user to get observation right
:return: either 'master_type', 'omniscient_type', 'observer_type' or None.
"""
if (self.server and self.server.users.has_admin(username)
) or self.is_moderator(username):
return strings.MASTER_TYPE
if self.is_omniscient(username):
return strings.OMNISCIENT_TYPE
if not self.no_observations:
return strings.OBSERVER_TYPE
return None
def get_reception_addresses(self):
""" Generate addresses (couple [power name, token]) of all users implied in this game. """
for power in self.powers.values(): # type: Power
for token in power.tokens:
yield (power.name, token)
for token in self.observer.tokens:
yield (self.observer.name, token)
for token in self.omniscient.tokens:
yield (self.omniscient.name, token)
def get_special_addresses(self):
""" Generate addresses (couples [power name, token]) of
omniscient observers and simple observers of this game.
"""
for power in (self.omniscient, self.observer):
for token in power.tokens:
yield (power.name, token)
def get_observer_addresses(self):
""" Generate addresses (couples [power name, token]) of observers of this game. """
for token in self.observer.tokens:
yield (self.observer.name, token)
def get_omniscient_addresses(self):
""" Generate addresses (couples [power name, token])
of omniscient observers of this game.
"""
for token in self.omniscient.tokens:
yield (self.omniscient.name, token)
def get_special_token_role(self, token):
""" Return role name (either OBSERVER_TYPE or OMNISCIENT_TYPE) for given special token. """
if self.has_omniscient_token(token):
return strings.OMNISCIENT_TYPE
if self.has_observer_token(token):
return strings.OBSERVER_TYPE
raise exceptions.DiplomacyException(
'Unknown special token in game %s' % self.game_id)
def get_power_addresses(self, power_name):
""" Generate addresses (couples [power name, token])
of user controlling given power name.
"""
for token in self.get_power(power_name).tokens:
yield (power_name, token)
def has_player(self, username):
""" (for server game) Return True if given username controls any map power. """
return any(
power.is_controlled_by(username) for power in self.powers.values())
def has_token(self, token):
""" Return True if game has given token (either observer, omniscient or player). """
return self.omniscient.has_token(token) or self.observer.has_token(
token) or any(
power.has_token(token) for power in self.powers.values())
def has_observer_token(self, token):
""" Return True if game has given observer token. """
return self.observer.has_token(token)
def has_omniscient_token(self, token):
""" Return True if game has given omniscient observer token. """
return self.omniscient.has_token(token)
def has_player_token(self, token):
""" Return True if game has given player token. """
return any(power.has_token(token) for power in self.powers.values())
def power_has_token(self, power_name, token):
""" Return True if given power has given player token.
:param power_name: name of power to check.
:param token: token to look for.
:return: a boolean
"""
return self.get_power(power_name).has_token(token)
def add_omniscient_token(self, token):
""" Set given token as omniscient token. """
if self.observer.has_token(token):
raise exceptions.ResponseException(
'Token already registered as observer.')
if self.has_player_token(token):
raise exceptions.ResponseException(
'Token already registered as player.')
self.omniscient.add_token(token)
def add_observer_token(self, token):
""" Set given token as observer token. """
if self.omniscient.has_token(token):
raise exceptions.ResponseException(
'Token already registered as omniscient.')
if self.has_player_token(token):
raise exceptions.ResponseException(
'Token already registered as player.')
self.observer.add_token(token)
def transfer_special_token(self, token):
""" Move given token from a special case to another
(observer -> omniscient or omniscient -> observer).
"""
if self.has_observer_token(token):
self.remove_observer_token(token)
self.add_omniscient_token(token)
elif self.has_omniscient_token(token):
self.remove_omniscient_token(token)
self.add_observer_token(token)
def control(self, power_name, username, token):
""" Control given power name with given username via given token. """
if self.observer.has_token(token):
raise exceptions.ResponseException(
'Token already registered as observer.')
if self.omniscient.has_token(token):
raise exceptions.ResponseException(
'Token already registered as omniscient.')
power = self.get_power(power_name) # type: Power
if power.is_controlled() and not power.is_controlled_by(username):
raise exceptions.ResponseException(
'Power already controlled by another user.')
power.set_controlled(username)
power.add_token(token)
def remove_observer_token(self, token):
""" Remove given observer token. """
self.observer.remove_tokens([token])
def remove_omniscient_token(self, token):
""" Remove given omniscient token. """
self.omniscient.remove_tokens([token])
def remove_special_token(self, special_name, token):
""" Remove given token from given special power name
(either __OBSERVER__ or __OMNISCIENT__).
"""
if special_name == self.observer.name:
self.remove_observer_token(token)
else:
assert special_name == self.omniscient.name
self.remove_omniscient_token(token)
def remove_all_tokens(self):
""" Remove all connected tokens from this game. """
self.observer.tokens.clear()
self.omniscient.tokens.clear()
for power in self.powers.values():
power.tokens.clear()
def remove_token(self, token):
""" Remove token from this game. """
for power in self.powers.values(): # type: Power
power.remove_tokens([token])
for special_power in (self.observer, self.omniscient):
special_power.remove_tokens([token])
def is_moderator(self, username):
""" Return True if given username is a moderator of this game. """
return username in self.moderator_usernames
def is_omniscient(self, username):
""" Return True if given username is allowed to be an omniscient observer of this game. """
return username in self.omniscient_usernames
def promote_moderator(self, username):
""" Allow given username to be a moderator of this game. """
self.moderator_usernames.add(username)
def promote_omniscient(self, username):
""" Allow given username to be an omniscient observer of this game. """
self.omniscient_usernames.add(username)
def demote_moderator(self, username):
""" Remove given username from allowed moderators. """
if username in self.moderator_usernames:
self.moderator_usernames.remove(username)
def demote_omniscient(self, username):
""" Remove given username from allowed omniscient observers. """
if username in self.omniscient_usernames:
self.omniscient_usernames.remove(username)
def filter_usernames(self, filter_function):
""" Remove each omniscient username, moderator username and player controller
that does not match given filter function (if filter_function(username) is False).
:param filter_function: a callable receiving a username and returning a boolean.
:return: an integer, either:
* 0: nothing changed.
* -1: something changed, but no player controllers removed.
* 1: something changed, and some player controllers were removed.
So, if 1 is returned, there are new dummy powers in the game
(some notifications may need to be sent).
"""
n_kicked_players = 0
n_kicked_omniscients = len(self.omniscient_usernames)
n_kicked_moderators = len(self.moderator_usernames)
self.omniscient_usernames = set(
username for username in self.omniscient_usernames
if filter_function(username))
self.moderator_usernames = set(username
for username in self.moderator_usernames
if filter_function(username))
for power in self.powers.values():
if power.is_controlled() and not filter_function(
power.get_controller()):
power.set_controlled(None)
n_kicked_players += 1
n_kicked_omniscients -= len(self.omniscient_usernames)
n_kicked_moderators -= len(self.moderator_usernames)
if n_kicked_players:
return 1
if n_kicked_moderators or n_kicked_omniscients:
return -1
return 0
def filter_tokens(self, filter_function):
""" Remove from this game any token not matching given filter function
(if filter_function(token) is False).
"""
self.observer.remove_tokens([
token for token in self.observer.tokens
if not filter_function(token)
])
self.omniscient.remove_tokens([
token for token in self.omniscient.tokens
if not filter_function(token)
])
for power in self.powers.values(): # type: Power
power.remove_tokens([
token for token in power.tokens if not filter_function(token)
])
def process(self):
""" Process current game phase and move forward to next phase.
:return: a triple containing:
- previous game state (before the processing)
- current game state (after processing and game updates)
- A dictionary mapping kicked power names to tokens previously associated to these powers.
Useful to notify kicked users as they will be not registered in game anymore.
If game was not active, triple is (None, None, None).
If game kicked powers, only kicked powers dict is returned: (None, None, kicked powers).
If game was correctly processed, only states are returned: (prev, curr, None).
"""
if not self.is_game_active:
return None, None, None
# Kick powers if necessary.
all_orderable_locations = self.get_orderable_locations()
kicked_powers = {}
for power in self.powers.values():
if (power.is_controlled() and not power.order_is_set
and not self.civil_disorder
and all_orderable_locations[power.name]):
# This controlled power has not submitted orders, we have not rule CIVIL_DISORDER,
# and this power WAS allowed to submit orders for this phase.
# We kick such power.
kicked_powers[power.name] = set(power.tokens)
power.set_controlled(None)
if kicked_powers:
# Some powers were kicked from an active game before processing.
# This game must be stopped and cannot be processed. We return info about kicked powers.
self.set_status(strings.FORMING)
return None, None, kicked_powers
# Process game and retrieve previous state.
previous_phase_data = super(ServerGame, self).process()
if self.count_controlled_powers() < self.get_expected_controls_count():
# There is no more enough controlled powers, we should stop game.
self.set_status(strings.FORMING)
# Return process results: previous phase data, current phase data, and None for no kicked powers.
return previous_phase_data, self.get_phase_data(), None
class DataPowerNames(UniqueData):
""" Unique data containing a list of power names. """
__slots__ = []
params = {strings.DATA: parsing.SequenceType(str)}
class DataGameInfo(_AbstractResponse):
""" Response containing information about a game, to be used when no entire game object is required.
Properties:
- **game_id**: game ID
- **phase**: game phase
- **timestamp**: latest timestamp when data was saved into game on server
(ie. game state or message)
- **timestamp_created**: timestamp when game was created on server
- **map_name**: (optional) game map name
- **observer_level**: (optional) highest observer level allowed for the user who sends
the request. Either ``'observer_type'``, ``'omniscient_type'`` or ``'master_type'``.
- **controlled_powers**: (optional) list of power names controlled by the user who sends
the request.
- **rules**: (optional) game rules
- **status**: (optional) game status
- **n_players**: (optional) number of powers currently controlled in the game
- **n_controls**: (optional) number of controlled powers required by the game to be active
- **deadline**: (optional) game deadline - time to wait before processing a game phase
- **registration_password**: (optional) boolean - if True, a password is required to join the game
"""
__slots__ = [
'game_id', 'phase', 'timestamp', 'map_name', 'rules', 'status',
'n_players', 'n_controls', 'deadline', 'registration_password',
'observer_level', 'controlled_powers', 'timestamp_created'
]
params = {
strings.GAME_ID:
str,
strings.PHASE:
str,
strings.TIMESTAMP:
int,
strings.TIMESTAMP_CREATED:
int,
strings.MAP_NAME:
parsing.OptionalValueType(str),
strings.OBSERVER_LEVEL:
parsing.OptionalValueType(
parsing.EnumerationType(
(strings.MASTER_TYPE, strings.OMNISCIENT_TYPE,
strings.OBSERVER_TYPE))),
strings.CONTROLLED_POWERS:
parsing.OptionalValueType(parsing.SequenceType(str)),
strings.RULES:
parsing.OptionalValueType(parsing.SequenceType(str)),
strings.STATUS:
parsing.OptionalValueType(
parsing.EnumerationType(strings.ALL_GAME_STATUSES)),
strings.N_PLAYERS:
parsing.OptionalValueType(int),
strings.N_CONTROLS:
parsing.OptionalValueType(int),
strings.DEADLINE:
parsing.OptionalValueType(int),
strings.REGISTRATION_PASSWORD:
parsing.OptionalValueType(bool)
}
def __init__(self, **kwargs):
self.game_id = None # type: str
self.phase = None # type: str
self.timestamp = None # type: int
self.timestamp_created = None # type: int
self.map_name = None # type: str
self.observer_level = None # type: str
self.controlled_powers = None # type: list
self.rules = None # type: list
self.status = None # type: str
self.n_players = None # type: int
self.n_controls = None # type: int
self.deadline = None # type: int
self.registration_password = None # type: bool
super(DataGameInfo, self).__init__(**kwargs)
class DataGamesToPowerNames(UniqueData):
""" Unique data containing a dictionary mapping a game ID to a list of power names. """
__slots__ = []
params = {strings.DATA: parsing.DictType(str, parsing.SequenceType(str))}
class Power(Jsonable):
""" Power Class
Properties:
- **abbrev** - Contains the abbrev of the power (i.e. the first letter of the power name) (e.g. 'F' for FRANCE)
- **adjust** - List of pending adjustment orders
(e.g. ['A PAR B', 'A PAR R MAR', 'A MAR D', 'WAIVE'])
- **centers** - Contains the list of supply centers currently controlled by the power ['MOS', 'SEV', 'STP']
- **civil_disorder** - Bool flag to indicate that the power has been put in CIVIL_DISORDER (e.g. True or False)
- **controller** - Sorted dictionary mapping timestamp to controller (either dummy or a user ID) who takes
control of power at this timestamp.
- **game** - Contains a reference to the game object
- **goner** - Boolean to indicate that this power doesn't control any SCs any more (e.g. True or False)
- **homes** - Contains a list of homes supply centers (where you can build)
e.g. ['PAR', 'MAR', ... ] or None if empty
- **influence** - Contains a list of locations influenced by this power
Note: To influence a location, the power must have visited it last.
e.g ['PAR', 'MAR', ... ]
- **name** - Contains the name of the power (e.g. 'FRANCE')
- **orders** - Contains a dictionary of units and their orders.
For NO_CHECK games, unit is 'ORDER 1', 'ORDER 2', ...
- e.g. {'A PAR': '- MAR' } or {'ORDER 1': 'A PAR - MAR', 'ORDER 2': '...', ... }
- Can also be {'REORDER 1': 'A PAR - MAR', 'INVALID 1': 'A PAR - MAR', ... } after validation
- **retreats** - Contains the list of units that need to retreat with their possible retreat locations
(e.g. {'A PAR': ['MAR', 'BER']})
- **role** - Power type (observer, omniscient, player or server power).
Either the power name (for a player power) or a value in diplomacy.utils.strings.ALL_ROLE_TYPES
- **tokens** - Only for server power: set of tokens of current power controlled (if not None).
- **units** - Contains the list of units (e.g. ['A PAR', 'A MAR', ...]
- **vote** - Only for omniscient, player and server power: power vote ('yes', 'no' or 'neutral').
"""
__slots__ = [
'game', 'name', 'abbrev', 'adjust', 'centers', 'units', 'influence',
'homes', 'retreats', 'goner', 'civil_disorder', 'orders', 'role',
'controller', 'vote', 'order_is_set', 'wait', 'tokens'
]
model = {
strings.ABBREV:
parsing.OptionalValueType(str),
strings.ADJUST:
parsing.DefaultValueType(parsing.SequenceType(str), []),
strings.CENTERS:
parsing.DefaultValueType(parsing.SequenceType(str), []),
strings.CIVIL_DISORDER:
parsing.DefaultValueType(int, 0),
strings.CONTROLLER:
parsing.DefaultValueType(
parsing.DictType(int, str, SortedDict.builder(int, str)), {}),
strings.HOMES:
parsing.OptionalValueType(parsing.SequenceType(str)),
strings.INFLUENCE:
parsing.DefaultValueType(parsing.SequenceType(str), []),
strings.NAME:
parsing.PrimitiveType(str),
strings.ORDER_IS_SET:
parsing.DefaultValueType(OrderSettings.ALL_SETTINGS,
OrderSettings.ORDER_NOT_SET),
strings.ORDERS:
parsing.DefaultValueType(parsing.DictType(str, str), {}),
strings.RETREATS:
parsing.DefaultValueType(
parsing.DictType(str, parsing.SequenceType(str)), {}),
strings.ROLE:
parsing.DefaultValueType(str, strings.SERVER_TYPE),
strings.TOKENS:
parsing.DefaultValueType(parsing.SequenceType(str, set), ()),
strings.UNITS:
parsing.DefaultValueType(parsing.SequenceType(str), []),
strings.VOTE:
parsing.DefaultValueType(
parsing.EnumerationType(strings.ALL_VOTE_DECISIONS),
strings.NEUTRAL),
strings.WAIT:
parsing.DefaultValueType(bool, True),
}
def __init__(self, game=None, name=None, **kwargs):
""" Constructor """
self.game = game
self.abbrev = None
self.adjust, self.centers, self.units, self.influence = [], [], [], []
self.homes = None
self.retreats = {}
self.goner = self.civil_disorder = 0
self.orders = {}
self.name = ''
self.role = ''
self.controller = SortedDict(int, str)
self.vote = ''
self.order_is_set = 0
self.wait = False
self.tokens = set()
super(Power, self).__init__(name=name, **kwargs)
assert self.role in strings.ALL_ROLE_TYPES or self.role == self.name
if not self.controller:
self.controller.put(common.timestamp_microseconds(), strings.DUMMY)
def __str__(self):
""" Returns a representation of the power instance """
show_cd = self.civil_disorder
show_inhabits = self.homes is not None
show_owns = self.centers
show_retreats = len(self.retreats) > 0
text = ''
text += '\n%s (%s)' % (self.name, self.role)
text += '\nPLAYER %s' % self.controller.last_value()
text += '\nCD' if show_cd else ''
text += '\nINHABITS %s' % ' '.join(self.homes) if show_inhabits else ''
text += '\nOWNS %s' % ' '.join(self.centers) if show_owns else ''
if show_retreats:
text += '\n'.join([''] + [
' '.join([unit, '-->'] + places)
for unit, places in self.retreats.items()
])
text = '\n'.join([text] + self.units + self.adjust)
# Orders - RIO is for REORDER, INVALID, ORDER (in NO_CHECK games)
text_order = '\nORDERS\n'
for unit, order in self.orders.items():
if unit[0] not in 'RIO':
text_order += '%s ' % unit
text_order += order + '\n'
text += text_order if self.orders else ''
return text
def __deepcopy__(self, memo):
""" Fast deep copy implementation (**not setting the game object**) """
cls = self.__class__
result = cls.__new__(cls)
# Deep copying
for key in self.__slots__:
if key not in ['game']:
setattr(result, key, deepcopy(getattr(self, key)))
# Game
setattr(result, 'game', None)
return result
def reinit(self, include_flags=6):
""" Performs a reinitialization of some of the parameters
:param include_flags: Bit mask to indicate which params to reset
(bit 1 = orders, 2 = persistent, 4 = transient)
:return: None
"""
reinit_persistent = include_flags & 2
reinit_transient = include_flags & 4
reinit_orders = include_flags & 1
# Initialize the persistent parameters
if reinit_persistent:
self.abbrev = None
# Initialize the transient parameters
if reinit_transient:
for home in self.homes:
self.game.update_hash(self.name, loc=home, is_home=True)
for center in self.centers:
self.game.update_hash(self.name, loc=center, is_center=True)
for unit in self.units:
self.game.update_hash(self.name,
unit_type=unit[0],
loc=unit[2:])
for dis_unit in self.retreats:
self.game.update_hash(self.name,
unit_type=dis_unit[0],
loc=dis_unit[2:],
is_dislodged=True)
self.homes = None
self.centers, self.units, self.influence = [], [], []
self.retreats = {}
# Initialize the order-related parameters
if reinit_orders:
self.civil_disorder = 0
self.adjust = []
self.orders = {}
if self.is_eliminated():
self.order_is_set = OrderSettings.ORDER_SET_EMPTY
self.wait = False
else:
self.order_is_set = OrderSettings.ORDER_NOT_SET
self.wait = True if self.is_dummy() else (
not self.game.real_time)
self.goner = 0
@staticmethod
def compare(power_1, power_2):
""" Comparator object - Compares two Power objects
:param power_1: The first Power object to compare
:param power_2: The second Power object to compare
:return: 1 if self is greater, -1 if other is greater, 0 if they are equal
"""
cmp = lambda power_1, power_2: ((power_1 > power_2) -
(power_1 < power_2))
xstr = lambda string: string or '' # To avoid comparing with None
cmp_type = cmp(xstr(power_1.role), xstr(power_2.role))
cmp_name = cmp(xstr(power_1.name), xstr(power_2.name))
return cmp_type or cmp_name
def initialize(self, game):
""" Initializes a game and resets home, centers and units
:param game: The game to use for initialization
:type game: diplomacy.Game
"""
# Not initializing observers and monitors
assert self.is_server_power()
self.game = game
self.order_is_set = OrderSettings.ORDER_NOT_SET
self.wait = True if self.is_dummy() else (not self.game.real_time)
# Get power abbreviation.
self.abbrev = self.game.map.abbrev.get(self.name, self.name[0])
# Resets homes
if self.homes is None:
self.homes = []
for home in game.map.homes.get(self.name, []):
self.game.update_hash(self.name, loc=home, is_home=True)
self.homes.append(home)
# Resets the centers and units
if not self.centers:
for center in game.map.centers.get(self.name, []):
game.update_hash(self.name, loc=center, is_center=True)
self.centers.append(center)
if not self.units:
for unit in game.map.units.get(self.name, []):
game.update_hash(self.name, unit_type=unit[0], loc=unit[2:])
self.units.append(unit)
self.influence.append(unit[2:5])
def merge(self, other_power):
""" Transfer all units, centers, and homes of the other_power to this power
:param other_power: The other power (will be empty after the merge)
"""
# Regular units
for unit in list(other_power.units):
self.units.append(unit)
other_power.units.remove(unit)
self.game.update_hash(self.name, unit_type=unit[0], loc=unit[2:])
self.game.update_hash(other_power.name,
unit_type=unit[0],
loc=unit[2:])
# Dislodged units
for unit in list(other_power.retreats.keys()):
self.retreats[unit] = other_power.retreats[unit]
del other_power.retreats[unit]
self.game.update_hash(self.name,
unit_type=unit[0],
loc=unit[2:],
is_dislodged=True)
self.game.update_hash(other_power.name,
unit_type=unit[0],
loc=unit[2:],
is_dislodged=True)
# Influence
for loc in list(other_power.influence):
self.influence.append(loc)
other_power.influence.remove(loc)
# Supply centers
for center in list(other_power.centers):
self.centers.append(center)
other_power.centers.remove(center)
self.game.update_hash(self.name, loc=center, is_center=True)
self.game.update_hash(other_power.name, loc=center, is_center=True)
# Homes
for home in list(other_power.homes):
self.homes.append(home)
other_power.homes.remove(home)
self.game.update_hash(self.name, loc=home, is_home=True)
self.game.update_hash(other_power.name, loc=home, is_home=True)
# Clearing state cache
self.game.clear_cache()
def clear_units(self):
""" Removes all units from the map """
for unit in self.units:
self.game.update_hash(self.name, unit_type=unit[0], loc=unit[2:])
for unit in self.retreats:
self.game.update_hash(self.name,
unit_type=unit[0],
loc=unit[2:],
is_dislodged=True)
self.units = []
self.retreats = {}
self.influence = []
self.game.clear_cache()
def clear_centers(self):
""" Removes ownership of all supply centers """
for center in self.centers:
self.game.update_hash(self.name, loc=center, is_center=True)
self.centers = []
self.game.clear_cache()
def is_dummy(self):
""" Indicates if the power is a dummy
:return: Boolean flag to indicate if the power is a dummy
"""
return self.controller.last_value() == strings.DUMMY
def is_eliminated(self):
""" Returns a flag to show if player is eliminated
:return: If the current power is eliminated
"""
# Not eliminated if has units left
if self.units or self.centers or self.retreats:
return False
return True
def clear_orders(self):
""" Clears the power's orders """
self.reinit(include_flags=1)
def moves_submitted(self):
""" Returns a boolean to indicate if moves has been submitted
:return: 1 if not in Movement phase, or orders submitted, or no more units lefts
"""
if self.game.phase_type != 'M':
return 1
return self.orders or not self.units
# ==============================================================
# Application/network methods (mainly used for connected games).
# ==============================================================
def is_observer_power(self):
""" (Network Method) Return True if this power is an observer power. """
return self.role == strings.OBSERVER_TYPE
def is_omniscient_power(self):
""" (Network Method) Return True if this power is an omniscient power. """
return self.role == strings.OMNISCIENT_TYPE
def is_player_power(self):
""" (Network Method) Return True if this power is a player power. """
return self.role == self.name
def is_server_power(self):
""" (Network Method) Return True if this power is a server power. """
return self.role == strings.SERVER_TYPE
def is_controlled(self):
""" (Network Method) Return True if this power is controlled. """
return self.controller.last_value() != strings.DUMMY
def does_not_wait(self):
""" (Network Method) Return True if this power does not wait
(ie. if we could already process orders of this power).
"""
return self.order_is_set and not self.wait
def update_controller(self, username, timestamp):
""" (Network Method) Update controller with given username and timestamp. """
self.controller.put(timestamp, username)
def set_controlled(self, username):
""" (Network Method) Control power with given username. Username may be None (meaning no controller). """
if username is None or username == strings.DUMMY:
if self.controller.last_value() != strings.DUMMY:
self.controller.put(common.timestamp_microseconds(),
strings.DUMMY)
self.tokens.clear()
self.wait = True
self.vote = strings.NEUTRAL
elif self.controller.last_value() == strings.DUMMY:
self.controller.put(common.timestamp_microseconds(), username)
self.wait = not self.game.real_time
elif self.controller.last_value() != username:
raise DiplomacyException(
'Power already controlled by someone else. Kick previous controller before.'
)
def get_controller(self):
""" (Network Method) Return current power controller name ('dummy' if power is not controlled). """
return self.controller.last_value()
def get_controller_timestamp(self):
""" (Network Method) Return timestamp when current controller took control of this power. """
return self.controller.last_key()
def is_controlled_by(self, username):
""" (Network Method) Return True if this power is controlled by given username. """
if username == constants.PRIVATE_BOT_USERNAME:
# Bot is connected if power is dummy and has some associated tokens.
return self.is_dummy() and bool(self.tokens)
return self.controller.last_value() == username
# Server-only methods.
def has_token(self, token):
""" (Server Method) Return True if this power has given token. """
assert self.is_server_power()
return token in self.tokens
def add_token(self, token):
""" (Server Method) Add given token to this power. """
assert self.is_server_power()
self.tokens.add(token)
def remove_tokens(self, tokens):
""" (Server Method) Remove sequence of tokens from this power. """
assert self.is_server_power()
self.tokens.difference_update(tokens)
class SendMessageRequest(DaideRequest):
""" Represents a SND DAIDE request
Syntax: ::
SND (power ...) (press_message)
SND (power ...) (reply)
SND (turn) (power ...) (press_message)
SND (turn) (power ...) (reply)
Press message syntax: ::
PRP (arrangement)
CCL (press_message)
FCT (arrangement)
TRY (tokens)
Reply syntax: ::
YES (press_message)
REJ (press_message)
BWX (press_message)
HUH (press_message)
"""
__slots__ = ['powers', 'message_bytes']
params = {
strings.POWERS: parsing.SequenceType(str),
strings.MESSAGE_BYTES: parsing.OptionalValueType(str),
}
def __init__(self, **kwargs):
""" Constructor """
self.phase = ''
self.powers = []
self.message_bytes = None
super(SendMessageRequest, self).__init__(powers=[], press_message='', reply='', **kwargs)
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
class CreateGame(_AbstractChannelRequest):
""" Channel request to create a game.
:param game_id: game ID. If not provided, a game ID will be generated.
:param n_controls: number of controlled powers required to start the game.
A power becomes controlled when a player joins the game to control this power.
Game won't start as long it does not have this number of controlled powers.
Game will stop (to ``forming`` state) if the number of controlled powers decrease under
this number (e.g. when powers are kicked, eliminated, or when a player controlling a power
leaves the game). If not provided, set with the number of powers on the map (e.g. ``7``
on standard map).
:param deadline: (default ``300``) time (in seconds) for the game to wait before
processing a phase. ``0`` means no deadline, ie. game won't process a phase until either
all powers submit orders and turn off wait flag, or a game master forces game to process.
:param registration_password: password required to join the game.
If not provided, anyone can join the game.
:param power_name: power to control once game is created.
- If provided, the user who send this request will be joined to the game as a player
controlling this power.
- If not provided, the user who send this request will be joined to the game as an
omniscient observer (ie. able to see everything in the game, including user messages).
Plus, as game creator, user will also be a game master, ie. able to send master requests,
e.g. to force game processing.
:param state: game initial state (for expert users).
:param map_name: (default ``'standard'``) map to play on.
You can retrieve maps available on server by sending request :class:`GetAvailableMaps`.
:param rules: list of strings - game rules (for expert users).
:type game_id: str, optional
:type n_controls: int, optional
:type deadline: int, optional
:type registration_password: str, optional
:type power_name: str, optional
:type state: dict, optional
:type map_name: str, optional
:type rules: list, optional
:return:
- Server: :class:`.DataGame`
- Client: a :class:`.NetworkGame` object representing a client version of the
game created and joined. Either a power game (if power name given) or an omniscient game.
"""
__slots__ = [
'game_id', 'power_name', 'state', 'map_name', 'rules', 'n_controls',
'deadline', 'registration_password'
]
params = {
strings.GAME_ID:
parsing.OptionalValueType(str),
strings.N_CONTROLS:
parsing.OptionalValueType(int),
strings.DEADLINE:
parsing.DefaultValueType(int, 300), # 300 seconds. Must be >= 0.
strings.REGISTRATION_PASSWORD:
parsing.OptionalValueType(str),
strings.POWER_NAME:
parsing.OptionalValueType(str),
strings.STATE:
parsing.OptionalValueType(dict),
strings.MAP_NAME:
parsing.DefaultValueType(str, 'standard'),
strings.RULES:
parsing.OptionalValueType(
parsing.SequenceType(str, sequence_builder=set)),
}
def __init__(self, **kwargs):
self.game_id = ''
self.n_controls = 0
self.deadline = 0
self.registration_password = ''
self.power_name = ''
self.state = {}
self.map_name = ''
self.rules = set()
super(CreateGame, self).__init__(**kwargs)
class Users(Jsonable):
""" Users class.
Properties:
- **users**: dictionary mapping usernames to User object.s
- **administrators**: set of administrator usernames.
- **token_timestamp**: dictionary mapping each token to its creation/last confirmation timestamp.
- **token_to_username**: dictionary mapping each token to its username.
- **username_to_tokens**: dictionary mapping each username to a set of its tokens.
- **token_to_connection_handler**: (memory only) dictionary mapping each token to a connection handler
- **connection_handler_to_tokens**: (memory only) dictionary mapping a connection handler to a set of its tokens
"""
__slots__ = [
'users', 'administrators', 'token_timestamp', 'token_to_username',
'username_to_tokens', 'token_to_connection_handler',
'connection_handler_to_tokens'
]
model = {
strings.USERS:
parsing.DefaultValueType(
parsing.DictType(str, parsing.JsonableClassType(User)), {}),
# {username => User}
strings.ADMINISTRATORS:
parsing.DefaultValueType(
parsing.SequenceType(str, sequence_builder=set), ()),
# {usernames}
strings.TOKEN_TIMESTAMP:
parsing.DefaultValueType(parsing.DictType(str, int), {}),
strings.TOKEN_TO_USERNAME:
parsing.DefaultValueType(parsing.DictType(str, str), {}),
strings.USERNAME_TO_TOKENS:
parsing.DefaultValueType(
parsing.DictType(str, parsing.SequenceType(str, set)), {}),
}
def __init__(self, **kwargs):
self.users = {}
self.administrators = set()
self.token_timestamp = {}
self.token_to_username = {}
self.username_to_tokens = {}
self.token_to_connection_handler = {}
self.connection_handler_to_tokens = {}
super(Users, self).__init__(**kwargs)
def has_username(self, username):
""" Return True if users have given username. """
return username in self.users
def has_user(self, username, password):
""" Return True if users have given username with given password. """
return username in self.users and self.users[
username].is_valid_password(password)
def has_admin(self, username):
""" Return True if given username is an administrator. """
return username in self.administrators
def has_token(self, token):
""" Return True if users have given token. """
return token in self.token_to_username
def token_is_alive(self, token):
""" Return True if given token is known and still alive.
A token is alive if elapsed time since last token usage does not exceed token lifetime
(TOKEN_LIFETIME_SECONDS).
"""
if self.has_token(token):
current_time = common.timestamp_microseconds()
elapsed_time_seconds = (current_time -
self.token_timestamp[token]) / 1000000
return elapsed_time_seconds <= TOKEN_LIFETIME_SECONDS
return False
def relaunch_token(self, token):
""" Update timestamp of given token with current timestamp. """
if self.has_token(token):
self.token_timestamp[token] = common.timestamp_microseconds()
def token_is_admin(self, token):
""" Return True if given token is associated to an administrator. """
return self.has_token(token) and self.has_admin(self.get_name(token))
def count_connections(self):
""" Return number of registered connection handlers. """
return len(self.connection_handler_to_tokens)
def get_tokens(self, username):
""" Return a sequence of tokens associated to given username. """
return self.username_to_tokens[username].copy()
def get_name(self, token):
""" Return username of given token. """
return self.token_to_username[token]
def get_user(self, username):
""" Returns user linked to username """
return self.users.get(username, None)
def get_connection_handler(self, token):
""" Return connection handler associated to given token, or None if no handler currently associated. """
return self.token_to_connection_handler.get(token, None)
def add_admin(self, username):
""" Set given username as administrator. Related user must exists in this Users object. """
assert username in self.users
self.administrators.add(username)
def remove_admin(self, username):
""" Remove given username from administrators. """
if username in self.administrators:
self.administrators.remove(username)
def create_token(self):
""" Return a new token guaranteed to not exist in this Users object. """
token = generate_token()
while self.has_token(token):
token = generate_token()
return token
def add_user(self, username, password_hash):
""" Add a new user with given username and hashed password.
See diplomacy.utils.common.hash_password() for hashing purposes.
"""
user = User(username=username, password_hash=password_hash)
self.users[username] = user
return user
def replace_user(self, username, new_user):
""" Replaces user object with a new user """
self.users[username] = new_user
def remove_user(self, username):
""" Remove user related to given username. """
user = self.users.pop(username)
self.remove_admin(username)
for token in self.username_to_tokens.pop(user.username):
self.token_timestamp.pop(token)
self.token_to_username.pop(token)
connection_handler = self.token_to_connection_handler.pop(
token, None)
if connection_handler:
self.connection_handler_to_tokens[connection_handler].remove(
token)
if not self.connection_handler_to_tokens[connection_handler]:
self.connection_handler_to_tokens.pop(connection_handler)
def remove_connection(self, connection_handler, remove_tokens=True):
""" Remove given connection handler.
Return tokens associated to this connection handler,
or None if connection handler is unknown.
:param connection_handler: connection handler to remove.
:param remove_tokens: if True, tokens related to connection handler are deleted.
:return: either None or a set of tokens.
"""
if connection_handler in self.connection_handler_to_tokens:
tokens = self.connection_handler_to_tokens.pop(connection_handler)
for token in tokens:
self.token_to_connection_handler.pop(token)
if remove_tokens:
self.token_timestamp.pop(token)
user = self.users[self.token_to_username.pop(token)]
self.username_to_tokens[user.username].remove(token)
if not self.username_to_tokens[user.username]:
self.username_to_tokens.pop(user.username)
return tokens
return None
def connect_user(self, username, connection_handler):
""" Connect given username to given connection handler with a new generated token,
and return token generated.
:param username: username to connect
:param connection_handler: connection handler to link to user
:return: a new token generated for connexion
"""
token = self.create_token()
user = self.users[username]
if connection_handler not in self.connection_handler_to_tokens:
self.connection_handler_to_tokens[connection_handler] = set()
if user.username not in self.username_to_tokens:
self.username_to_tokens[user.username] = set()
self.token_to_username[token] = user.username
self.token_to_connection_handler[token] = connection_handler
self.username_to_tokens[user.username].add(token)
self.connection_handler_to_tokens[connection_handler].add(token)
self.token_timestamp[token] = common.timestamp_microseconds()
return token
def attach_connection_handler(self, token, connection_handler):
""" Associate given token with given connection handler if token is known.
If there is a previous connection handler associated to given token, it should be
the same as given connection handler, otherwise an error is raised
(meaning previous connection handler was not correctly disconnected from given token.
It should be a programming error).
:param token: token
:param connection_handler: connection handler
"""
if self.has_token(token):
previous_connection = self.get_connection_handler(token)
if previous_connection:
assert previous_connection == connection_handler, \
"A new connection handler cannot be attached to a token always connected to another handler."
else:
LOGGER.warning(
'Attaching a new connection handler to a token.')
if connection_handler not in self.connection_handler_to_tokens:
self.connection_handler_to_tokens[
connection_handler] = set()
self.token_to_connection_handler[token] = connection_handler
self.connection_handler_to_tokens[connection_handler].add(
token)
self.token_timestamp[token] = common.timestamp_microseconds()
def disconnect_token(self, token):
""" Remove given token. """
self.token_timestamp.pop(token)
user = self.users[self.token_to_username.pop(token)]
self.username_to_tokens[user.username].remove(token)
if not self.username_to_tokens[user.username]:
self.username_to_tokens.pop(user.username)
connection_handler = self.token_to_connection_handler.pop(token, None)
if connection_handler:
self.connection_handler_to_tokens[connection_handler].remove(token)
if not self.connection_handler_to_tokens[connection_handler]:
self.connection_handler_to_tokens.pop(connection_handler)
