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 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 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 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 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 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 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)