async def test_registering(self): instance = Controller.prepare(name='default').instance test1 = Callback(call='SampleCall', code='sample_call', namespace='tests', target=self.handle_sample) test1_comp = instance.signals.get_callback('SampleCall') assert test1.raw_signal == test1_comp
async def test_listening(self): test1 = Callback(call='SampleCall', code='sample_call', namespace='tests', target=self.handle_sample) self.got_sync = 0 self.got_async = 0 self.got_handle = 0 self.got_glue = 0 test1.register(self.sync_listener) test1.register(self.async_listener) await test1.raw_signal.send(dict(glue=False), raw=False) await test1.raw_signal.send_robust(dict(glue=False), raw=False) assert self.got_async == 2 assert self.got_sync == 2 assert self.got_glue == 0 assert self.got_handle == 2
from pyplanet.core import Controller from pyplanet.core.events import Callback, handle_generic async def handle_map_loading(source, signal, **kwargs): map = await Controller.instance.map_manager.get_map( uid=source['map']['uid']) return dict( map=map, restarted=source.get('restarted', None), ) server_start = Callback( call='Script.Maniaplanet.StartServer_Start', namespace='maniaplanet', code='server_start', target=handle_generic, ) """ :Signal: Server Start signal :Code: ``maniaplanet:server_start`` :Description: This callback is called when the server script is (re)started. The begin of the event. :Original Callback: `Script` Maniaplanet.StartServer_Start :param restarted: Boolean giving information if the script has restarted. :param time: Server time when callback has been sent. """
return dict(players=players) async def handle_joust_results(source, signal, **kwargs): async def get_player_result(data): player = await Controller.instance.player_manager.get_player( login=data['login']) return dict(player=player, score=data['score']) players = await asyncio.gather( *[get_player_result(d) for d in source['players']]) return dict(players=players) player_reload = Callback(call='Script.Shootmania.Joust.OnReload', namespace='shootmania', code='joust_player_reload', target=handle_generic) """ :Signal: Player reloads its weapon and capture pole. :Code: ``shootmania:joust_player_reload`` :Description: Callback sent when a player capture a pole to reload its weapons. :Original Callback: `Script` Shootmania.Joust.OnReload :param login: Player login. :param player: Player instance. :type player: pyplanet.apps.core.maniaplanet.models.player.Player """
is_pure_spectator=is_pure_spectator, auto_target=auto_target, target_id=target_id, target=target, flags=source['Flags'], spectator_status=source['SpectatorStatus'], team_id=source['TeamId'], player_id=source['PlayerId'], player=player, player_login=source['Login'], ) player_connect = Callback( call='ManiaPlanet.PlayerConnect', namespace='maniaplanet', code='player_connect', target=handle_player_connect, ) """ :Signal: Player has been connected. :Code: ``maniaplanet:player_connect`` :Description: Callback sent when a player connects and we fetched our data. :Original Callback: `Native` Maniaplanet.PlayerConnect :param player: Player instance :param is_spectator: Boolean determinating if the player joined as spectator. :param source: Raw payload, best to not use!
async def handle_vote_updated(source, signal, **kwargs): state, login, cmd_name, cmd_param = source player = None try: player = await Controller.instance.player_manager.get_player(login) except PlayerNotFound: player = None return dict(player=player, state=state, cmd_name=cmd_name, cmd_param=cmd_param) bill_updated = Callback(call='ManiaPlanet.BillUpdated', namespace='maniaplanet', code='bill_updated', target=handle_bill_updated) """ :Signal: Bill has been updated. :Code: ``maniaplanet:bill_updated`` :Description: Callback sent when a bill has been updated. :Original Callback: `Native` Maniaplanet.BillUpdated :param 1: Bill id. :param 2: State. :param 3: State name. :param 4: Transaction id.
*[get_team_scores(d) for d in source['teams']]) return dict(players=player_scores, teams=team_scores, winner_team=source['winnerteam'], use_teams=source['useteams'], winner_player=source['winnerplayer'], section=source['section']) ####################################################################################### # Generic ####################################################################################### on_shoot = Callback( call='Script.Shootmania.Event.OnShoot', namespace='shootmania', code='on_shoot', target=handle_on_shoot, ) """ :Signal: Player shoot. :Code: ``shootmania:on_shoot`` :Description: Callback sent when a player shoots. :Original Callback: `Script` Shootmania.Event.OnShoot :param shooter: Shooter, Player instance :param time: Time of server when callback is sent. :param weapon: Weapon number.
) async def handle_stunt(source, signal, **kwargs): player = await Controller.instance.player_manager.get_player(login=source['login']) return dict( player=player, race_time=source['racetime'], lap_time=source['laptime'], stunt_score=source['stuntsscore'], figure=source['figure'], angle=source['angle'], points=source['points'], combo=source['combo'], is_straight=source['isstraight'], is_reverse=source['isreverse'], is_master_jump=source['ismasterjump'], factor=source['factor'] ) start_line = Callback( call='Script.Trackmania.Event.StartLine', namespace='trackmania', code='start_line', target=handle_start_line, ) """ :Signal: Player drives off from the start line. :Code: ``trackmania:start_line`` :Description: Callback sent when a player starts to race (at the end of the 3,2,1,GO! sequence). :Original Callback: `Script` Trackmania.Event.StartLine :param time: Server time when callback has been sent. :param player: Player instance :param flow: Flow class instance.
section=source['section'] ) async def handle_stunt(source, signal, **kwargs): player = await Controller.instance.player_manager.get_player(login=source['login']) return dict( player=player, race_time=source['racetime'], lap_time=source['laptime'], stunt_score=source['stuntsscore'], figure=source['figure'], angle=source['angle'], points=source['points'], combo=source['combo'], is_straight=source['isstraight'], is_reverse=source['isreverse'], is_master_jump=source['ismasterjump'], factor=source['factor'] ) start_line = Callback( call='Script.Trackmania.Event.StartLine', namespace='trackmania', code='start_line', target=handle_start_line, ) """ :Signal: Player drives off from the start line. :Code: ``trackmania:start_line`` :Description: Callback sent when a player starts to race (at the end of the 3,2,1,GO! sequence). :Original Callback: `Script` Trackmania.Event.StartLine :param time: Server time when callback has been sent. :param player: Player instance :param flow: Flow class instance.
async def handle_elite_turn_start(source, signal, **kwargs): attacker = await Controller.instance.player_manager.get_player(login=source['attacker']) defenders = await asyncio.gather(*[ Controller.instance.player_manager.get_player(login=p) for p in source['defenders'] ]) return dict(attacker=attacker, defenders=defenders) async def handle_elite_turn_end(source, signal, **kwargs): return dict(victory_type=source['victorytype']) turn_start = Callback( call='Script.Shootmania.Elite.StartTurn', namespace='shootmania', code='elite_turn_start', target=handle_elite_turn_start ) """ :Signal: Elite turn start. :Code: ``shootmania:elite_turn_start`` :Description: Information about the starting turn. :Original Callback: `Script` Shootmania.Elite.StartTurn :param attacker: Player instance of attacker. :param defenders: List with player instances of defenders. :type attacker: pyplanet.apps.core.maniaplanet.models.player.Player
source = dict() source['maps_updated'] = updated return source async def handle_map_start(source, signal, **kwargs): # Get the map map = await Controller.instance.map_manager.get_map(source['map']['uid']) return dict( time=source['time'], count=source['count'], restarted=source['restarted'], map=map, ) # We don't use scripted map events due to the information we get and the stability of the information structure. map_begin = Callback( call='ManiaPlanet.BeginMap', namespace='maniaplanet', code='map_begin', target=handle_map_begin, ) """ :Signal: Begin of map. :Code: ``maniaplanet:map_begin`` :Description: Callback sent when map begins. :Original Callback: `Native` Maniaplanet.BeginMap :param map: Map instance. :type map: pyplanet.apps.core.maniaplanet.models.map.Map """
async def handle_manialink_answer(source, signal, **kwargs): _, player_login, action, raw_values = source values = dict() if isinstance(raw_values, list): for val in raw_values: values[val['Name']] = val['Value'] player = await Controller.instance.player_manager.get_player(login=player_login) return dict(player=player, action=action, values=values) manialink_answer = Callback( call='ManiaPlanet.PlayerManialinkPageAnswer', namespace='maniaplanet', code='manialink_answer', target=handle_manialink_answer, ) """ :Signal: Player has raised an action on the Manialink. :Code: ``maniaplanet:manialink_answer`` :Description: Callback sent when a player clicks on an event of a manialink. :Original Callback: `Native` Maniaplanet.PlayerManialinkPageAnswer :param player: Player instance :param action: Action name
from pyplanet.core import Controller from pyplanet.core.events import Callback, handle_generic async def handle_royal_points(source, signal, **kwargs): player = await Controller.instance.player_manager.get_player( login=source['login']) return dict(player=player, type=source['type'], points=source['points']) player_score_points = Callback(call='Script.Shootmania.Royal.Points', namespace='shootmania', code='royal_player_score_points', target=handle_royal_points) """ :Signal: Player score points. :Code: ``shootmania:royal_player_score_points`` :Description: Callback sent when a player scores some points. :Original Callback: `Script` Shootmania.Royal.Points :param player: Player instance. :param type: Type of score, like 'Pole', 'Hit', or 'Survival'. :param points: Points that the player gains. :type player: pyplanet.apps.core.maniaplanet.models.player.Player """ player_spawn = Callback(call='Script.Shootmania.Royal.PlayerSpawn',