def onConnect(cn):
setUsedTags(cn)
p = player(cn)
try:
if len(p.registered_tags) > 0:
execLater(initCheck, (cn,))
registerServerEventHandler('player_logged_in', onLogin)
except AttributeError:
pass
@usage cn
@public'''
if master_required and not isAtLeastMaster(cn):
insufficientPermissions(cn)
return
if args == '':
raise UsageError()
return
try:
tcn = int(args)
names = dbmanager.query(IpToNick).filter(
IpToNick.ip == sbserver.playerIpLong(tcn)).all()
if len(names) == 0:
sbserver.playerMessage(cn, info('No names found'))
return
except NoResultFound:
sbserver.playerMessage(cn, info('No names found'))
return
except ValueError:
sbserver.playerMessage(cn, error('Invalid cn'))
return
namestr = 'Other known names: '
for name in names:
namestr += name.nick + ' '
sbserver.playerMessage(cn, info(namestr))
Base.metadata.create_all(dbmanager.engine)
registerServerEventHandler('player_connect', onConnect)
registerServerEventHandler('player_name_changed', onNameChange)
from Bans.bans import ban
from xsbs.settings import PluginConfig
from xsbs.events import registerServerEventHandler
from xsbs.players import player
from xsbs.ui import warning
from xsbs.colors import colordict
import string
config = PluginConfig('notk')
limit = int(config.getOption('Config', 'teamkill_limit', '5'))
duration = int(config.getOption('Config', 'ban_time', '3600'))
warn_tk_limit = config.getOption('Config', 'warn_tk_limit', 'no') == 'yes'
warn_tk_message = config.getOption('Config', 'warn_tk_message', 'This server does not allow more than ${red}${limit}${white} teamkills per game')
del config
warn_tk_message = string.Template(warn_tk_message)
def onTeamkill(cn, tcn):
try:
if player(cn).teamkills() >= limit:
ban(cn, duration, 'killing teammates', -1)
elif warn_tk_limit and player(cn).teamkills() == 1:
player(cn).message(warning(warn_tk_message.substitute(colordict, limit=limit)))
except KeyError:
pass
registerServerEventHandler('player_teamkill', onTeamkill)
try:
sbserver.playerMessage(
cn,
info(
nextmap_response.substitute(colordict,
mapname=getSuccessor(
sbserver.gameMode(),
sbserver.mapName()))))
except (KeyError, ValueError):
sbserver.playerMessage(cn, error('Could not determine next map'))
def onConnect(cn):
if rotate_on_join[0]:
rotate_on_join[0] = False
sbserver.setPaused(False)
if preset_rotation:
modeMapLists = {}
for mode in map_modes:
modeMapLists[mode[0]] = mode[1].replace(' ', '').split(',')
rotate_on_join = [False]
mn = modes.index(start_mode)
sbserver.setMap(modeMapLists[start_mode][0], mn)
registerServerEventHandler('intermission_ended', presetRotate)
registerCommandHandler('nextmap', onNextMapCmd)
registerServerEventHandler('player_connect', onConnect)
else:
registerServerEventHandler('intermission_ended', onIntermEnd)
addTimer(1000, duelCountdown, (count-1, map, mode))
def onDuelCommand(cn, args):
if args == '':
sbserver.playerMessage(cn, error('Usage: #duel <mapname> (mode) (cn) (cn)'))
args = args.split(' ')
players = sbserver.players()
if len(players) != 2:
sbserver.playerMessage(cn, error('There must be only two unspectated players to enter duel mode.'))
else:
if len(args) == 2:
map = args[0]
mode = int(args[1])
elif len(args) == 1:
map = args[0]
mode = sbserver.gameMode()
else:
sbserver.playerMessage(cn, error('Usage: #duel <mapname> (mode)'))
return
duelers[0] = players[0]
duelers[1] = players[1]
prev_mastermode = sbserver.masterMode()
sbserver.setMasterMode(2)
sbserver.message(green('Duel begins in...'))
duelCountdown(5, map, mode)
registerCommandHandler('duel', onDuelCommand)
registerServerEventHandler('player_disconnect', onPlayerDisconnect)
registerServerEventHandler('map_changed', onMapChange)
from xsbs.events import registerServerEventHandler
from xsbs.players import player
from xsbs.ui import warning
from xsbs.colors import colordict
import string
config = PluginConfig('notk')
limit = int(config.getOption('Config', 'teamkill_limit', '5'))
duration = int(config.getOption('Config', 'ban_time', '3600'))
warn_tk_limit = config.getOption('Config', 'warn_tk_limit', 'no') == 'yes'
warn_tk_message = config.getOption(
'Config', 'warn_tk_message',
'This server does not allow more than ${red}${limit}${white} teamkills per game'
)
del config
warn_tk_message = string.Template(warn_tk_message)
def onTeamkill(cn, tcn):
try:
if player(cn).teamkills() >= limit:
ban(cn, duration, 'killing teammates', -1)
elif warn_tk_limit and player(cn).teamkills() == 1:
player(cn).message(
warning(warn_tk_message.substitute(colordict, limit=limit)))
except KeyError:
pass
registerServerEventHandler('player_teamkill', onTeamkill)
cn, error('Usage: #duel <mapname> (mode) (cn) (cn)'))
args = args.split(' ')
players = sbserver.players()
if len(players) != 2:
sbserver.playerMessage(
cn,
error(
'There must be only two unspectated players to enter duel mode.'
))
else:
if len(args) == 2:
map = args[0]
mode = int(args[1])
elif len(args) == 1:
map = args[0]
mode = sbserver.gameMode()
else:
sbserver.playerMessage(cn, error('Usage: #duel <mapname> (mode)'))
return
duelers[0] = players[0]
duelers[1] = players[1]
prev_mastermode = sbserver.masterMode()
sbserver.setMasterMode(2)
sbserver.message(green('Duel begins in...'))
duelCountdown(5, map, mode)
registerCommandHandler('duel', onDuelCommand)
registerServerEventHandler('player_disconnect', onPlayerDisconnect)
registerServerEventHandler('map_changed', onMapChange)
from xsbs.ui import insufficientPermissions, error
import sbserver
def onReqSpectate(cn, tcn):
if tcn != cn:
if isAtLeastMaster(cn):
sbserver.spectate(tcn)
else:
insufficientPermissions(cn)
else:
sbserver.spectate(tcn)
def onReqUnspectate(cn, tcn):
if tcn != cn:
if isAtLeastMaster(cn):
sbserver.unspectate(tcn)
else:
insufficientPermissions(cn)
else:
if sbserver.masterMode() > 1 and not isAtLeastMaster(cn):
sbserver.playerMessage(
cn, error('Master mode is locked. You cannot unspectate.'))
else:
sbserver.unspectate(tcn)
registerServerEventHandler('player_request_spectate', onReqSpectate)
registerServerEventHandler('player_request_unspectate', onReqUnspectate)
from xsbs.events import registerServerEventHandler
from xsbs.ui import error, info
from xsbs.colors import green, blue
from xsbs.players import masterRequired
import sbserver
MMNAMES = ['open',
'veto',
'locked',
'private']
@masterRequired
def setMM(cn, mm):
sbserver.message((info(green('%s') + ' set master mode to ' + blue('%s')) % (sbserver.playerName(cn), MMNAMES[mm])))
sbserver.setMasterMode(mm)
def onNoClients():
if sbserver.masterMode() > 1:
sbserver.setMasterMode(1)
registerServerEventHandler('player_set_mastermode', setMM)
registerServerEventHandler('no_clients', onNoClients)
import string
config = PluginConfig('gamenotifications')
tktemp = config.getOption('Config', 'teamkill', '${green}${tker}${white} team killed (${tkcount}) ${orange}${victim}')
uptemp = config.getOption('Config', 'map_uploaded', '${green}${name}${white} uploaded a map. /getmap to receive it')
getmaptemp = config.getOption('Config', 'get_map', '${green}${name}${white} is downloading map')
del config
tktemp = string.Template(tktemp)
uptemp = string.Template(uptemp)
getmaptemp = string.Template(getmaptemp)
def teamkill_broadcast(cn, tcn):
tker = player(cn)
target = player(tcn)
serverMessage(info(tktemp.substitute(colordict, tker=tker.name(), victim=target.name(), tkcount=tker.teamkills())))
def getmap(cn):
p = player(cn)
serverMessage(info(getmaptemp.substitute(colordict, name=p.name())))
def onUploadMap(cn):
p = player(cn)
serverMessage(info(uptemp.substitute(colordict, name=p.name())))
registerServerEventHandler('player_teamkill', teamkill_broadcast)
registerServerEventHandler('player_uploaded_map', onUploadMap)
registerServerEventHandler('player_get_map', getmap)
def checkModified(cn):
try:
p = player(cn)
if p.gamevars['modified_map'] and spectate_map_modified:
p.message(warning('You cannot play with a modified map.'))
p.spectate()
except KeyError:
pass
except ValueError:
pass
@masterRequired
def mapModifiedSpecCmd(cn, args):
'''@description Enable or disable spectate clients with modified map
@usage enable/disable'''
p = player(cn)
if args == 'disable':
spectate_map_modified = False
p.message(info('Spectate modified mapes disabled'))
elif args == 'enable':
spectate_map_modified = True
p.message(info('Spectate modified mapes enabled'))
else:
p.message(error('Usage: #mapmodifiedspec (enable/disable)'))
registerServerEventHandler('player_modified_map', onMapModified)
registerServerEventHandler('player_active', checkModified)
registerServerEventHandler('player_unspectated', checkModified)
registerCommandHandler('mapmodifiedspec', mapModifiedSpecCmd)
self.teamkills = teamkills
self.damage_delt = damage_delt
self.damage_recieved = damage_recieved
def flushPlayerSession(cn):
user = loggedInAs(cn)
p = player(cn)
stats = UserSessionStats(cn.id, time.time(), p.stats_frags, p.stats_deaths, p.stats_teamkills, sbserver.playerDamageDelt(cn), sbserver.playerDamageRecieved(cn))
def onConnect(cn):
player(cn).stats_frags = 0
player(cn).stats_deaths = 0
player(cn).stats_teamkills = 0
def onFrag(cn, tcn):
if cn == tcn:
val = suicide_fragval
else:
val = 1
try:
player(cn).stats_frags += val
except AttributeError:
player(cn).stats_frags = val
def onTeamKill(cn, tcn):
pass
registerServerEventHandler('player_frag', onFrag)
registerServerEventHandler('player_teamkill', onTeamKill)
import sbserver
from xsbs.settings import PluginConfig
from xsbs.colors import colordict
from xsbs.events import registerServerEventHandler
import string
def greet(cn):
sbserver.playerMessage(cn, motdstring)
config = PluginConfig('motd')
motdstring = config.getOption(
'Config', 'template', '${orange}Welcome to a ${red}XSBS ${orange}server')
del config
motdstring = string.Template(motdstring).substitute(colordict)
registerServerEventHandler('player_connect_delayed', greet)
msg += most_doublekillstemp.substitute(colordict, name=player(most_doublekills_cn).name(), count=most_doublekills)
msg += ' '
if most_triplekills > 0:
msg += most_triplekillstemp.substitute(colordict, name=player(most_triplekills_cn).name(), count=most_triplekills)
msg += ' '
if most_overkills > 0:
msg += most_overkillstemp.substitute(colordict, name=player(most_overkills_cn).name(), count=most_overkills)
msg += ' '
if most_killtaculars > 0:
msg += most_killtacularstemp.substitute(colordict, name=player(most_killtaculars_cn).name(), count=most_killtaculars)
msg += ' '
if most_killotrocities > 0:
msg += most_killotrocitiestemp.substitute(colordict, name=player(most_killotrocities_cn).name(), count=most_killotrocities)
msg += ' '
if most_killtastrophes > 0:
msg += most_killtastrophestemp.substitute(colordict, name=player(most_killtastrophes_cn).name(), count=most_killtastrophes)
msg += ' '
if most_killapocalypses > 0:
msg += most_killapocalypsestemp.substitute(colordict, name=player(most_killapocalypses_cn).name(), count=most_killapocalypses)
msg += ' '
if most_killionaires > 0:
msg += most_killionairestemp.substitute(colordict, name=player(most_killionaires_cn).name(), count=most_killionaires)
msg += ' '
if msg != '':
msg = awards_prefix + msg
serverMessage(msg)
registerServerEventHandler('intermission_begin', onIntermission)
try:
p = player(cn)
if p.gamevars['modified_map'] and spectate_map_modified:
p.message(warning('You cannot play with a modified map.'))
p.spectate()
except KeyError:
pass
except ValueError:
pass
@masterRequired
def mapModifiedSpecCmd(cn, args):
'''@description Enable or disable spectate clients with modified map
@usage enable/disable'''
p = player(cn)
if args == 'disable':
spectate_map_modified = False
p.message(info('Spectate modified mapes disabled'))
elif args == 'enable':
spectate_map_modified = True
p.message(info('Spectate modified mapes enabled'))
else:
p.message(error('Usage: #mapmodifiedspec (enable/disable)'))
registerServerEventHandler('player_modified_map', onMapModified)
registerServerEventHandler('player_active', checkModified)
registerServerEventHandler('player_unspectated', checkModified)
registerCommandHandler('mapmodifiedspec', mapModifiedSpecCmd)
def init():
registerServerEventHandler('player_setmaster', onSetMaster)
registerServerEventHandler('player_setmaster_off', onSetMasterOff)
registerServerEventHandler('player_claimed_master', onGainMaster)
registerServerEventHandler('player_claimed_admin', onGainAdmin)
registerServerEventHandler('player_released_master', onRelMaster)
registerServerEventHandler('player_released_admin', onRelAdmin)
registerServerEventHandler('player_auth_succeed', onAuthSuccess)
Base.metadata.create_all(dbmanager.engine)
def onNextMapCmd(cn, args):
'''@description Display next map
@usage
@public'''
if args != '':
sbserver.playerMessage(cn, error('Usage: #nextmap'))
else:
try:
sbserver.playerMessage(cn, info(nextmap_response.substitute(colordict, mapname=getSuccessor(sbserver.gameMode(), sbserver.mapName()))))
except (KeyError, ValueError):
sbserver.playerMessage(cn, error('Could not determine next map'))
def onConnect(cn):
if rotate_on_join[0]:
rotate_on_join[0] = False
sbserver.setPaused(False)
if preset_rotation:
modeMapLists = {}
for mode in map_modes:
modeMapLists[mode[0]] = mode[1].replace(' ', '').split(',')
rotate_on_join = [False]
mn = modes.index(start_mode)
sbserver.setMap(modeMapLists[start_mode][0], mn)
registerServerEventHandler('intermission_ended', presetRotate)
registerCommandHandler('nextmap', onNextMapCmd)
registerServerEventHandler('player_connect', onConnect)
else:
registerServerEventHandler('intermission_ended', onIntermEnd)
(sbserver.playerName(x), x, y))),
'map_change':
('map_changed',
lambda x, y: factory.broadcast('\x038Map changed to:\x03 %s (%s)' %
(x, sbserver.modeName(y)))),
'gain_admin': ('player_claimed_admin', lambda x: factory.
broadcast('%s (\x037 %i \x03) \x036Has claimed admin\x03' %
(sbserver.playerName(x), x))),
'gain_master': ('player_claimed_master', lambda x: factory.broadcast(
'%s (\x037 %i \x03) \x036Has claimed master\x03' %
(sbserver.playerName(x), x))),
'auth': ('player_auth_succeed', lambda x, y: factory.broadcast(
'%s (\x037 %i \x03) has authenticated as\x036 %[email protected]\x03' %
(sbserver.playerName(x), x, y))),
'relinquish_admin': ('player_released_admin', lambda x: factory.broadcast(
'%s (\x037 %i \x03) \x036Has relinquished admin\x03' %
(sbserver.playerName(x), x))),
'relinquish_master':
('player_released_master', lambda x: factory.
broadcast('%s (\x037 %i \x03) \x036Has relinquished master\x03' %
(sbserver.playerName(x), x))),
}
if enable:
factory = IrcBotFactory(nickname, [channel])
factory.doConnect()
for key in event_abilities.keys():
if config.getOption('Abilities', key, 'no') == 'yes':
ev = event_abilities[key]
registerServerEventHandler(ev[0], ev[1])
def init():
registerServerEventHandler('player_setmaster', onSetMaster)
registerServerEventHandler('player_setmaster_off', onSetMasterOff)
registerServerEventHandler('player_claimed_master', onGainMaster)
registerServerEventHandler('player_claimed_admin', onGainAdmin)
registerServerEventHandler('player_released_master', onRelMaster)
registerServerEventHandler('player_released_admin', onRelAdmin)
registerServerEventHandler('player_auth_succeed', onAuthSuccess)
Base.metadata.create_all(dbmanager.engine)
from xsbs.events import registerServerEventHandler
from xsbs.ui import error, info
from xsbs.colors import green, blue
from xsbs.players import masterRequired
import sbserver
MMNAMES = ['open', 'veto', 'locked', 'private']
@masterRequired
def setMM(cn, mm):
sbserver.message((info(green('%s') + ' set master mode to ' + blue('%s')) %
(sbserver.playerName(cn), MMNAMES[mm])))
sbserver.setMasterMode(mm)
def onNoClients():
if sbserver.masterMode() > 1:
sbserver.setMasterMode(1)
registerServerEventHandler('player_set_mastermode', setMM)
registerServerEventHandler('no_clients', onNoClients)
self.bots.append(bot)
def signedOut(self, bot):
if bot in self.bots:
self.bots.remove(bot)
addTimer(5000, self.doReconnect, ())
def broadcast(self, message):
for bot in self.bots:
bot.broadcast(message)
event_abilities = {
'player_active': ('player_connect', lambda x: factory.broadcast('%s (\x037 %i \x03) \x032Connected\x03' % (sbserver.playerName(x), x))),
'player_disconnect': ('player_disconnect', lambda x: factory.broadcast('%s (\x037 %i \x03) \x032Disconnected\x03' % (sbserver.playerName(x), x))),
'message': ('player_message', lambda x, y: factory.broadcast('%s (\x037 %i \x03): %s' % (sbserver.playerName(x), x, y))),
'map_change': ('map_changed', lambda x, y: factory.broadcast('\x038Map changed to:\x03 %s (%s)' % (x, sbserver.modeName(y)))),
'gain_admin': ('player_claimed_admin', lambda x: factory.broadcast('%s (\x037 %i \x03) \x036Has claimed admin\x03' % (sbserver.playerName(x), x))),
'gain_master': ('player_claimed_master', lambda x: factory.broadcast('%s (\x037 %i \x03) \x036Has claimed master\x03' % (sbserver.playerName(x), x))),
'auth': ('player_auth_succeed', lambda x, y: factory.broadcast('%s (\x037 %i \x03) has authenticated as\x036 %[email protected]\x03' % (sbserver.playerName(x), x, y))),
'relinquish_admin': ('player_released_admin', lambda x: factory.broadcast('%s (\x037 %i \x03) \x036Has relinquished admin\x03' % (sbserver.playerName(x), x))),
'relinquish_master': ('player_released_master', lambda x: factory.broadcast('%s (\x037 %i \x03) \x036Has relinquished master\x03' % (sbserver.playerName(x), x))),
}
if enable:
factory = IrcBotFactory(nickname, [channel])
factory.doConnect()
for key in event_abilities.keys():
if config.getOption('Abilities', key, 'no') == 'yes':
ev = event_abilities[key]
registerServerEventHandler(ev[0], ev[1])
'''@description Display names used by client
@usage cn
@public'''
if master_required and not isAtLeastMaster(cn):
insufficientPermissions(cn)
return
if args == '':
raise UsageError()
return
try:
tcn = int(args)
names = dbmanager.query(IpToNick).filter(IpToNick.ip==sbserver.playerIpLong(tcn)).all()
if len(names) == 0:
sbserver.playerMessage(cn, info('No names found'))
return
except NoResultFound:
sbserver.playerMessage(cn, info('No names found'))
return
except ValueError:
sbserver.playerMessage(cn, error('Invalid cn'))
return
namestr = 'Other known names: '
for name in names:
namestr += name.nick + ' '
sbserver.playerMessage(cn, info(namestr))
Base.metadata.create_all(dbmanager.engine)
registerServerEventHandler('player_connect', onConnect)
registerServerEventHandler('player_name_changed', onNameChange)
from xsbs.events import registerServerEventHandler
from xsbs.players import isAtLeastMaster
from xsbs.ui import insufficientPermissions, error
import sbserver
def onReqSpectate(cn, tcn):
if tcn != cn:
if isAtLeastMaster(cn):
sbserver.spectate(tcn)
else:
insufficientPermissions(cn)
else:
sbserver.spectate(tcn)
def onReqUnspectate(cn, tcn):
if tcn != cn:
if isAtLeastMaster(cn):
sbserver.unspectate(tcn)
else:
insufficientPermissions(cn)
else:
if sbserver.masterMode() > 1 and not isAtLeastMaster(cn):
sbserver.playerMessage(cn, error('Master mode is locked. You cannot unspectate.'))
else:
sbserver.unspectate(tcn)
registerServerEventHandler('player_request_spectate', onReqSpectate)
registerServerEventHandler('player_request_unspectate', onReqUnspectate)
msg += most_doublekillstemp.substitute(colordict, name=player(most_doublekills_cn).name(), count=most_doublekills)
msg += ' '
if most_triplekills > 0:
msg += most_triplekillstemp.substitute(colordict, name=player(most_triplekills_cn).name(), count=most_triplekills)
msg += ' '
if most_overkills > 0:
msg += most_overkillstemp.substitute(colordict, name=player(most_overkills_cn).name(), count=most_overkills)
msg += ' '
if most_killtaculars > 0:
msg += most_killtacularstemp.substitute(colordict, name=player(most_killtaculars_cn).name(), count=most_killtaculars)
msg += ' '
if most_killotrocities > 0:
msg += most_killotrocitiestemp.substitute(colordict, name=player(most_killotrocities_cn).name(), count=most_killotrocities)
msg += ' '
if most_killtastrophes > 0:
msg += most_killtastrophestemp.substitute(colordict, name=player(most_killtastrophes_cn).name(), count=most_killtastrophes)
msg += ' '
if most_killapocalypses > 0:
msg += most_killapocalypsestemp.substitute(colordict, name=player(most_killapocalypses_cn).name(), count=most_killapocalypses)
msg += ' '
if most_killionaires > 0:
msg += most_killionairestemp.substitute(colordict, name=player(most_killionaires_cn).name(), count=most_killionaires)
msg += ' '
if msg != '':
msg = awards_prefix + msg
serverMessage(msg)
registerServerEventHandler('intermission_begin', onIntermission)
import sbserver
from xsbs.settings import PluginConfig
from xsbs.colors import colordict
from xsbs.events import registerServerEventHandler
import string
def greet(cn):
sbserver.playerMessage(cn, motdstring)
config = PluginConfig('motd')
motdstring = config.getOption('Config', 'template', '${orange}Welcome to a ${red}XSBS ${orange}server')
del config
motdstring = string.Template(motdstring).substitute(colordict)
registerServerEventHandler('player_connect_delayed', greet)
