# encoding: utf-8

# Imports

import os, time, re, math
import es, gamethread, playerlib, usermsg

# Globals

_players = {} # user objects
_commands = {} # command objects
_saves = {} # save games
_bans = {} # player bans


def ed(pl, args=[], silent=False): # Main ED Menu
 if pl.adminmenu == 2:
  pl.adminmenu = 1
 else:
  pl.adminmenu = int(pl.admin) + 1
 if len(args) > 1:
  if re.match('0|1', args[1]): # 1 - Admin menu, 0 - Client menu
   pl.adminmenu = int(int(args[1]) and pl.admin) + 1
 pl.sendmenu(menu.admin(pl))


def load(): # Addon load
 
 es.flags('remove', 'cheat', 'endround')
 
 # register chat and command filters
 
 es.addons.registerClientCommandFilter(commandfilter)
 es.addons.registerSayFilter(chatfilter)
 
 # enable custom events
 
 es.set('eventscripts_defaultevents', '0')
 
 es.loadevents(config.dir.events_es)
 es.loadevents(config.dir.events_game)
 es.loadevents(config.dir.events_engine)
 
 # load config file
 
 if not config.reload():
  es.unload('ed')
  return False
 
 # load banlist
 
 if os.path.exists(config.dir.banlist): 
  regex = re.compile('^(STEAM_0:(0|1):\d+)\\ (.+)') # banlist format: <id> <name>
  file = open(config.dir.banlist)
  global _bans
  for line in file.readlines():
   match = regex.match(line)
   if match:
    groups = match.groups()
    _bans[groups[0]] = groups[2]
    specialcmd.banid(0, groups[0], 'kick')
  file.close()
 
 # create player objects
 
 global _players
 for id in getplayers():
  _players[id] = player(id)
  
 _players[0] = player(0) # server 'player' object
 
 # create command objects
 
 global _commands
 
 special = {
  player.say: ['@', '!', '#'],
 }
 
 for method in special:
  cmd = command(method, server=False, special=True, admin=False)
  for name in special[method]:
   _commands[name] = cmd
  
 client = {
  ed: ['ed', 'enemydown', 'admin'],
  player.rates: ['rate', 'rates'],
  player.login: ['login', 'logon'],
 }
 
 for method in client:
  cmd = command(method, server=False, admin=False)
  for name in client[method]:
   _commands[name] = cmd
   
 _commands['rate'].clientfunc = player.consolerates
 
 admin = {
  player.ko3: ['ko3'],
  player.lo3: ['lo3'],
  player.rr: ['rr', 'restart'],
  player.save: ['save'],
  player.load: ['load'],
  player.map: ['map'],
  player.config: ['cfg', 'config', 'exec', 'execute'],
  player.password: ['pass', 'setpass'],
  player.demo: ['demo', 'rec', 'record', 'recdemo'],
  player.stopdemo: ['stopdemo', 'stoprec', 'stoprecord'],
  player.kick: ['kick'],
  player.ban: ['ban'],
  player.unban: ['unban'],
  player.swap: ['swap'],
  player.swapteam: ['swapteam'],
  player.swapt: ['swapt'],
  player.swapct: ['swapct'],
  player.swapspec: ['spec', 'swapspec'],
  player.rcon: ['rcon'],
 }
 
 for method in admin:
  cmd = command(method)
  for name in admin[method]:
   _commands[name] = cmd

 # register commands
 
 for name in _commands:
  _commands[name].register(name)


def unload(): # Addon unload
 
 # unregister chat and command filters
 
 es.addons.unregisterClientCommandFilter(commandfilter)
 es.addons.unregisterSayFilter(chatfilter)
 
 # unregister commands
 
 for command in _commands:
  _commands[command].unregister(command)
 
 # enable default events
  
 es.set('eventscripts_defaultevents', '1')


class command: # Admin Command Class
 
 def __init__(self, function, server=True, client=True, say=True, special=False, admin=True):
  self.function = function
  self.server = server
  self.client = client
  self.say = say
  self.special = special
  self.admin = admin
  
  self.serverfunc = None
  self.clientfunc = None
  self.sayfunc = None
  
 def register(self, name): # Register command
  for prefix in [''] if self.special else config.commandprefixes:
   cmd = prefix + name
   if self.server:
    if not es.exists('command', cmd):
     es.regcmd(cmd, config.serverblock)
   if self.client:
    if es.exists('clientcommand', cmd):
     es.unregclientcmd(cmd)
    es.regclientcmd(cmd, config.clientblock)
   if self.say:
    if es.exists('saycommand', cmd):
     es.unregsaycmd(cmd)
    es.regsaycmd(cmd, config.sayblock)
    
 def unregister(self, name):  # Unregister Command
  for prefix in [''] if self.special else config.commandprefixes:
   cmd = prefix + name
   if self.client:
    if es.exists('clientcommand', cmd):
     es.unregclientcmd(cmd)
   if self.say:
    if es.exists('saycommand', cmd):
     es.unregsaycmd(cmd)
    
 def call(self, id, args, prefix, tp):  # Call Block
  pl = _players[id]
  silent = prefix == '/'
  if self.admin:
   if not pl.admin:
    es.tell(pl.id, config.output.denied % config.prefix)
    pl.command = (self.function, args, silent)
    es.queryclientvar(pl.id, 'rcon_password')
    return
  function = [self.serverfunc, self.clientfunc, self.sayfunc][tp]
  if not function:
   function = self.function
  function(pl, args=args, silent=silent)

def servercall(): # Server command called
 id = 0
 args = []
 a = es.getargs()
 a = a.strip() if a else ''
 args.append((es.getargv(0).lower(), a))
 for i in range(1, int(es.getargc())):
  args.append(es.getargv(i))
 name = args[0][0]
 prefix = name[0]
 if not name in _commands:
  if prefix in config.commandprefixes:
   name = name[1:]
 _commands[name].call(id, args, prefix, 0)
 
def clientcall(): # Client command called
 id = int(es.getcmduserid())
 args = []
 a = es.getargs()
 a = a.strip() if a else ''
 args.append((es.getargv(0).lower(), a))
 for i in range(1, int(es.getargc())):
  args.append(es.getargv(i))
 name = args[0][0]
 prefix = name[0]
 if not name in _commands:
  if prefix in config.commandprefixes:
   name = name[1:]
 _commands[name].call(id, args, prefix, 1)
 
def saycall(): # Chat command called
 id = int(es.getcmduserid())
 args = []
 a = es.getargs()
 a = a.strip() if a else ''
 args.append((es.getargv(0).lower(), a))
 for i in range(1, int(es.getargc())):
  args.append(es.getargv(i))
 name = args[0][0]
 prefix = name[0]
 if not name in _commands:
  if prefix in config.commandprefixes:
   name = name[1:]
 _commands[name].call(id, args, prefix, 2)
 
 
def chatfilter(id, message, teamonly): # Chat Filter
 id = int(id)
 if id > 0:
  message = message[1:-1] # first and last characters are unknown and scary
  cmd = message.split(' ')[0]
  if not cmd in _commands:
   if cmd[0] in config.commandprefixes:
    cmd = cmd[1:]
  if cmd in _commands:
   cmd = _commands[cmd]
   if cmd.say:
    return (id, message, teamonly) # it's a chat command, pass it on
  pl = _players[id]
  pl.chat('\3%s\1 : %s' % (pl.name, message), teamonly) # output it like a normal chat
  return (0, None, False)
 return (id, message, teamonly) # can't do anything with team messages

# Command Filter
 
def commandfilter(id, args):

 if id > 0:
  id = int(id)
  
  if not id in _players:
   return True
  pl = _players[id]
  
  # Menu Handling
  
  global _paused
  
  if args[0] == 'menuselect':
   if pl.menu:
    choice = int(args[1])
    if choice == 10:
     pl.adminmenu = 0
     pl.menu = None
    else:
     pl.menu = pl.menu.action(choice)
     if pl.menu:
      pl.sendmenu()
   return False
   
  # Dropped Grenade Handling
  
  elif args[0] == 'drop':
   if config.allowdropnades:
    
    pl.get(es.createplayerlist()[pl.id])
    w =  pl.get.current()
    if w in 'weapon_'.join(('', 'hegrenade', 'flashbang', 'smokegrenade')):
     
     n = 1 if w == 'weapon_hegrenade' else 2
     
     getset = {'weapon_flashbang': (pl.get.fb, pl.set.fb), 'weapon_smokegrenade': (pl.get.sg, pl.set.sg), 'weapon_hegrenade': (pl.get.he, pl.set.he)}[w]
     num = getset[0]()
     if not int(num):
      es.cexec(pl.id, 'lastinv')
      return True
      
     for i in range(num, n+1):
      servercmd.es_give(pl.id, w)
      
     # Voodoo
      
     pitch = es.getplayerprop(pl.id, 'CCSPlayer.m_angEyeAngles[0]')
     z = -1
     if pitch > 269:
      pitch = 360 - pitch
      z = 1
     pitch = math.radians(pitch)
     z *= math.sin(pitch)
     xy = math.cos(pitch)
     yaw = es.getplayerprop(pl.id, 'CCSPlayer.m_angEyeAngles[1]')
     x = -1 if 90 < yaw < 270 else 1
     y = 1 if 0 < yaw < 180 else -1
     n = yaw % 90
     if not  x == y:
      n = 90 - n
     n = math.radians(n)
     x *= math.cos(n)*xy
     y *= math.sin(n)*xy
     m = 30000
     p = pl.get.loc()
     nv = [str(i) for i in (x*m+es.getplayerprop(pl.id, 'CCSPlayer.baseclass.localdata.m_vecVelocity[0]'), y*m+es.getplayerprop(pl.id, 'CCSPlayer.baseclass.localdata.m_vecVelocity[1]'), z*m+es.getplayerprop(pl.id, 'CCSPlayer.baseclass.localdata.m_vecVelocity[2]'))]
     np = [str(i) for i in (p[0], p[1], p[2]+60)]
     gamethread.delayed(0.01, es.physics, ('active', 'teleport', sv.eventscripts_lastgive, ','.join(np)))
     gamethread.delayed(0.01, es.physics, ('active', 'setvelocity', sv.eventscripts_lastgive, ','.join(nv)))
     gamethread.delayed(0.3, getset[1], num-1)
     gamethread.delayed(0.3, es.sexec, (pl.id, 'use %s' % w))
     
     if num == 1:
      es.cexec(pl.id, 'lastinv')
 
 return True


class demo: # Demo Record Class
 
 def __init__(self):
  self.recording = False
  
 def tvactive(self):
  return bool(int(sv.tv_enable))
 
 def record(self, name):
  self.recording = True
  self.name = name
  self.time = time.time()
  dir = '%s/%s' % (config.dir.cstrike, config.demo.dir)
  if not os.path.exists(dir):
   os.mkdir(dir)
  servercmd.tv_record('%s/%s' % (config.demo.dir, name))
  
 def stoprecord(self):
  if self.recording:
   self.recording = False
   servercmd.tv_stoprecord()

_demo = demo()


class save: # Save Game Class
 
 def __init__(self, name):
  self.name = name
  self.bombtime = time.time() - config.bombplanted if config.bombplanted else config.bombplanted
  self.roundtime = float(sv.mp_roundtime) - ((time.time() - config.roundstarted)/60)
  self.map = str(sv.eventscripts_currentmap)
  self.botcount = 0
  self.players = []
  playerlist = es.createplayerlist()
  for id in getplayers():
   obj = self.player(_players[id], playerlist[id])
   self.players.append(obj)
   if obj.steamid == 'bot':
    self.botcount += 1
    
 class player:
  
  def __init__(self, pl, playerlist=None):
   self.pl = pl
   if not playerlist:
    playerlist = es.createplayerlist()[self.pl.id]
   get = self.pl.get(playerlist)
   self.steamid = pl.steamid
   self.loc = get.loc()
   self.prim = get.prim()
   self.sec = get.sec()
   self.current = get.current()
   self.kills = get.kills()
   self.deaths = get.deaths()
   self.cash = get.cash()
   self.health = get.health()
   self.armour = get.armour()
   self.team = get.team()
   self.fb = get.fb()
   self.he = get.he()
   self.sg = get.sg()
   self.view = get.view()
   self.vel = get.velocity()
   
 def load(self, rr=False):
  if not rr:
   config.restarted = self
   for player in self.players:
    pl = player.pl
    set = pl.set
    set.team(player.team)
   #es.forcevalue('sv_cheats', 1)
   self.mp_roundtime, self.mp_freezetime = int(sv.mp_roundtime), int(sv.mp_freezetime)
   es.forcevalue('mp_roundtime', self.roundtime)
   es.forcevalue('mp_freezetime', 0)
   servercmd.endround()
   #es.forcevalue('sv_cheats', 0)
   return
  config.restarted = False
  #es.forcevalue('sv_cheats', 1)
  es.forcevalue('mp_roundtime', self.mp_roundtime)
  es.forcevalue('mp_freezetime', self.mp_freezetime)
  playerlist = es.createplayerlist()
  for player in self.players:
   pl = player.pl
   set = pl.set
   get = pl.get
   #gamethread.delayed(0.1, servercmd, ('es_give', pl.id, 'weapon_knife'))
   set.loc(player.loc)
   set.view(player.view)
   set.velocity(player.vel)
   #servercmd.es_fire(pl.id, 'player_weaponstrip', 'strip', '1')
   servercmd.es_xremove(get.weaponindex('weapon_%s' % {2: 'glock', 3: 'usp'}[player.team]))
   weps = []
   for i in (player.prim, player.sec):
    if i:
     weps.append(i)
   gamethread.delayed(0.1, set.weapon, tuple(weps))
   gamethread.delayed(0.1, es.sexec, (pl.id, 'use %s' % player.current))
  #gamethread.delayed(0.1, es.forcevalue, ('sv_cheats', 0))


class player: # Player Class
 
 def __init__(self, id):
  self.id = int(id)
  if self.id:
   self.name = es.getplayername(self.id)
   self.steamid = es.getplayersteamid(self.id)
   if self.steamid.lower() == 'bot':
    self.steamid = 'bot'
    self.bot = True
   else:
    self.bot = False
   self.get = self.get(self.id)
   self.set = self.set(self.id)
   self.index = es.createplayerlist()[self.id]['index']
  else:
   self.name = 'Server'
   self.steamid = 0
   self.admin = True
   self.index = 0
  self.menu = None
  self.adminmenu = True
  self.loginattempts = 3
  self.command = None
  self.output = en
  
 def __getattr__(self, name):
  if name == 'admin':
   if self.bot:
    return False
   else:
    return self.steamid in config.admins
   
 def sendmenu(self, menu=None):
  if menu:
   self.menu = menu
  m = self.menu.build()
  es.menu(0, self.id, m[0], m[1])
  return self.menu
 
 def feedback(self, silent, level):
  if silent:
   if level == 2:
    level = 1
  if not self.id and level == 1:
   level = 0
  return level
 
 def say(self, args=[], silent=False):
  if self.admin:
   usermsg.saytext2(self.id, self.index, '\1Admin \3%s\1 : %s' % (self.name, args[0][1]))
   
 def chat(self, text, teamonly):
  players = es.createplayerlist()
  dead = False
  prefix = '\1'
  if players[self.id]['isdead']:
   dead = True
   prefix += '*DEAD*'
  team = players[self.id]['teamid']
  if teamonly:
   prefix += '(%s)' % {1: 'Spectator', 2: 'Terrorist', 3: 'Counter-Terrorist'}[team]
  prefix += ' '
  es.usermsg('create', 'msg', 'SayText2')
  es.usermsg('write', 'byte', 'msg', self.index)
  es.usermsg('write', 'byte', 'msg', True)
  es.usermsg('write', 'string', 'msg', prefix+text)
  for id in getplayers(bots=False):
   if teamonly:
    if not players[self.id]['teamid'] == team:
     continue
   if dead:
    if not players[self.id]['isdead']:
     continue
   es.usermsg('send', 'msg', id)
  es.usermsg('delete', 'msg')
  
 def rcon(self, args=[], silent=False):
  if args:
   pass
  
 def login(self, args=[], silent=False):
  if args[0][1] and not self.admin:
   vars = {'pre': config.prefix}
   if args[0][1] == config.login:
    self.admin = True
    es.tell(self.id, self.output.login['success']%vars)
   else:
    self.loginattempts -= 1
    vars['plu'] = 's' if self.loginattempts > 1 else ''
    vars['num'] = self.loginattempts
    es.tell(self.id, self.output.login['attempt']%vars)
   if not self.loginattempts:
    _players[0].ban(name=[self.id], reason=self.output.login['failed']%vars)
 
 def ko3(self, no=3, args=[], silent=False):
  if config.match.ko3:
   es.mexec(config.match.ko3)
  else:
   rr(True)
   if len(args) > 1:
    no = int(args[1])
   config.restart[0] = no-1 if no > 0 else 0
   es.msg('-| Knives on %s Restart%s |-' % (('1', '') if no == 1 else (no, 's')))
   config.restart[2] = '-| Knives! |-'
   config.restart[3] = True
   
 def lo3(self, no=3, args=[], silent=False):
  if config.match.lo3:
   es.mexec(config.match.lo3)
  else:
   rr(True)
   if len(args) > 1:
    no = int(args[1])
   config.restart[0] = no-1 if no > 0 else 0
   es.msg('-| Live on %s Restart%s |-' % (('1', '') if no == 1 else (no, 's')))
   config.restart[2] = '-| Live! |-'
   config.restart[3] = False
   
 def rr(self, no=1, args=[], silent=False):
  rr(True)
  if len(args) > 1:
   no = int(args[1])
  config.restart[0] = no-1 if no > 0 else 0
  config.restart[2] = ''
   
 def save(self, name='', args=[], silent=False):
  if name:
   global _saves
   _saves[name] = save(name)
   feedback = self.output.feedback['save']
   level = self.feedback(silent, config.feedback.save)
   vars = {'pre': config.prefix, 'var': name, 'adm': self.name, 'plu': ''}
   if level == 1:
    es.tell(self.id, feedback[level] % vars)
   elif level == 2:
    es.msg(feedback[level] % vars)
  elif args:
   items = args[0][1]
   cmdmenu = config.cmdmenu if items else True
   if cmdmenu and self.id:
    items = [items] if items else config.saves
    self.sendmenu(menu.admin.match.save(self, items))
   elif items:
    name = newname(subvars(items), _saves)
    self.save(name=name, silent=silent)
  
 def load(self, name='', args=[], silent=False):
  if name:
   save = _saves[name]
   save.load()
   feedback = self.output.feedback['load']
   level = self.feedback(silent, config.feedback.load)
   vars = {'pre': config.prefix, 'var': name, 'adm': self.name, 'plu': ''}
   if level == 1:
    es.tell(self.id, feedback[level] % vars)
   elif level == 2:
    es.msg(feedback[level] % vars)
  elif args:
   items = args[0][1]
   cmdmenu = config.cmdmenu if items else True
   if cmdmenu and self.id:
    if items:
     items = filterlist(_saves, [items])
    if not items:
     items = _saves
    self.sendmenu(menu.admin.match.load(self, items))
   elif items:
    if items in _saves:
     self.load(items, silent=silent)
   
 def map(self, name='', args=[], silent=False):
  if name:
   servercmd.changelevel(name)
  elif args:
   if len(args) == 1 and not config.cmdmenu:
    items = config.maps
    self.sendmenu(menu.admin.map(self, items, silent))
   else:
    extra = []
    if os.path.exists(config.dir.maplist):
     extra += [i.strip().replace('\n', '') for i in open(config.dir.maplist).read().split('\n')]
    if os.path.exists(config.dir.maps):
     for i in os.listdir(config.dir.maps):
      i = i.strip()
      if len(i) > 4:
       if i[-4:] == '.bsp':
        extra.append(i[:-4])
    while '' in extra:
     extra.remove('')
    items = config.maps + config.standardmaps + extra
    if not '#all' in args and not '*' in args:
     items = filterlist(extra, args[1:])
    if self.id and config.cmdmenu:
     name = choice(args, items)
     if type(name) == int:
      if len(items) == 0:
       items = config.maps
      self.sendmenu(menu.admin.map(self, items, silent))
     else:
      servercmd.changelevel(name)
    else:
     for arg in args:
      if arg in items:
       servercmd.changelevel(arg)
       break
 
 def config(self, name='', args=[], silent=False):
  def execute(name, silent):
   servercmd.execute(name)
   feedback = self.output.feedback['exec']
   level = self.feedback(silent, config.feedback.execute)
   vars = {'pre': config.prefix, 'var': name, 'adm': self.name, 'plu': ''}
   if level == 1:
    es.tell(self.id, feedback[1] % vars)
   elif level == 2:
    es.msg(feedback[2] % vars)
  if name:
   execute(name, silent)
  elif args:
   if len(args) == 1 and not config.cmdmenu:
    items = config.configs
    self.sendmenu(menu.admin.config(self, items, silent))
   else:
    extra = []
    if os.path.exists(config.dir.cfg):
     for cfg in os.listdir(config.dir.cfg):
      cfg = cfg.strip()
      if cfg[-4:] == '.cfg':
       extra.append(cfg[:-4])
    items = config.configs + extra
    if not '#all' in args and not '*' in args:
     items = filterlist(items, args[1:])
    if self.id and config.cmdmenu:
     name = choice(args, items)
     if type(name) == int:
      if len(items) == 0:
       items = config.configs
      self.sendmenu(menu.admin.config(self, items, silent))
     else:
      execute(name, silent)
    else:
     for arg in args:
      if arg in items:
       execute(arg)
       break
 
 def password(self, name='', args=[], silent=False):
  def setpass(name, silent):
   es.set('sv_password', name)
   if not name:
    name = '(none)'
   feedback = self.output.feedback['password']
   level = self.feedback(silent, config.feedback.password)
   vars = {'pre': config.prefix, 'var': name, 'adm': self.name, 'plu': ''}
   if level == 1:
    es.tell(self.id, feedback[1] % vars)
   elif level == 2:
    es.msg(feedback[2] % vars)
  if name:
   if name.lower() == 'none':
    name = ''
   setpass(name, silent)
  elif args:
   items = args[1:]
   cmdmenu = config.cmdmenu if items else True
   if config.cmdmenu and self.id:
    items = items if items else config.passwords
    self.sendmenu(menu.admin.password(self, items, silent))
   elif items:
    setpass(items[0], silent)

 # player actions
 
 def kick(self, name='', args=[], silent=False, reopen=0, reason=''):
  if name:
   es.msg(name)
   names = []
   for id in name:
    if id in _players:
     pl = _players[id]
     names.append(pl.name)
     if not reason:
      reason = config.kickmsg
     servercmd.kickid(pl.id, reason)
     if pl.bot:
      es.set('bot_quota', int(sv.bot_quota)-1)
   plural = 's' if len(names) > 1 else ''
   names = ', '.join(names)
   feedback = self.output.feedback['kick']
   level = self.feedback(silent, config.feedback.kick)
   vars = {'pre': config.prefix, 'var': names, 'adm': self.name, 'plu': plural}
   if level == 1:
    es.tell(self.id, feedback[1] % vars)
   elif level == 2:
    es.msg(feedback[2] % vars)
   if reopen:
    return menu.admin.players.kick(self, args, reopen, silent)
  elif args:
   items = args[1:]
   cmdmenu = config.cmdmenu if items else True
   items = itemobj.players(items)
   if config.cmdmenu and self.id:
    self.sendmenu(menu.admin.players.kick(self, items, config.reopen.kick, silent))
   elif items:
    self.kick(items.get(), silent=silent)
    
    
 def ban(self, name='', args=[], silent=False, reopen=0, reason=''):
  if name:
   names = []
   for id in name:
    if id in _players:
     pl = _players[id]
     names.append(pl.name)
     if not pl.bot:
      if not os.path.exists(config.dir.banlist):
       file = open(config.dir.banlist, 'w')
       file.close()
      file = open(config.dir.banlist)
      lines = file.readlines()
      file.close()
      global _bans
      if not pl.steamid in _bans:
       file = open(config.dir.banlist, 'a')
       file.write(pl.steamid + ' ' + pl.name + '\n')
       file.close()
       _bans[pl.steamid] = pl.name
      specialcmd.banid(0, pl.steamid)
     if not reason:
      reason = config.kickmsg
     servercmd.kickid(pl.id, reason)
     if pl.bot:
      es.set('bot_quota', int(sv.bot_quota)-1)
   plural = 's' if len(names) > 1 else ''
   names = ', '.join(names)
   feedback = self.output.feedback['ban']
   level = self.feedback(silent, config.feedback.ban)
   vars = {'pre': config.prefix, 'var': names, 'adm': self.name, 'plu': plural}
   if level == 1:
    es.tell(self.id, feedback[1] % vars)
   elif level == 2:
    es.msg(feedback[2] % vars)
   if reopen:
    return menu.admin.players.ban(self, args, reopen, silent)
   return None
  elif args: 
   items = args[1:]
   cmdmenu = config.cmdmenu if items else True
   if config.cmdmenu and self.id:
    items = itemobj.players(args[1:])
    self.sendmenu(menu.admin.players.ban(self, items, config.reopen.ban, silent))
   elif items:
    items = getplayers(items)
    self.ban(items.get(), silent=silent)

 def unban(self, name='', args=[], silent=False, reopen=0):
  if name:
   global _bans
   if name == 'all':
    _bans = {}
    name = 'All'
   else:
    if name in _bans:
     playername = _bans[name]
     del _bans[name]
     name = '%s (%s)' % (playername, name[6:])
   os.remove(config.dir.banlist)
   file = open(config.dir.banlist, 'w')
   if _bans:
    file.write('\n'.join(['%s %s' % (i, _bans[i]) for i in _bans]))
   file.close()
   plural = 's' if name == 'All' else ''
   feedback = self.output.feedback['unban']
   level = self.feedback(silent, config.feedback.unban)
   vars = {'pre': config.prefix, 'var': name, 'adm': self.name, 'plu': plural}
   if level == 1:
    es.tell(self.id, feedback[1] % vars)
   elif level == 2:
    es.msg(feedback[2] % vars)
   if reopen:
    if _bans:
     items = _bans.keys()
     return menu.admin.players.unban(self, items, reopen, silent)
  elif args:
   if args[0][1].match('^STEAM_0:(0|1):\d+'):
    self.unban(args[0][1], silent=silent)
   else:
    if config.cmdmenu and self.id:
     items = _bans.keys()
     self.sendmenu(menu.admin.players.unban(self, items, config.reopen.unban, silent))


 def rates(self, name='', args=[], silent=False, reopen=0):
  if name:
   return menu.admin.players.rates.player(self, args, reopen, name[0], silent=self.admin)
  elif args:
   items = itemobj.players(args[1:], False)
   self.sendmenu(menu.admin.players.rates(self, items, silent=self.admin))
   
 def consolerates(self, name='', args=[], silent=False, reopen=0):
  if args:
   items = itemobj.players(args[1:], False).get()
   es.msg('yow')
 
 def swap(self, name='', args=[], silent=False, reopen=0, choice=0):
  if name:
   names = []
   for id in name:
    pl = _players[id]
    team = int(es.getplayerteam(pl.id))
    new = [{1: 1, 2: 3, 3: 2}[team], 2, 3, 1][choice-1]
    if not team == new:
     es.changeteam(pl.id, new)
     names.append(pl.name)
   plural = 's' if len(names) > 1 else ''
   names = ', '.join(names)
   feedback = self.output.feedback[['swapteam', 'swapt', 'swapct', 'swapspec'][choice-1]]
   level = self.feedback(silent, config.feedback.kick)
   vars = {'pre': config.prefix, 'var': names, 'adm': self.name, 'plu': plural}
   if level == 1:
    es.tell(self.id, feedback[1] % vars)
   elif level == 2:
    es.msg(feedback[2] % vars)
   if reopen:
    if args:
     act = [menu.admin.players.swap.swapteam, menu.admin.players.swap.swapt, menu.admin.players.swap.swapct, menu.admin.players.swap.swapspec][choice-1]
     return act(self, args, reopen, silent)
  elif args:
   items = itemobj.players(args[1:])
   act = [self.swapteam, self.swapteam, self.swapt, self.swapct, self.swapspec][choice]
   if config.cmdmenu and self.id:
    if choice:
     self.sendmenu(menu.admin.players.swap(self, items).action(choice))
    else:
     self.sendmenu(menu.admin.players.swap(self, items, silent))
   else:
    act(items.get(), silent=silent)

 def swapteam(self, name='', args=[], silent=False, reopen=0):
  if name:
   return self.swap(name, args, silent, reopen, 1)
  elif args:
   self.swap('', args, silent, config.reopen.swap, 1)

 def swapt(self, name='', args=[], silent=False, reopen=0):
  if name:
   return self.swap(name, args, silent, reopen, 2)
  elif args:
   self.swap('', args, silent, config.reopen.swap, 2)

 def swapct(self, name='', args=[], silent=False, reopen=0):
  if name:
   return self.swap(name, args, silent, reopen, 3)
  elif args:
   self.swap('', args, silent, config.reopen.swap, 3)
 
 def swapspec(self, name='', args=[], silent=False, reopen=0):
  if name:
   return self.swap(name, args, silent, reopen, 4)
  elif args:
   self.swap('', args, silent, config.reopen.swap, 4)

  
 def demo(self, name='', args=[], silent=False):
  if name:
   _demo.record(name)
   feedback = self.output.feedback['demo']
   level = self.feedback(silent, config.feedback.kick)
   vars = {'pre': config.prefix, 'var': name, 'adm': self.name, 'plu': ''}
   if level == 1:
    es.tell(self.id, feedback[1] % vars)
   elif level == 2:
    es.msg(feedback[2] % vars)
  elif args:
   items = args[0][1]
   items = [items] if items else config.demos
   self.sendmenu(menu.admin.demo(self, items, silent))

 def stopdemo(self, name='', args=[], silent=False):
  if args:
   self.sendmenu(menu.admin.demo(self))
  else:
   _demo.stoprecord()
   feedback = self.output.feedback['stopdemo']
   level = self.feedback(silent, config.feedback.kick)
   vars = {'pre': config.prefix, 'var': name, 'adm': self.name, 'plu': ''}
   if level == 1:
    es.tell(self.id, feedback[1] % vars)
   elif level == 2:
    es.msg(feedback[2] % vars)
    
 class get:
  def __init__(self, id):
   self.id = id
  def __call__(self, attr):
   self.attr = attr
   return self
  def loc(self):
   return (self.attr['x'], self.attr['y'], self.attr['z'])
  def helmet(self):
   return es.getplayerprop(self.id, 'CCSPlayer.m_bHasHelmet')
  def weaponindex(self, weapon):
   if not weapon[:7] == 'weapon_':
    weapon = 'weapon_' + weapon
   handle = es.getplayerhandle(self.id)
   weaponlist = es.createentitylist(weapon)
   pname = 'm_hOwner'
   for item in weaponlist.keys():
    for prop in weaponlist[item].keys():
     if len(prop) > len(pname) and prop[-len(pname):] == pname:
      if weaponlist[item][prop] == handle:
       return int(item)
  def prim(self):
   for weapon in config.primary:
    index = self.weaponindex(weapon)
    if index > 0:
     return (weapon, es.getplayerprop(self.id, 'CBasePlayer.localdata.m_iAmmo.' + config.ammo[weapon]), es.getindexprop(index, 'CBaseCombatWeapon.LocalWeaponData.m_iClip1'))
   return None
  def sec(self):
   for weapon in config.secondary:
    index = self.weaponindex(weapon)
    if index > 0:
     return (weapon, es.getplayerprop(self.id, 'CBasePlayer.localdata.m_iAmmo.' + config.ammo[weapon]), es.getindexprop(index, 'CBaseCombatWeapon.LocalWeaponData.m_iClip1'))
   return None
  def current(self):
   return self.attr['weapon']
  def kills(self):
   return self.attr['kills']
  def deaths(self):
   return self.attr['deaths']
  def dead(self):
   return self.attr['isdead']
  def team(self):
   return self.attr['teamid']
  def health(self):
   return self.attr['health']
  def armour(self):
   return self.attr['armor']
  def cash(self):
   return es.getplayerprop(self.id, 'CCSPlayer.m_iAccount')
  def he(self):
   return es.getplayerprop(self.id, 'CBasePlayer.localdata.m_iAmmo.011')
  def fb(self):
   return es.getplayerprop(self.id, 'CBasePlayer.localdata.m_iAmmo.012')
  def sg(self):
   return es.getplayerprop(self.id, 'CBasePlayer.localdata.m_iAmmo.013')
  def c4(self):
   return self.weaponindex('weapon_c4') > 0
  def nvgs(self):
   return es.getplayerprop(self.id, 'CCSPlayer.m_bHasNightVision') % 2
  def defuser(self):
   return es.getplayerprop(self.id, 'CCSPlayer.m_bHasDefuser')
  def view(self):
   return (es.getplayerprop(self.id, 'CCSPlayer.m_angEyeAngles[0]'), es.getplayerprop(self.id, 'CCSPlayer.m_angEyeAngles[1]'))
  def velocity(self):
   return (es.getplayerprop(self.id, 'CCSPlayer.baseclass.localdata.m_vecVelocity[0]'), es.getplayerprop(self.id, 'CCSPlayer.baseclass.localdata.m_vecVelocity[1]'), es.getplayerprop(self.id, 'CCSPlayer.baseclass.localdata.m_vecVelocity[2]'))
 
 class set:
  def __init__(self, id):
   self.id = id
  def loc(self, coords):
   es.setpos(self.id, coords[0], coords[1], coords[2])
  def helmet(self, status):
   es.setplayerprop(self.id, 'CCSPlayer.m_bHasHelmet', status)
  def weapon(self, *weapon):
   for wep in weapon:
    servercmd.es_give(self.id, 'weapon_%s' % wep[0])
    index = _players[self.id].get.weaponindex(wep[0])
    es.setplayerprop(self.id, 'CBasePlayer.localdata.m_iAmmo.' + config.ammo[wep[0]], wep[1])
    es.setindexprop(index, 'CBaseCombatWeapon.LocalWeaponData.m_iClip1', wep[2])
  def current(self, weapon):
   es.sexec(self.id, 'use %s' % weapon)
  def kills(self, num):
   pass
  def deaths(self, num):
   pass
  def dead(self, isdead):
   if isdead:
    es.sexec(self.id, 'kill')
  def team(self, teamid):
   #es.setplayerprop(self.id, 'CBaseEntity.m_iTeamNum', teamid)
   es.changeteam(self.id, teamid)
  def health(self, value):
   es.setplayerprop(self.id, 'CBasePlayer.m_iHealth', value)
  def armour(self):
   es.setplayerprop(self.id, 'CCSPlayer.m_ArmorValue', value)
  def cash(self, value):
   s.setplayerprop(self.id, 'CCSPlayer.m_iAccount', value)
  def he(self, value):
   es.setplayerprop(self.id, 'CBasePlayer.localdata.m_iAmmo.011', value)
  def fb(self, value):
   es.setplayerprop(self.id, 'CBasePlayer.localdata.m_iAmmo.012', value)
  def sg(self, value):
   es.setplayerprop(self.id, 'CBasePlayer.localdata.m_iAmmo.013', value)
  def c4(self, hasc4):
   if hasc4:
    servercmd.es_give(self.id, 'weapon_c4')
  def nvgs(self, value):
   es.setplayerprop(self.id, 'CCSPlayer.m_bHasNightVision', value)
  def defuser(self, value):
   es.setplayerprop(self.id, 'CCSPlayer.m_bHasDefuser', value)
  def view(self, coord):
   es.setang(self.id, coord[0], coord[1])
  def velocity(self, vel):
   es.setplayerprop(self.id, 'CBasePlayer.localdata.m_vecBaseVelocity', ','.join([str(i) for i in vel]))
   
 
class menu:

 class group:
   def __init__(self, pl, items, title, act, prev, function=lambda x: x, reopen=0, vars=False, silent=False, itemobj=None):
    self.pl = pl
    self.subvars = vars if vars else lambda x: x
    self.items = itemlist(title, items, function)
    if reopen:
     self.reopen = self.page = reopen if len(self.items) >= reopen else len(self.items)
    else:
     self.page = 1
    self.title = title
    self.act = act
    self.prev = prev
    self.reopen = reopen
    self.silent = silent
    self.itemobj = itemobj
   def build(self):
    return (self.items[self.page]['content'], self.items[self.page]['choices'])
   def action(self, choice):
    if choice == 8:
     if self.page == 1:
      return self.prev
     else:
      self.page -= 1
      self.reopen = self.page if self.reopen else 0
      return self
    elif choice == 9:
      self.page += 1
      self.reopen = self.page if self.reopen else 0
      return self
    else:
     name = self.subvars(self.items[self.page][choice])
     if self.reopen:
      act = self.act(name=name, args=self.itemobj, silent=self.silent, reopen=self.reopen)
     else:
      act = self.act(name=name, args=self.itemobj, silent=self.silent)
     if act:
      return act
     return None
     
 class player:
   def __init__(self, pl, items, title, act, prev, reopen, filters=True, silent=False):
    self.pl = pl
    self.items = items.get()
    self.title = title
    self.act = act
    self.prev = prev
    self.reopen = reopen
    self.filters = filters
    self.silent = silent
    self.itemobj = items
   def build(self):
    if not self.items:
     self.items = self.itemobj.get()
    filters = {'t': [], 'ct': [], 'spec': [], 'bot': []}
    if self.filters:
     if len(self.items) > 1:
      disclude = self.filters if type(self.filters) == list else []
      b = True
      for item in self.items:
       team = int(es.getplayerteam(item))
       if team == 2 and not 't' in disclude:
        filters['t'].append(item)
       elif team == 3 and not 'ct' in disclude:
        filters['ct'].append(item)
       elif team == 1 and not 'spec' in disclude:
        filters['spec'].append(item)
       if es.isbot(item):
        filters['bot'].append(item)
       else:
        b = False
      if b:
       filters['bot'] = []
     f = dict(filters)
     for filter in filters:
      if not filters[filter]:
       del f[filter]
     filters = f
     if len(self.items) > 1:
      filters['all'] = self.items
     keys = []
     c = 0
     n = ''
     for f in ('all', 't', 'ct', 'spec', 'bot'):
      if f in filters:
       keys.append(f)
       if f in ('t', 'ct', 'spec'):
        c += 1
        n = f
     if c == 1:
      keys.remove(n)
     if keys:
      self.items = keys + [''] + self.items
    function = lambda x: es.getplayername(x) if type(x) == int else self.pl.output.filters[x]
    self.pl.menu = menu.group(self.pl, self.items, self.title, self.act, self.prev, function, self.reopen, lambda x: filters[x] if x in filters else [x], silent=self.silent, itemobj=self.itemobj)
    return self.pl.menu.build()

 class admin:
  def __init__(self, pl):
   self.pl = pl
  def build(self):
   if self.pl.adminmenu == 2:
    return (config.output.menu['admin']['content'], '01234567')
   else:
    return (config.output.menu['client']['content'], '01')
  def action(self, choice):
   if self.pl.adminmenu == 2:
    self.pl.adminmenu = 0
    if choice == 2:
     return menu.admin.map(self.pl, config.maps)
    elif choice == 3:
     return menu.admin.config(self.pl, config.configs)
    elif choice == 4:
     return menu.admin.password(self.pl, config.passwords)
    elif choice == 6:
     return self.demo(self.pl, config.demos)
    else:
     act = {1: self.match, 5: self.players, 7: self.settings}[choice]
     return act(self.pl)
   else:
    self.pl.adminmenu = 0
  
  class match:
   def __init__(self, pl):
    self.pl = pl
   def build(self):
    return (config.output.menu['admin']['match']['content'] + backnext(), '01234568')
   def action(self, choice):
    if choice == 1:
     self.pl.ko3(3)
    elif choice == 2:
     self.pl.lo3(3)
    elif choice == 3:
     self.pl.rr(1)
    elif choice == 4:
     es.set('sv_pausable', 1)
     es.sexec(self.pl.id, 'pause')
     return menu.admin.match(self.pl)
    elif choice == 5:
     return menu.admin.match.save(self.pl, config.saves)
    elif choice == 6:
     return menu.admin.match.load(self.pl, _saves)
    elif choice == 8:
     return menu.admin(self.pl)
    return None
   
   class save:
    def __init__(self, pl, items, silent=False):
     self.pl = pl
     self.items = items
     self.prev = menu.admin.match(self.pl)
     self.silent = silent
    def build(self):
     title = config.output.menu['admin']['match']['save']['content']
     act = self.pl.save
     function = lambda x: newname(subvars(x), _saves)
     vars = lambda x: newname(subvars(x), _saves)
     self.pl.menu = menu.group(self.pl, self.items, title, act, self.prev, function, vars=vars, silent=self.silent)
     return self.pl.menu.build()
    
   class load(save):
    def build(self):
     title = config.output.menu['admin']['match']['load']['content']
     act = self.pl.load
     self.pl.menu = menu.group(self.pl, self.items, title, act, self.prev, silent=self.silent)
     return self.pl.menu.build()
    
  class map:
   def __init__(self, pl, items, silent=False):
    self.pl = pl
    self.items = items
    self.prev = menu.admin(self.pl)
    self.silent = silent
   def build(self):
    title = config.output.menu['admin']['map']['content']
    act = self.pl.map
    self.pl.menu = menu.group(self.pl, self.items, title, act, self.prev, silent=self.silent)
    return self.pl.menu.build()
    
  class config(map):
   def build(self):
    title = config.output.menu['admin']['config']['content']
    act = self.pl.config
    function = lambda x: x[:-4] if x[-4:] == '.cfg' else x
    self.pl.menu = menu.group(self.pl, self.items, title, act, self.prev, function, silent=self.silent)
    return self.pl.menu.build()
    
  class password(map):
   def build(self):
    while 'none' in self.items:
     self.items.remove('none')
    while 'None' in self.items:
     self.items.remove('none')
    self.items = ['None'] + ([''] if self.items else []) + self.items
    title = config.output.menu['admin']['password']['content']
    act = self.pl.password
    self.pl.menu = menu.group(self.pl, self.items, title, act, self.prev, silent=self.silent)
    return self.pl.menu.build()
    
  class players:
   def __init__(self, pl):
    self.pl = pl
    self.items = []
   def build(self):
    return (config.output.menu['admin']['players']['content'] + backnext(), '0123458')
   def action(self, choice):
    if choice == 8:
     return menu.admin(self.pl)
    elif choice == 1:
     return menu.admin.players.kick(self.pl, itemobj.players(), config.reopen.kick)
    elif choice == 2:
     return menu.admin.players.ban(self.pl, itemobj.players(), config.reopen.ban)
    elif choice == 3:
     return menu.admin.players.unban(self.pl, itemobj.bans(), config.reopen.unban)
    elif choice == 4:
     return menu.admin.players.rates(self.pl, itemobj.players(bots=False), silent=True)
    elif choice == 5:
     return self.swap(self.pl, itemobj.players())
     
   class kick:
    def __init__(self, pl, items, reopen=0, silent=False):
     self.pl = pl
     self.items = items
     self.reopen = reopen
     self.silent = silent
     self.prev = prev = menu.admin.players(self.pl)
    def build(self):
     title = config.output.menu['admin']['players']['kick']['content']
     act = self.pl.kick
     filters = True
     self.menu = menu.player(self.pl, self.items, title, act, self.prev, self.reopen, filters, self.silent)
     return self.menu.build()
    
   class ban(kick):
    def build(self):
     title = config.output.menu['admin']['players']['ban']['content']
     act = self.pl.ban
     filters = True
     self.menu = menu.player(self.pl, self.items, title, act, self.prev, self.reopen, filters, self.silent)
     return self.menu.build()
    
   class unban(kick):
    def build(self):
     if len(self.items) > 1:
      items = ['all', ''] + items
     title = config.output.menu['admin']['players']['unban']['content']
     act = self.pl.unban
     function = lambda x: 'All' if x == 'all' else '%s - %s' % (_bans[x], x[6:])
     self.pl.menu = menu.group(self.pl, self.items, title, act, self.prev, function, self.reopen, silent=self.silent)
     return self.pl.menu.build()
     
   class rates(kick):
    def build(self):
     title = config.output.menu['admin']['players']['rates']['content']
     act = self.pl.rates
     reopen = 0
     filters = False
     if not self.silent:
      self.prev = menu.admin(self.pl)
     return menu.player(self.pl, self.items, title, act, self.prev, reopen, filters).build()
   
    class player:
     def __init__(self, pl, items, page, id, silent):
      self.pl = pl
      self.items = items
      self.id = id
      self.page = page
      self.silent = silent
     def build(self):
      return ('This is a rate menu' + backnext(), '08')
     def action(self, choice):
      if choice == 8:
       return menu.admin.players.rates(self.pl, self.items, self.page, self.silent)
      return None
    
   class swap:
    def __init__(self, pl, items, silent=False):
     self.pl = pl
     self.items = items
     self.silent = silent
    def build(self):
     return (config.output.menu['admin']['players']['swap']['content'] + backnext(), '012348')
    def action(self, choice, page=1):
     if choice == 8:
      return menu.admin.players(self.pl)
     elif choice == 1:
      return menu.admin.players.swap.swapteam(self.pl, self.items, config.reopen.swap, self.silent)
     elif choice == 2:
      return menu.admin.players.swap.swapt(self.pl, self.items, config.reopen.swap, self.silent)
     elif choice == 3:
      return menu.admin.players.swap.swapct(self.pl, self.items, config.reopen.swap, self.silent)
     elif choice == 4:
      return menu.admin.players.swap.swapspec(self.pl, self.items, config.reopen.swap, self.silent)

    class swapteam:
     def __init__(self, pl, items, reopen, silent=False):
      self.pl = pl
      self.items = items
      self.reopen = reopen
      self.silent = silent
      self.filters = True
      self.prev = prev = menu.admin.players.swap(self.pl, self.items, self.silent)
     def __call__(self, name='', args=[], silent=False, reopen=0):
      pass
     def build(self):
      title = config.output.menu['admin']['players']['swap']['team']['content']
      act = self.pl.swapteam
      self.pl.menu = menu.player(self.pl, self.items, title, act, self.prev, self.reopen, self.filters, silent=self.silent)
      return self.pl.menu.build()
     
    class swapt(swapteam):
     def build(self):
      title = config.output.menu['admin']['players']['swap']['t']['content']
      act = self.pl.swapt
      self.pl.menu = menu.player(self.pl, self.items, title, act, self.prev, self.reopen, self.filters, silent=self.silent)
      return self.pl.menu.build()
     
    class swapct(swapteam):
     def build(self):
      title = config.output.menu['admin']['players']['swap']['ct']['content']
      act = self.pl.swapct
      self.pl.menu = menu.player(self.pl, self.items, title, act, self.prev, self.reopen, self.filters, silent=self.silent)
      return self.pl.menu.build()
     
    class swapspec(swapteam):
     def build(self):
      title = config.output.menu['admin']['players']['swap']['spec']['content']
      act = self.pl.swapspec
      self.pl.menu = menu.player(self.pl, self.items, title, act, self.prev, self.reopen, self.filters, silent=self.silent)
      return self.pl.menu.build()
     
    
  class demo(map):
   def build(self):
    if not _demo.tvactive():
     self.status = 0
     return (('%s \n \n->1 ' + config.output.menu['admin']['demo']['enable']['content']) % config.output.menu['admin']['demo']['content'], '01')
    elif _demo.recording:
     self.status = 1
     return (('%s \n \n%s \n \n' + config.output.menu['admin']['demo']['recording']['content']) % (config.output.menu['admin']['demo']['content'], _demo.name, subvars('%hour%:%min%', _demo.time), int(time.time() - _demo.time)), '01')
    else:
     dir = '%s/%s' % (config.dir.cstrike, config.demo.dir)
     if os.path.exists(dir):
      demodir = [(i[:-4] if i[-4:] == '.dem' else None) for i in os.listdir(dir)]
     else:
      demodir = []
     es.msg(demodir)
     title = config.output.menu['admin']['demo']['content']
     act = self.pl.demo
     prev = menu.admin(self.pl)
     function = lambda x: newname(subvars(x[:-4] if x[-4:] == '.dem' else x), demodir)
     vars = function
     self.pl.menu = menu.group(self.pl, self.items, title, act, prev, function, vars=vars, silent=self.silent)
     return self.pl.menu.build()
   def action(self, choice):
    if choice == 1:
     if self.status == 0:
      servercmd.tv_enable(1)
      servercmd.changelevel(sv.eventscripts_currentmap)
     elif self.status == 1:
      self.pl.stopdemo(_demo.name)
    return None
  
  class settings:
   def __init__(self, pl):
    self.pl = pl
   def build(self):
    return (config.output.menu['admin']['settings']['content'], '')
   def action(self, choice):
    pass
 
class en:
 def __init__(self, lang):
  self.lang = lang
  
 menu = {
  'client': {
   'content': '::ED Client\n->1 Demo'},
  'admin': {
   'content': '::ED Admin\n->1 Match\n->2 Map\n->3 Config\n->4 Password\n->5 Players\n->6 Demo\n->7 Settings',
   'match': {
    'content': ':: Match\n \n->1 Knives on 3\n->2 Live on 3\n->3 Restart Round\n \n->4 Toggle Pause \n->5 Save Game\n->6 Load Game',
    'save': {
     'content': '::Save'
    },
    'load': {
     'content': '::Load'
    }
   },
   'map': {
    'content': '::Map'
   },
   'config': {
    'content': '::Config'
   },
   'password': {
    'content': '::Password'
   },
   'players': {
    'content': '::Players\n \n->1 Kick\n->2 Ban\n->3 Unban\n->4 Rates\n->5 Swap Team',
    'kick': {
     'content': '::Kick'
    },
    'ban': {
     'content': '::Ban'
    },
    'unban': {
     'content': '::Unban'
    },
    'rates': {
     'content': '::Rates'
    },
    'swap': {
     'content': '::Swap To\n \n->1 Other Side\n->2 Terrorists\n->3 CTs\n->4 Spectators',
     'team': {
      'content': '::Swap Side'
     },
     't': {
      'content': '::Swap to T'
     },
     'ct': {
      'content': '::Swap to CT'
     },
     'spec': {
      'content': '::Swap to Spec'
     }
    }
   },
   'demo': {
    'content': '::Demo',
    'enable': {
     'content': 'Enable SourceTV \n \n(reloads map)'
    },
    'recording': {
     'content': 'Started %s - for %s minutes \n \n->1 Stop Recording'
    }
   },
   'config': {
    'content': '::Config'
   }
  }
 }
 
 filters = {
  'spec': 'Spectators',
  'ct': 'CTs',
  't': 'Terrorists',
  'bot': 'Bots',
  'all': 'All'
 }

 feedback = {
  'save': {
   1: '%(pre)s Game saved: %(var)s',
   2: '%(pre)s %(adm)s saved game: %(var)s'
  },
  'load': {
   1: '%(pre)s Game loaded: %(var)s',
   2: '%(pre)s %(adm)s loaded game: %(var)s'
  },
  'exec': {
   1: '%(pre)s Config executed: %(var)s',
   2: '%(pre)s %(adm)s exec\'d config: %(var)s'
  },
  'password': {
   1: '%(pre)s Password changed: %(var)s',
   2: '%(pre)s %(adm)s changed password: %(var)s'
  },
  'demo': {
   1: '%(pre)s Demo recording: %(var)s',
   2: '%(pre)s %(adm)s set demo recording: %(var)s'
  },
  'stopdemo': {
   1: '%(pre)s Demo stopped: %(var)s',
   2: '%(pre)s %(adm)s stopped demo recording: %(var)s'
  },
  'kick': {
   1: '%(pre)s Player%(plu)s kicked: %(var)s',
   2: '%(pre)s %(adm)s kicked player%(plu)s: %(var)s'
  },
  'ban': {
   1: '%(pre)s Player%(plu)s banned: %(var)s',
   2: '%(pre)s %(adm)s banned player%(plu)s: %(var)s'
  },
  'unban': {
   1: '%(pre)s Player%(plu)s unbanned: %(var)s',
   2: '%(pre)s %(adm)s unbanned player%(plu)s: %(var)s'
  },
  'swapteam': {
   1: '%(pre)s Player%(plu)s swapped: %(var)s',
   2: '%(pre)s %(adm)s swapped player%(plu)s: %(var)s'
  },
  'swapt': {
   1: '%(pre)s Player%(plu)s swapped to T: %(var)s',
   2: '%(pre)s %(adm)s swapped player%(plu)s to T: %(var)s'
  },
  'swapct': {
   1: '%(pre)s Player%(plu)s swapped to CT: %(var)s',
   2: '%(pre)s %(adm)s swapped player%(plu)s to CT: %(var)s'
  },
  'swapspec': {
   1: '%(pre)s Player%(plu)s swapped to Spec: %(var)s',
   2: '%(pre)s %(adm)s swapped player%(plu)s to Spec: %(var)s'
  },
 }
 
 login = {
  'success': '%(pre)s Logged in as admin successfully',
  'attempt': '%(pre)s Bad Password - %(num)s attempt%(plu)s remaining before permanent ban',
  'failed': '%(pre)s Bad Password',
 }
 
 denied = '%s You do not have admin privileges'
 
class servercmd:
 def __init__(self, quotes=True):
  self.quotes = quotes
 def __getattr__(self, name):
  if name == 'execute':
   name = 'exec'
  self.name = str(name).replace('"', '')
  return self
 def __call__(self, *args):
  commandstring = self.name
  for i in args:
   i = str(i)
   i = i.replace('"', '')
   if self.quotes:
    i = '"%s"' % i
   commandstring += ' %s' % i
  es.server.cmd(commandstring)
  return self

specialcmd = servercmd(False)
servercmd = servercmd()

class sv():
 def __getattr__(self, name):
  return es.server_var[name]
 def __getitem__(self, name):
  return es.server_var[name]

sv = sv()

#----- misc actions -----

class itemobj:
 
 class bans:
  
  def __init__(self):
   self.__iter__ = self.get
  
  def get(self):
   return _bans
 
 class players:
 
  def __init__(self, filters=[], bots=True):
   self.bots = bots
   if 'bot' in filters:
    self.bots = True
   self.filters = filters
   self.__iter__ = self.get
   
  def get(self):
   return self.filter(self.getplayers(self.bots), self.filters)
   
  def getplayers(self, bots=True):
    
   players = []
   for player in es.getUseridList():
    if not isfake(player):
     if bots:
      players.append(player)
     elif not es.isbot(player):
      players.append(player)
   return players
  
  def filter(self, players, filters):
  
   if filters and not 'all' in filters and not '*' in filters:
    newplayers = []
    for id in players:
     team = int(es.getplayerteam(id))
     if [None, '#spec', '#t', '#ct'][team] in filters:
      newplayers.append(id)
      continue
     if '#bot' in filters:
      if es.isbot(id):
       newplayers.append(id)
       continue
     name = es.getplayername(id)
     for filter in filters:
      if not filter in ['#spec', '#t', '#ct', '#bot']:
       if filter.lower() in name.lower():
        newplayers.append(id)
    if newplayers:
     players = newplayers
   return players

def getplayers(filters=[], bots=True):

 if 'bot' in filters:
  bots = True
  
 players = []
 playerlist = es.getUseridList()
 for id in playerlist:
  if es.getuserid(id):
   if not isfake(id):
    if bots:
     players.append(id)
    elif not es.isbot(id):
     players.append(id)

 if filters and not 'all' in filters and not '*' in filters:
  newplayers = []
  for id in players:
   team = int(es.getplayerteam(id))
   if [None, '#spec', '#t', '#ct'][team] in filters:
    newplayers.append(id)
    continue
   if '#bot' in filters:
    if es.isbot(id):
     newplayers.append(id)
     continue
   name = es.getplayername(id)
   for filter in filters:
    if not filter in ['#spec', '#t', '#ct', '#bot']:
     if filter.lower() in name.lower():
      newplayers.append(id)
  if newplayers:
   players = newplayers
   
 return players



def itemlist(title, items, function=lambda x: x):
 array = {}
 count = 0
 items = list(items)
 if '' in items:
  length = 0
  for i in items:
   if i != '':
    length += 1
 else:
  length = len(items)
 pages = 1
 while length > 7:
  pages += 1
  length -= 7
 while True:
  count += 1
  array[count] = {}
  content = title
  if pages > 1:
   content += ' %s|%s' % (count, pages)
  content += ' \n '
  choices = '08'
  for i in range(1,8):
   if not items:
    break
   while items[0] == '':
    del items[0]
    content += ' \n '
   choices += str(i)
   array[count][i] = items[0]
   final = function(items[0])
   content += '\n->%s %s' % (i, final)
   del items[0]
  content += backnext(items)
  if items:
   choices += '9'
  array[count]['content'] = content
  array[count]['choices'] = choices
  if not items:
   break
 return array

def listobjects(object, pre=''):
 for name in object.__dict__:
  obj = object.__dict__[name]
  if not name in ['__%s__' % i for i in ('builtins', 'file', 'name', 'doc', 'module')]:
   name = '%s.%s' % (pre, name) if pre else name
   if hasattr(obj, '__dict__'):
    for i in listobjects(obj, name):
     yield i
   else:
    yield name

def choice(args, options):
 match = []
 for arg in args:
  if arg in options:
   if not arg in match:
    match.append(arg)
 return len(match) if len(match) != 1 else match[0]

def newname(name, items):
 name = name.replace(' ', '-')
 if name in items:
  c = 1
  while True:
   c += 1
   new = '%s-%s' % (name, c)
   if not new in items:
    return new
 else:
  return name

def backnext(forward=False):
 return '\n \n« 8' + (' 9 »' if forward else '')

def filterlist(itemlist, choices, itemfunc = lambda x : x, choicefunc = lambda x : x):
 items = []
 for item in itemlist:
  if not item in items:
   for choice in choices:
    if choicefunc(choice).lower() in itemfunc(item).lower():
     items.append(item)
     break
 return items

def isfake(player):
 if not es.isbot(player) and es.getplayersteamid(player).lower() == 'bot':
  return True
 else:
  return False

def subvars(name, thetime=None):
 if not thetime:
  thetime = time.time()
 replace = {}
 date = time.gmtime(thetime+(60*config.time.offset))
 date = ['0%s'%i if len(i) == 1 else i for i in [str(i) for i in date]]
 if '%map%' in name:
  replace['map'] = sv.eventscripts_currentmap
 if '%players%' in name:
  replace['players'] = es.getplayercount()
 if '%year%' in name:
  replace['year'] = date[0]
 if '%month%' in name:
  replace['month'] = date[1]
 if '%monthname%' in name:
  replace['monthname'] = ('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December')[date[1]-1]
 if '%day%' in name:
  replace['day'] = date[2]
 if '%dayname%' in name:
  replace['dayname'] = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday')[date[6]]
 if '%shortdayname%' in name:
  replace['shortdayname'] = ('Mon', 'Tue', 'Wed', 'Thur', 'Fri', 'Sat', 'Sun')[date[6]]
 if '%daysuffix%' in name:
  day = str(date[2])
  if (day[1] == 1 and len(day) > 1) or not day[-1] in (1, 2, 3):
   suffix = 'th'
  else:
   suffix = {'1':'st', '2':'nd', '3':'rd'}[day[-1]]
  replace['daysuffix'] = day + suffix
 if '%hour%' in name:
  replace['hour'] = date[3]
 if '%min%' in name:
  replace['min'] = date[4]
 if '%sec' in name:
  replace['sec'] = date[5]
 for i in replace:
  name = name.replace('%'+i+'%', str(replace[i]))
 return name

def rr(norm):
 if norm:
  servercmd.mp_restartgame(1)
  es.centermsg('Restarting Game')
 else:
  es.forcevalue('sv_cheats', '1')
  servercmd.endround()
  es.centermsg('Restarting Game')
  es.forcevalue('sv_cheats', '0')


# ----- small events -----

  
def player_use(ev):
 es.msg('PLAYER UUUUSE')

def bomb_planted(ev):
 config.bombplanted = time.time()

def round_start(ev):
 if config.restarted:
  config.restarted.load(True)
 config.bombplanted = 0
 config.roundstarted = time.time()
 if config.restart[0]:
  config.restart[0] -= 1
  gamethread.delayed(config.restart[1], rr, False)
  if not config.restart[0]:
   gamethread.delayed(config.restart[1], es.msg, config.restart[2])
 elif config.restart[3]:
  config.restart[3] = False
  players = getplayers()
  removeguns = ''
  for player in players:
   obj = playerlib.getPlayer(player)
   if config.ko3.removearmour:
    obj.set('armor', 0)
   if config.ko3.removecash:
    obj.set('cash', 0)
   if config.ko3.removeguns:
    for gun in [obj.get('primary'), obj.get('secondary')]:
     if not gun == '0':
      #removeguns += 'es_xdelayed 0 es_xremove weapon_%s; ' % gun
      es.remove('weapon_%s; ' % gun)
    es.sexec(player, 'use weapon_knife')
  servercmd.removeguns()
  es.msg(removeguns)

def server(ev):
 es.msg(es.loadevents(config.dir.events_es))
 es.msg(es.loadevents(config.dir.events_game))
 es.msg(es.loadevents(config.dir.events_engine))
 global _players
 _players = {}
 for id in getplayers(bots=False):
  _players[id] = player(id)
 _players[0] = player(0)
 global _demo
 _demo = demo()
 
def es_player_variable(ev):
 if ev['status'] == 'success':
  id = int(ev['userid'])
  var = ev['variable']
  val = ev['value']
  if id in _players:
   pl = _players[id]
   if var == 'rcon_password':
    if val == sv.rcon_password:
     pl.admin = True
     if pl.command:
      pl.command[0](pl, args=pl.command[1], silent=pl.command[2])
      pl.command = None
     
 
def player_changename(ev):
 id = int(ev['userid'])
 global _players
 if id in _players:
  _players[id].name = str(ev['newname'])
 
def player_disconnect(ev):
 id = int(ev['userid'])
 global _players
 if id in _players:
  del _players[id]
 
def player_team(ev):
 es.msg('teeeeeaaam')
 global _players
 id = int(ev['userid'])
 if es.getuserid(id):
  if not id in _players:
   if not isfake(id):
    _players[id] = player(id)
    es.msg(_players[id].name, 'connected')
    
class config:
 def __getattr__(self, name):
  if self.reload():
   return self.config.__dict__[name]

 def reload(self):
  if os.path.exists(self.dir.settings_txt):
   modified = os.stat(self.dir.settings_txt).st_mtime
   if modified > self.modified:
    self.modified = modified
    if os.path.exists(self.dir.settings_py):
     os.remove(self.dir.settings_py)
    new = open(self.dir.settings_py, 'w')
    old = open(self.dir.settings_txt, 'r')
    new.write(old.read())
    new.close()
    old.close()
    if not self.config:
     import conf
     self.config = conf
    else:
     reload(self.config)
    os.remove(self.dir.settings_py)
   return True
  elif self.config:
   return True
  return False
 
 config = None
 
 playerlist = None
 
 output = en
 prefix = 'ED | '
 
 restart = [0, 0.2, '', False] # restart game instantaneously: (number of times, delay, output text on last rr, knife)
 
 modified = 0
 
 serverblock = 'ed/servercall'
 clientblock = 'ed/clientcall'
 sayblock = 'ed/saycall'
 
 class dir:
  cstrike = str(sv.eventscripts_gamedir).replace('\\', '/') + '/'
  maps = cstrike + 'maps/'
  cfg = cstrike + 'cfg/'
  ed = cstrike + 'addons/eventscripts/ed/'
  events_es = ed + 'events_es.res'
  events_game = ed + 'events_game.res'
  events_engine = ed + 'events_engine.res'
  maplist = cstrike + 'maplist.txt'
  banlist = ed + 'banlist.txt'
  settings_txt = ed + 'settings/settings.txt'
  settings_py = ed + 'conf.py'
 
 bombplanted = 0
 roundstarted = 0
 
 restarted = False
 
 commandprefixes = ['/', '!', '#']
 
 standardmaps = [
  'de_dust',
  'de_aztec',
  'de_cbble',
  'de_chateau',
  'de_dust2',
  'de_piranesi',
  'cs_italy',
  'cs_havana',
  'cs_office',
  'de_train',
  'cs_compound',
  'de_prodigy',
  'de_tides',
  'de_port',
  'de_inferno',
  'cs_assault',
  'de_nuke',
  'cs_militia',
 ]
 
 primary = [
  'awp',
  'scout',
  'aug',
  'mac10',
  'tmp',
  'mp5navy',
  'ump45',
  'p90',
  'galil',
  'famas',
  'ak47',
  'sg552',
  'sg550',
  'g3sg1',
  'm249',
  'm3',
  'xm1014',
  'm4a1'
 ]
 
 secondary = [
  'glock',
  'usp',
  'p228',
  'deagle',
  'elite',
  'fiveseven'
 ]
 
 ammo = {
  'awp':'005',
  'scout':'002',
  'aug':'002',
  'mac10':'008',
  'tmp':'006',
  'mp5navy':'006',
  'ump45':'008',
  'p90':'010',
  'galil':'003',
  'famas':'003',
  'ak47':'002',
  'sg552':'003',
  'sg550':'003',
  'g3sg1':'002',
  'm249':'004',
  'm3':'007',
  'xm1014':'007',
  'm4a1':'003',
  'glock':'006',
  'usp':'008',
  'p228':'009',
  'deagle':'001',
  'elite':'006',
  'fiveseven':'010'
 }
config = config()