class GameProcessed(_GameNotification):
""" Notification about a game phase update. Sent after game had processed a phase. """
__slots__ = ['previous_phase_data', 'current_phase_data']
params = {
strings.PREVIOUS_PHASE_DATA: parsing.JsonableClassType(GamePhaseData),
strings.CURRENT_PHASE_DATA: parsing.JsonableClassType(GamePhaseData),
}
def __init__(self, **kwargs):
self.previous_phase_data = None # type: GamePhaseData
self.current_phase_data = None # type: GamePhaseData
super(GameProcessed, self).__init__(**kwargs)
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 DataGamePhases(UniqueData):
""" Unique data containing a list of :class:`.GamePhaseData` objects. """
__slots__ = []
params = {
strings.DATA:
parsing.SequenceType(parsing.JsonableClassType(GamePhaseData))
}
class NotRequest(DaideRequest):
""" Represents a NOT DAIDE request. Sent by the client to cancel a previous request.
Syntax:
NOT (SUB) # Cancel all submitted orders
NOT (SUB (order)) # Cancel specific submitted order
NOT (GOF) # Do not process orders until the deadline
NOT (TME) # Cancel all requested time messages
NOT (TME (seconds)) # Cancel specific requested time message
NOT (DRW) # Cancel all draw requests
"""
__slots__ = ['request']
params = {strings.REQUEST: parsing.JsonableClassType(DaideRequest)}
def __init__(self, **kwargs):
""" Constructor """
self.request = None # type: DaideRequest
super(NotRequest, self).__init__(request=DaideRequest(), **kwargs)
def parse_bytes(self, daide_bytes):
""" Builds the request from DAIDE bytes """
super(NotRequest, self).parse_bytes(daide_bytes)
# Parsing
lead_token, daide_bytes = parse_bytes(SingleToken, daide_bytes)
request_group_bytes, daide_bytes = break_next_group(daide_bytes)
assert str(lead_token) == 'NOT', 'Expected NOT request'
# Request
request_group_bytes = strip_parentheses(request_group_bytes)
request = RequestBuilder.from_bytes(request_group_bytes)
assert not daide_bytes, '%s bytes remaining. Request is malformed' % len(
daide_bytes)
# Setting properties
self.request = request
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 GameProcessed(_GameNotification):
""" Notification about a game phase update. Sent after game has processed a phase.
Properties:
- **previous_phase_data**: :class:`diplomacy.utils.game_phase_data.GamePhaseData` of the previous phase
- **current_phase_data**: :class:`diplomacy.utils.game_phase_data.GamePhaseData` of the current phase
"""
__slots__ = ['previous_phase_data', 'current_phase_data']
params = {
strings.PREVIOUS_PHASE_DATA: parsing.JsonableClassType(GamePhaseData),
strings.CURRENT_PHASE_DATA: parsing.JsonableClassType(GamePhaseData),
}
def __init__(self, **kwargs):
self.previous_phase_data = None # type: GamePhaseData
self.current_phase_data = None # type: GamePhaseData
super(GameProcessed, self).__init__(**kwargs)
class GameMessageReceived(_GameNotification):
""" Notification about a game message received. """
__slots__ = ['message']
params = {
strings.MESSAGE: parsing.JsonableClassType(Message),
}
def __init__(self, **kwargs):
self.message = None # type: Message
super(GameMessageReceived, self).__init__(**kwargs)
class SendGameMessage(_AbstractGameRequest):
""" SendGameMessage request.
Expected response: responses.DataTimeStamp
Expected response handler result: None
"""
__slots__ = ['message']
params = {strings.MESSAGE: parsing.JsonableClassType(Message)}
def __init__(self, **kwargs):
self.message = None # type: Message
super(SendGameMessage, self).__init__(**kwargs)
class GamePhaseUpdate(_GameNotification):
""" Notification about a game phase update. """
__slots__ = ['phase_data', 'phase_data_type']
params = {
strings.PHASE_DATA: parsing.JsonableClassType(GamePhaseData),
strings.PHASE_DATA_TYPE: strings.ALL_STATE_TYPES
}
def __init__(self, **kwargs):
self.phase_data = None # type: GamePhaseData
self.phase_data_type = None # type: str
super(GamePhaseUpdate, self).__init__(**kwargs)
class OmniscientUpdated(_GameNotification):
""" Notification about a grade updated. Sent at channel level. """
__slots__ = ['grade_update', 'game']
params = {
strings.GRADE_UPDATE:
parsing.EnumerationType(strings.ALL_GRADE_UPDATES),
strings.GAME: parsing.JsonableClassType(Game)
}
def __init__(self, **kwargs):
self.grade_update = ''
self.game = None # type: Game
super(OmniscientUpdated, self).__init__(**kwargs)
class OmniscientUpdated(_GameNotification):
""" Notification about a grade updated. Sent at channel level.
Properties:
- **grade_update**: :class:`str` One of 'promote' or 'demote'.
- **game**: :class:`parsing.JsonableClassType(Game)` a :class:`diplomacy.engine.game.Game` object.
"""
__slots__ = ['grade_update', 'game']
params = {
strings.GRADE_UPDATE: parsing.EnumerationType(strings.ALL_GRADE_UPDATES),
strings.GAME: parsing.JsonableClassType(Game)
}
def __init__(self, **kwargs):
self.grade_update = ''
self.game = None # type: Game
super(OmniscientUpdated, self).__init__(**kwargs)
class GamePhaseUpdate(_GameNotification):
""" Notification about a game phase update.
Properties:
- **phase_data**: :class:`diplomacy.utils.game_phase_data.GamePhaseData` of the updated phase
- **phase_data_type**: :class:`str`. One of 'state_history', 'state', 'phase'
"""
__slots__ = ['phase_data', 'phase_data_type']
params = {
strings.PHASE_DATA: parsing.JsonableClassType(GamePhaseData),
strings.PHASE_DATA_TYPE: strings.ALL_STATE_TYPES
}
def __init__(self, **kwargs):
self.phase_data = None # type: GamePhaseData
self.phase_data_type = None # type: str
super(GamePhaseUpdate, self).__init__(**kwargs)
class SendGameMessage(_AbstractGameRequest):
""" Game message to send a user request.
:param message: message to send. See :class:`.Message` for more info.
message sender must be request user role (ie. power role, in such case).
Message time sent must not be defined, it will be allocated by server.
:type message: Message
:return:
- Server: :class:`.DataTimeStamp`
- Client: nothing (returned timestamp is just used to update message locally)
"""
__slots__ = ['message']
params = {strings.MESSAGE: parsing.JsonableClassType(Message)}
def __init__(self, **kwargs):
self.message = None # type: Message
super(SendGameMessage, self).__init__(**kwargs)
def test_jsonable_class_type():
""" Test parser for Jsonable sub-classes. """
checker = parsing.JsonableClassType(MyJsonable)
my_jsonable = MyJsonable(field_a=False,
field_b='test',
field_e={1},
field_f=[6.5])
my_jsonable_dict = {
'field_a': False,
'field_b': 'test',
'field_e': (1, 2),
'field_f': (1.0, 2.0),
}
checker.validate(my_jsonable)
assert_raises(lambda: checker.validate(None), exceptions.TypeException)
assert_raises(lambda: checker.validate(my_jsonable_dict),
exceptions.TypeException)
class DataGameSchedule(_AbstractResponse):
""" Response with info about current scheduling for a game.
Properties:
- **game_id**: str - game ID
- **phase**: str - game phase
- **schedule**: :class:`.SchedulerEvent` - scheduling information about the game
"""
__slots__ = ['game_id', 'phase', 'schedule']
params = {
'game_id': str,
'phase': str,
'schedule': parsing.JsonableClassType(SchedulerEvent)
}
def __init__(self, **kwargs):
self.game_id = ''
self.phase = ''
self.schedule = None # type: SchedulerEvent
super(DataGameSchedule, self).__init__(**kwargs)
def test_indexed_sequence():
""" Test parser type for dicts stored as sequences. """
checker = parsing.IndexedSequenceType(
parsing.DictType(str, parsing.JsonableClassType(MyJsonable)),
'field_b')
sequence = [
MyJsonable(field_a=True,
field_b='x1',
field_e=[1, 2, 3],
field_f=[1., 2., 3.]),
MyJsonable(field_a=True,
field_b='x3',
field_e=[1, 2, 3],
field_f=[1., 2., 3.]),
MyJsonable(field_a=True,
field_b='x2',
field_e=[1, 2, 3],
field_f=[1., 2., 3.]),
MyJsonable(field_a=True,
field_b='x5',
field_e=[1, 2, 3],
field_f=[1., 2., 3.]),
MyJsonable(field_a=True,
field_b='x4',
field_e=[1, 2, 3],
field_f=[1., 2., 3.])
]
dct = {element.field_b: element for element in sequence}
checker.validate(dct)
checker.update(dct)
jval = checker.to_json(dct)
assert isinstance(jval, list), type(jval)
from_jval = checker.to_type(jval)
assert isinstance(from_jval, dict), type(from_jval)
assert len(dct) == 5
assert len(from_jval) == 5
for key in ('x1', 'x2', 'x3', 'x4', 'x5'):
assert key in dct, (key, list(dct.keys()))
assert key in from_jval, (key, list(from_jval.keys()))
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 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
# 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/>.
# ==============================================================================
""" Utility class to save all data related to one game phase (phase name, state, messages and orders). """
from diplomacy.engine.message import Message
from diplomacy.utils import common, strings, parsing
from diplomacy.utils.jsonable import Jsonable
from diplomacy.utils.sorted_dict import SortedDict
MESSAGES_TYPE = parsing.IndexedSequenceType(
parsing.DictType(int, parsing.JsonableClassType(Message),
SortedDict.builder(int, Message)), 'time_sent')
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:
class DataGame(UniqueData):
""" Unique data containing a :class:`.Game` object. """
__slots__ = []
params = {strings.DATA: parsing.JsonableClassType(Game)}
def test_model_parsing():
""" Test parsing for a real model. """
model = {
'name': str,
'language': ('fr', 'en'),
'myjsonable': parsing.JsonableClassType(MyJsonable),
'mydict': parsing.DictType(str, float),
'nothing': (bool, str),
'default_float': parsing.DefaultValueType(float, 33.44),
'optional_float': parsing.OptionalValueType(float)
}
bad_data_field = {
'_name_':
'hello',
'language':
'fr',
'myjsonable':
MyJsonable(field_a=False, field_b='test', field_e={1}, field_f=[6.5]),
'mydict': {
'a': 2.5,
'b': -1.6
},
'nothing':
'thanks'
}
bad_data_type = {
'name':
'hello',
'language':
'fr',
'myjsonable':
MyJsonable(field_a=False, field_b='test', field_e={1}, field_f=[6.5]),
'mydict': {
'a': 2.5,
'b': -1.6
},
'nothing':
2.5
}
bad_data_value = {
'name':
'hello',
'language':
'__',
'myjsonable':
MyJsonable(field_a=False, field_b='test', field_e={1}, field_f=[6.5]),
'mydict': {
'a': 2.5,
'b': -1.6
},
'nothing':
'2.5'
}
good_data = {
'name':
'hello',
'language':
'fr',
'myjsonable':
MyJsonable(field_a=False, field_b='test', field_e={1}, field_f=[6.5]),
'mydict': {
'a': 2.5,
'b': -1.6
},
'nothing':
'2.5'
}
assert_raises(lambda: parsing.validate_data(bad_data_field, model),
(exceptions.TypeException, ))
assert_raises(lambda: parsing.validate_data(bad_data_type, model),
(exceptions.TypeException, ))
assert_raises(lambda: parsing.validate_data(bad_data_value, model),
(exceptions.ValueException, ))
assert 'default_float' not in good_data
assert 'optional_float' not in good_data
parsing.validate_data(good_data, model)
updated_good_data = parsing.update_data(good_data, model)
assert 'default_float' in updated_good_data
assert 'optional_float' in updated_good_data
assert updated_good_data['default_float'] == 33.44
assert updated_good_data['optional_float'] is None
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)
