def __init__(self, service, plugins):
# Register a function to listen to the game events.
self.service = service
self.service.listen().addCallback(self.self_notify)
# Storage for our messages
self.messages = []
# Implement the path conventions
self.confdir = os.path.join(self.service.settings['plugins-confdir'], self.name())
self.libdir = os.path.join(self.service.settings['plugins-libdir'], self.name())
self.logdir = os.path.join(self.service.settings['plugins-logdir'], self.name())
# Initialize logdir, and make sure we have write permissions.
# If not, turn off logging.
self.logging = True
if not os.path.exists(self.logdir):
try:
os.makedirs(self.logdir)
except OSError:
self.logging = False
elif not os.access(self.logdir, os.W_OK):
self.logging = False
# Initialize the pollable using the recommended timeout.
Pollable.__init__(self, self.service.settings.get('poll-timeout', 30))
def __init__(self, service, plugins):
# Storage for tables
self.tables = []
# Store the relationship between tables and games
self.game2table = {}
# Depends on the activity plugin (to know when players are online)
for plugin in plugins:
if plugin.name() == 'activity':
self.activity_plugin = plugin
assert self.activity_plugin
# Register a function to know when players go online/offline
self.activity_plugin.listen().addCallback(self.on_activity_notification)
# Register a function to listen to the game events.
self.service = service
self.service.listen().addCallback(self.on_service_notification)
# Implement the path conventions
self.confdir = os.path.join(self.service.settings['plugins-confdir'], self.name())
self.libdir = os.path.join(self.service.settings['plugins-libdir'], self.name())
# Initialize the pollable using the recommended timeout.
Pollable.__init__(self, self.service.settings.get('poll-timeout', 30))
def __init__(self, service, plugins):
#
# The example depends on another plugin and checks
# that it has been loaded before it. It relies on the
# name() method to identify the plugin.
#
for plugin in plugins:
if plugin.name() == 'another':
self.another = plugin
assert self.another
#
# Register a function to listen to the game events.
# check the documentation of the self_notify method.
#
self.service = service
self.service.listen().addCallback(self.accept)
#
# Implement the path conventions as described above ( look for plugins-confdir )
#
self.confdir = os.path.join(self.service.settings['plugins-confdir'], self.name())
self.libdir = os.path.join(self.service.settings['plugins-libdir'], self.name())
#
# initialize the pollable using the service parameters. There is
# no reason to improve or change these parameters.
#
Pollable.__init__(self, self.service.settings.get('poll-timeout', 30))
def __init__(self, service, plugins):
# Register a function to listen to the game events.
self.service = service
self.service.listen().addCallback(self.self_notify)
# Storage for our messages
self.messages = []
# Implement the path conventions
self.confdir = os.path.join(self.service.settings['plugins-confdir'],
self.name())
self.libdir = os.path.join(self.service.settings['plugins-libdir'],
self.name())
self.logdir = os.path.join(self.service.settings['plugins-logdir'],
self.name())
# Initialize logdir, and make sure we have write permissions.
# If not, turn off logging.
self.logging = True
if not os.path.exists(self.logdir):
try:
os.makedirs(self.logdir)
except OSError:
self.logging = False
elif not os.access(self.logdir, os.W_OK):
self.logging = False
# Initialize the pollable using the recommended timeout.
Pollable.__init__(self, self.service.settings.get('poll-timeout', 30))
def __init__(self, service, plugins):
#
# The example depends on another plugin and checks
# that it has been loaded before it. It relies on the
# name() method to identify the plugin.
#
for plugin in plugins:
if plugin.name() == 'another':
self.another = plugin
assert self.another
#
# Register a function to listen to the game events.
# check the documentation of the self_notify method.
#
self.service = service
self.service.listen().addCallback(self.accept)
#
# Implement the path conventions as described above ( look for plugins-confdir )
#
self.confdir = os.path.join(self.service.settings['plugins-confdir'],
self.name())
self.libdir = os.path.join(self.service.settings['plugins-libdir'],
self.name())
#
# initialize the pollable using the service parameters. There is
# no reason to improve or change these parameters.
#
Pollable.__init__(self, self.service.settings.get('poll-timeout', 30))
def __init__(self, service, plugins):
# Register a function to listen to the game events.
self.service = service
self.service.listen().addCallback(self.self_notify)
# Implement the path conventions
self.confdir = os.path.join(self.service.settings['plugins-confdir'], self.name())
self.libdir = os.path.join(self.service.settings['plugins-libdir'], self.name())
# Load bots logic
brain = NLWordMatcherBrain(self)
# Load configuration and instantiate bots
self.settings = objectify.parse(open(os.path.join(self.confdir, 'bot.xml'))).getroot()
self.delays = {}
self.bots = []
for node in self.settings.iterchildren():
if node.tag == "delay":
self.delays[node.get('type')] = {'base': int(node.get('base')),
'random': int(node.get('random'))}
elif node.tag == "botinstance":
bot = Bot(self, brain, int(node.get('player_id')))
self.bots.append(bot)
# Store enable_join per game.
self.enable_join = {}
# Initialize the pollable using the recommended timeout.
Pollable.__init__(self, self.service.settings.get('poll-timeout', 30))
def __init__(self, service, id=None):
self.service = service
self.settings = service.settings
self.id = id
self.owner_id = None
self.players = []
self.invited = []
Pollable.__init__(self, self.settings.get('poll-timeout', 30))
def __init__(self, table_plugin):
self.table_plugin = table_plugin
self.activity_plugin = self.table_plugin.activity_plugin
self.service = self.table_plugin.service
self.games_ids = []
self.last_owners_ids = []
self.next_owner_id = None
Pollable.__init__(self, self.service.settings.get("poll - timeout", 30))
def __init__(self, service, plugins):
self.service = service
self.observers = []
self.online_players = {}
self.service.listen().addCallback(self.on_service_notification)
# Implement the path conventions
self.confdir = os.path.join(self.service.settings['plugins-confdir'], self.name())
self.libdir = os.path.join(self.service.settings['plugins-libdir'], self.name())
# Initialize the pollable using the recommended timeout.
Pollable.__init__(self, self.service.settings.get('poll-timeout', 30))
def __init__(self, service, plugins):
self.service = service
self.observers = []
self.online_players = {}
self.service.listen().addCallback(self.on_service_notification)
# Implement the path conventions
self.confdir = os.path.join(self.service.settings['plugins-confdir'],
self.name())
self.libdir = os.path.join(self.service.settings['plugins-libdir'],
self.name())
# Initialize the pollable using the recommended timeout.
Pollable.__init__(self, self.service.settings.get('poll-timeout', 30))
def destroy(self):
self.clear_countdown()
if hasattr(self, 'timer') and self.timer.active():
self.timer.cancel()
if hasattr(self, 'service'):
del self.service
return Pollable.destroy(self)
def __init__(self, table_plugin):
self.table_plugin = table_plugin
self.activity_plugin = self.table_plugin.activity_plugin
self.service = self.table_plugin.service
# A list of game IDs of all games ever played in this table,
# in chronological order (oldest game comes first in the list,
# while the last game in the list is the most recent, "current" game
# of the table.
self.games_ids = []
# A list of new games that were created as next_games of the table, but didn't
# yet reach the 'invitation' state. The first pending game that reaches
# 'invitation' state is promoted to be the next_game, while any other
# pending game is spun off into its own, brand new table.
self.pending_games = []
# A list of unique IDs of all users that were chosen to be the next_owner
# at some point (even if they failed to create the next game),
# in reverse chronological order (owner that was the most recent next_owner
# comes first in the list). Keeping track of them for the sole purpose of
# being able to cycle between next owners when the time to update next_owner_id comes.
self.chosen_owners_ids = []
# The ID of the player who is currently chosen as the next owner.
self.next_owner_id = None
# Timer that keeps track of how long it takes the next_owner to create the next
# game and make it "playable" (move it into invitation state). If the next owner
# doesn't manage to do that in under NEXT_GAME_TIMEOUT seconds, another next_owner
# is chosen instead.
self.next_game_timer = None
# When current game is completed, self.next_game_promoted is set to False until one
# of the pending games that get created is promoted to be the new current game.
self.next_game_promoted = None
# If self.next_owner_id is currently (asynchonously) being updated,
# self.next_owner_deferred is set to a deferred that will fire once the update_next_owner_id
# operation completes. Set to None when no next_owner update is in progress.
self._next_owner_deferred = None
# update_next_owner_id is asynchronous because its waiting for results of get_active_players
# operation. We store this as an attribute of the table, so that we are able to cancel the
# deferred attached to the get_active_players result and start a new one in case a new
# update_next_owner_id request is made before the one already in progress completes.
# This is an implementation detail.
self._active_players_deferred = None
Pollable.__init__(self, self.service.settings.get('poll - timeout', 30))
def get_modified(self, args=None):
"""
Returns last poll object modification
Redefined from Pollable.get_modified() to delegate to the relevant table when available
"""
game_id = self.get_game_id_from_args(args)
if game_id in self.game2table:
table = self.game2table[game_id]
return table.get_modified()
else:
return Pollable.get_modified(self)
def poll(self, args):
"""
Handles poll requests
Redefined from Pollable.poll() to delegate to the relevant table when available
Otherwise monitors new game/table availability.
"""
game_id = self.get_game_id_from_args(args)
# Delegate poll() to table when it exists
if game_id in self.game2table:
table = self.game2table[game_id]
return table.poll(args)
# The current game isn't in a table, or no game is displayed at all.
# The poll returns when a new game becomes available in any table
else:
return Pollable.poll(self, args)
def __init__(self):
Pollable.__init__(self, 200000000000)
def touch(self, *args, **kwargs):
self.update_timer()
kwargs['game_id'] = [self.id]
return Pollable.touch(self, kwargs)
