def login(cn, user):
if isLoggedIn(cn):
raise StateError('You are already logged in')
player(cn).user = user
player(cn).logged_in = True
triggerServerEvent('player_logged_in', (cn,))
sbserver.message(info(green(sbserver.playerName(cn)) + ' is verified'))
def add_kill(self, killercn, victimcn): #updates the ownage datatype for the killer and victim killerplayer = player(killercn) victimplayer = player(victimcn) killerplayer.ownagedata.commit_kill(victimcn) victimplayer.ownagedata.commit_death(killercn)
def CheckForSpammers():
#sbserver.message("Check for spammers ran")
log = chatlog.get_log()
cn_occurs_1sec = {}
cn_occurs_interval = {}
for timekey in log.keys():
chatcn = log[timekey][0]
if (time.time() - timekey) <= 1:
if not chatcn in cn_occurs_1sec.keys():
cn_occurs_1sec[chatcn] = 1
else:
cn_occurs_1sec[chatcn] += 1
if not chatcn in cn_occurs_interval.keys():
cn_occurs_interval[chatcn] = 1
else:
cn_occurs_interval[chatcn] += 1
for occur in cn_occurs_1sec.keys():
if cn_occurs_1sec[occur] > max_per_second:
spammermanager.add_spamming_case(player(occur).ipString())
else:
for occur in cn_occurs_interval.keys():
if cn_occurs_interval[occur] > max_per_interval:
spammermanager.add_spamming_case(player(occur).ipString())
def onMuteCommand(cn, args):
'''@description Mute a player
@usage cn'''
try:
args = args.split(' ')
tcn = int(args[0])
if len(args) > 1:
raise KeyError
try:
p = player(tcn)
except ValueError:
raise StateError('Invalid player cn')
else:
try:
muted = p.is_muted
except AttributeError:
muted = False
if muted:
raise StateError('Player is already muted.')
else:
p.is_muted = True
name = p.name()
muter = player(cn).name()
sbserver.message(info(muted_temp.substitute(colordict, muted_name=name, muter=muter)))
except KeyError:
raise UsageError()
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
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 onSmiteCommand(cn, args): '''@description Strike a player down @usage <cn> @master''' if args == '': raise UsageError() p = player(cn) t = player(int(args)) sendServerMessage(info(smite_template.substitute(colordict, smiter=p.name(), smited=t.name()))) t.suicide()
def userPrivSetCmd(cn, tcn, args):
user_id = player(tcn).user.id
if args == 'user':
try:
if isUser(player(tcn).user.id):
sbserver.playerMessage(cn, error('%s already has user permissions.' % sbserver.playerName(tcn)))
return
except (ValueError, AttributeError):
pass
else:
try:
user = loggedInAs(tcn)
except AttributeError:
sbserver.playerMessage(cn, error('%s is not logged in.' % sbserver.playerName(tcn)))
else:
dbmanager.query(UserPrivilege).filter(UserPrivilege.user_id==user_id).update({ 'privilege': None })
session.add(UserPrivilege(0, user.id))
session.commit()
sbserver.playerMessage(cn, info('User privilege has been given to %s (%s)' % (sbserver.playerName(tcn), user.email)))
elif args == 'master':
try:
if isUserMaster(player(tcn).user.id):
sbserver.playerMessage(cn, error('%s already has master permissions.' % sbserver.playerName(tcn)))
return
except (ValueError, AttributeError):
pass
else:
try:
user = loggedInAs(tcn)
except AttributeError:
sbserver.playerMessage(cn, error('%s is not logged in.' % sbserver.playerName(tcn)))
else:
dbmanager.query(UserPrivilege).filter(UserPrivilege.user_id==user_id).update({ 'privilege': None })
session.add(UserPrivilege(1, user.id))
session.commit()
sbserver.playerMessage(cn, info('Master privilege has been given to %s (%s)' % (sbserver.playerName(tcn), user.email)))
elif args == 'admin':
try:
if isUserAdmin(player(tcn).user.id):
sbserver.playerMessage(cn, error('%s already has admin permissions.' % sbserver.playerName(tcn)))
return
except (ValueError, AttributeError):
pass
else:
try:
user = loggedInAs(tcn)
except AttributeError:
sbserver.playerMessage(cn, error('%s is not logged in.' % sbserver.playerName(tcn)))
else:
dbmanager.query(UserPrivilege).filter(UserPrivilege.user_id==user_id).update({ 'privilege': None })
session.add(UserPrivilege(2, user.id))
session.commit()
sbserver.playerMessage(cn, info('Admin privilege has been given to %s (%s)' % (sbserver.playerName(tcn), user.email)))
else:
sbserver.playerMessage(cn, error('Privilege level must be \'master\' to set master permissions and \'admin\' to set master or admin permissions'))
def onPlayerActive(cn): nick = sbserver.playerName(cn) p = player(cn) try: nickacct = nickReserver(sbserver.playerName(cn)) except NoResultFound: p.warning_for_login = False return p = player(cn) p.warning_for_login = True p.warn_nickacct = nickacct warnNickReserved(cn, 0, sbserver.playerSessionId(cn))
def onPmCommand(cn, args):
'''@description Send a private message
@usage <cn> <message>
@public'''
args = args.split()
if len(args) < 2:
raise UsageError()
i = 0
for key in args:
if i > 1:
args[1] += (" " + str(key))
i += 1
player(int(args[0])).message(pm_template.substitute(colordict, sender=player(cn).name(), message=args[1]))
def onSetTeam(tcn, cn, team):
p = player(cn)
r = player(tcn)
if cn != tcn and not isAtLeastMaster(tcn):
insufficientPermissions(tcn)
return
mode = currentMode()
if isSafeTeam(team):
execLater(p.suicide, ())
p.setTeam(team)
else:
r.message(
error('You cannot join team \'%s\' in game mode %s' %
(team, modeName(currentMode()))))
def setPersistantDemoRecord(cn, args):
'''@description Enable/disable persistant demo recording
@usage enable/disable'''
if args == 'enable':
player(cn).message(info('Enabling persistant demo recording'))
persistent_recording = True
sbserver.setRecordNextMatch(persistent_recording)
elif args == 'disable':
player(cn).message(info('Disabling persistant demo recording'))
persistent_recording = False
sbserver.setRecordNextMatch(persistent_recording)
else:
raise UsageError()
def onSetTeam(tcn, cn, team):
p = player(cn)
r = player(tcn)
if cn != tcn and not isAtLeastMaster(tcn):
insufficientPermissions(tcn)
return
mode = currentMode()
if isSafeTeam(team):
execLater(p.suicide, ())
p.setTeam(team)
else:
r.message(error('You cannot join team \'%s\' in game mode %s' % (
team,
modeName(currentMode())
)))
def onKickCommand(cn, args):
'''@description Kick player from the server without ban time
@usage <cn>'''
tcn = int(args)
t = player(tcn)
serverMessage(info(kick_message.substitute(colordict, name=p.name())))
t.kick()
def isNotGBanned(cn, pwd):
p = player(cn)
try:
gbans[p.ipString()]
return False
except KeyError:
return True
def isNotGBanned(cn, pwd): p = player(cn) try: gbans[p.ipString()] return False except KeyError: return True
def check_ownage(self): if (self.current_kill_time - self.last_kill_time) < interval: self.ownage_count += 1 #check whether this level of multikill warrants a message if self.ownage_count in neomessages.keys(): try: player(self.playercn).message(info(neomessages[self.ownage_count].substitute())) except ValueError: pass self.last_ownage_count = self.ownage_count else: #that multikill session ended so the multikill counter should be incremented if self.last_ownage_count != 0: self.multikill_counts[self.last_ownage_count] += 1 self.ownage_count = 1
def warnNickReserved(cn, count, sessid):
try:
p = player(cn)
except ValueError:
return
try:
nickacct = p.warn_nickacct
if nickacct.nick != sbserver.playerName(cn) or sessid != sbserver.playerSessionId(cn):
p.warning_for_login = False
return
except (AttributeError, ValueError):
p.warning_for_login = False
return
if isLoggedIn(cn):
user = loggedInAs(cn)
if nickacct.user_id != user.id:
ban(cn, 0, 'Use of reserved name', -1)
p.warning_for_login = False
return
if count > 4:
ban(cn, 0, 'Use of reserved name', -1)
p.warning_for_login = False
return
remaining = 25-(count*5)
sbserver.playerMessage(cn, warning('Your name is reserved. You have ' + red('%i') + ' seconds to login or be kicked.') % remaining)
addTimer(5000, warnNickReserved, (cn, count+1, sessid))
def onKickCommand(cn, args): '''@description Kick player from the server without ban time @usage <cn>''' tcn = int(args) t = player(tcn) serverMessage(info(kick_message.substitute(colordict, name=p.name()))) t.kick()
def check_domination(self): if self.last_victim == self.current_victim: self.domination_count += 1 else: self.domination_count = 0 if self.domination_count in dommessages.keys(): sbserver.message(info(dommessages[self.domination_count].substitute(killername=player(self.playercn).name(), victimname=player(self.last_victim).name())))
def playerIp(cn, args): '''@description Get string representation of client ip @usage cn @master''' if args == '': raise UsageError() else: sbserver.message(info(player(int(args)).ipString()))
def playerIp(cn, args): '''@description Get string representation of client ip @usage cn @master''' if args == '': raise UsageError() else: sbserver.message(info(player(int(args)).ipString()))
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
def onSwitchTeam(cn, team):
p = player(cn)
if isSafeTeam(team):
execLater(p.suicide, ())
p.setTeam(team)
else:
p.message(
error('You cannot join team \'%s\' in game mode %s' %
(team, modeName(currentMode()))))
def onSwitchTeam(cn, team):
p = player(cn)
if isSafeTeam(team):
execLater(p.suicide, ())
p.setTeam(team)
else:
p.message(error('You cannot join team \'%s\' in game mode %s' % (
team,
modeName(currentMode())
)))
def onRecentBans(cn, args):
'''@description Recently added bans
@usage'''
p = player(cn)
if args != '':
raise UsageError()
else:
recent = dbmanager.query(Ban).order_by(Ban.time.desc())[:5]
for ban in recent:
p.message(info('Nick: %s' % ban.nick))
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
def permissions_ok(cn):
if required_permissions == 0:
return True
p = player(cn)
if required_permissions == 1:
return p.isAtLeastMaster()
if required_permissions == 2:
return p.isAdmin()
logging.error('required_permissions not an int!')
return False
def onRecentBans(cn, args):
'''@description Recently added bans
@usage'''
p = player(cn)
if args != '':
raise UsageError()
else:
recent = dbmanager.query(Ban).order_by(Ban.time.desc())[:5]
for ban in recent:
p.message(info('Nick: %s' % ban.nick))
def onVoteKick(cn, args):
'''@description Vote to kick a player from server
@usage <cn>'''
if args == '':
sbserver.playerMessage(cn, error('Usage #votekick <cn>'))
else:
try:
tcn = int(args)
if player(cn).votekick == tcn:
sbserver.playerMessage(cn, error('You have already voted to kick that player.'))
allow_vote = False
else:
allow_vote = True
except AttributeError:
allow_vote = True
if allow_vote:
sbserver.message(info(vktemp.substitute(colordict, voter=sbserver.playerName(cn), victim=sbserver.playerName(tcn))))
player(cn).votekick = int(args)
checkVotes(int(args))
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
def onMapSet(cn, mapname, mapmode):
p = player(cn)
if sbserver.mapName() == '':
setMap(mapname, mapmode)
elif mapreload[0]:
setMap(mapname, mapmode)
mapreload[0] = False
elif isAtLeastMaster(cn) and sbserver.masterMode() > 0:
sbserver.setMap(mapname, mapmode)
elif mapmode != sbserver.gameMode() and (lock_mode or not allow_modevote):
p.message(error('You cannot request a new game mode'))
def onMapSet(cn, mapname, mapmode):
p = player(cn)
if sbserver.mapName() == '':
setMap(mapname, mapmode)
elif mapreload[0]:
setMap(mapname, mapmode)
mapreload[0] = False
elif isAtLeastMaster(cn) and sbserver.masterMode() > 0:
sbserver.setMap(mapname, mapmode)
elif mapmode != sbserver.gameMode() and (lock_mode or not allow_modevote):
p.message(error('You cannot request a new game mode'))
def allowMsg(cn, text):
try:
p = player(cn)
if mute_spectators[0] == True and p.isSpectator():
p.message(notice('Spectators are currently muted. No one will recieve your message'))
return False
if p.is_muted:
p.message(notice('You are currently muted. No one will recieve your message'))
return False
except (AttributeError, ValueError):
pass
return True
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)'))
def initCheck(cn): if isLoggedIn(cn): onLogin(cn) return p = player(cn) try: if p.warning_for_login: return except AttributeError: pass else: warnTagReserved(cn, 0, p.sessionId(), p.name())
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)'))
def onCommand(cn, args):
'''@description Stats for the current match
@usage (cn)
@public'''
cp = player(cn)
if args != '':
if require_master and not isPlayerMaster(cn):
insufficientPermissions(cn)
return
try:
p = player(int(args))
except ValueError:
cp.message(error('Usage: #stats (cn)'))
return
else:
p = cp
if not p.name():
cp.message(error('You must use a valid cn'))
return
msg = template.substitute(colordict, name=p.name(), frags=p.frags(), deaths=p.deaths(), teamkills=p.teamkills(), shots=p.shots(), hits=p.hits(), accuracy=p.accuracy(), ktd=p.kpd(), score=p.score())
cp.message(msg)
def onUnmuteCommand(cn, args):
'''@description Unmute a player
@usage cn'''
try:
args = args.split(' ')
tcn = int(args[0])
if len(args) > 1:
raise KeyError
try:
p = player(tcn)
if p.is_muted:
p.is_muted = False
muter = player(cn).name()
sbserver.message(info(unmuted_temp.substitute(colordict, muted_name=p.name(), muter=muter)))
else:
raise StateError('Specified player is not crrently muted')
except AttributeError:
raise StateError('Specified player is not currently muted.')
except KeyError:
raise UsageError('No cn specified')
except ValueError:
raise ArgumentValueError('Invalid player cn')
def onVoteKick(cn, args):
'''@description Vote to kick a player from server
@usage <cn>'''
if args == '':
sbserver.playerMessage(cn, error('Usage #votekick <cn>'))
else:
try:
tcn = int(args)
if player(cn).votekick == tcn:
sbserver.playerMessage(
cn, error('You have already voted to kick that player.'))
allow_vote = False
else:
allow_vote = True
except AttributeError:
allow_vote = True
if allow_vote:
sbserver.message(
info(
vktemp.substitute(colordict,
voter=sbserver.playerName(cn),
victim=sbserver.playerName(tcn))))
player(cn).votekick = int(args)
checkVotes(int(args))
def onBanName(cn, args):
'''@description Ban name from the server
@usage <name>'''
p = player(cn)
reason = args.split(' ')
if len(reason) == 1:
nick = reason[0]
reason = 'Unspecified reason'
else:
nick = reason.pop(0)
reason = args[len(nick) + 1:]
b = BanNick(nick, reason)
session.add(b)
session.commit()
p.message(info('Inserted nick ban of %s for %s' % (nick, reason)))
def onSetMaster(cn, givenhash):
p = player(cn)
adminhash = sbserver.hashPassword(cn, sbserver.adminPassword())
try:
na = dbmanager.query(NickAccount).filter(NickAccount.nick==p.name()).one()
except NoResultFound:
if givenhash != adminhash:
p.message(error('Your name is not assigned to any accounts'))
except MultipleResultsFound:
p.message(error('Multiple names linked to this account. Contact the system administrator.'))
else:
nickhash = sbserver.hashPassword(cn, na.user.password)
if givenhash == nickhash:
login(cn, na.user)
else:
if givenhash != adminhash:
p.message(error('Invalid password'))
def trigger(self, cn, command, text):
p = player(cn)
if self.command_handlers.has_key(command):
for func in self.command_handlers[command]:
try:
func(cn, text)
except UsageError, e:
try:
usages = command_info[command].usages
except KeyError:
usages = []
p.message(error('Invalid Usage of #' + command + ' command. ' + str(e)))
for usage in usages:
p.message(info('Usage: ' + command + ' ' + usage))
except StateError, e:
p.message(error(str(e)))
except ArgumentValueError, e:
p.message(error('Invalid argument. ' + str(e)))
def allowMsg(cn, text):
try:
p = player(cn)
if mute_spectators[0] == True and p.isSpectator():
p.message(
notice(
'Spectators are currently muted. No one will recieve your message'
))
return False
if p.is_muted:
p.message(
notice(
'You are currently muted. No one will recieve your message'
))
return False
except (AttributeError, ValueError):
pass
return True
def setPaused(val, cn=-1):
'''Pause or unpause the game'''
if isFrozen():
raise StateError('Server is currently frozen')
if val == isPaused():
return
if val:
action = 'paused'
else:
action = 'unpaused'
try:
p = player(cn)
except ValueError:
name = 'Unknown'
else:
name = p.name()
sbserver.message(notice(pause_message.substitute(
colordict,
action=action,
name=name)))
sbserver.setPaused(val)
def onBanCmd(cn, text):
'''@description Ban user from server
@usage <seconds> (reason)'''
sp = text.split(' ')
p = player(cn)
try:
tcn = int(sp[0])
ip = p.ipLong()
reason = ''
length = 0
if len(sp) >= 3:
reason = sp[2]
else:
reason = default_reason
if len(sp) >= 2:
length = int(sp[1])
else:
length = int(default_ban_length)
ban(tcn, length, reason, cn)
except (ValueError, KeyError):
raise UsageError('cn (duration) (reason)')
def onInsertBan(cn, args):
'''@description Intert ban for ip address
@usage <ip> <seconds> (reason)'''
p = player(cn)
args = args.split(' ')
if len(args) < 2:
raise UsageError('ip length (reason)')
else:
ip = ipStringToLong(args[0])
length = int(args[1])
try:
reason = args[2]
except IndexError:
reason = 'Unspecified reason'
expiration = time.time() + length
newban = Ban(ip, expiration, reason, 'Unnamed', 0, 'Unnamed',
time.time())
session.add(newban)
session.commit()
p.message(
info('Inserted ban for %s for %i seconds for %s.' %
(ipLongToString(ip), length, reason)))
def clanWar(cn, args):
'''@description Start a clan war with current teams
@usage map (mode)'''
sender = player(cn)
if args == '':
raise UsageError()
else:
args = args.split(' ')
if len(args) == 1:
map = args
mode = currentMode()
elif len(args) == 2:
map = args[0]
try:
mode = modeNumber(args[1])
except ValueError:
raise ArgumentValueError('Invalid game mode')
persistentTeams(True)
setMap(map, mode)
setMasterMode(2)
setPaused(True, cn)
setFrozen(True)
clanWarTimer(10, cn)
def check_if_ending_spree(self, killercn): if self.kills_since_death >= 5: if killercn == -2: sbserver.message(info(suicideendmsg.substitute(victimname=player(self.playercn).name()))) else: sbserver.message(info(endmsg.substitute(victimname=player(self.playercn).name(), killername=player(killercn).name())))
def check_sprees(self): if self.kills_since_death in spreemessages.keys(): sbserver.message(info(spreemessages[self.kills_since_death].substitute(name=player(self.playercn).name())))
def teamkill(self, killercn, victimcn): player(victimcn).ownagedata.commit_death(killercn) player(killercn).ownagedata.commit_death()
def suicide(self, cn): player(cn).ownagedata.commit_death(-2)
def connect(self, cn): player(cn).ownagedata = ownageData(cn)
def add_chat(self, cn, text):
speakin = player(cn)
ip = speakin.ipString()
self.log[time.time()] = (cn, ip, text)
