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',
