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 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 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 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 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 isNotGBanned(cn, pwd):
	p = player(cn)
	try:
		gbans[p.ipString()]
		return False
	except KeyError:
		return True

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