def player_hurt(ev):
    armor = int(ev['es_userarmor'])
    if armor < 150 and armor + int(ev['dmg_armor']) >= 150:
        player = getPlayer(ev['userid'])
        gamethread.cancelDelayed(delayname % player)
        gamethread.delayedname(FUEL_REGEN_DELAY, delayname % player,
                               fuel_regen, player)
def load():
    xaextendedpunishments.addRequirement('xapunishments')
    # xaextendedpunishments.xapunishments.registerPunishment("punishment", xalanguage["punishment"], _callback_function)
    xaextendedpunishments.xapunishments.registerPunishment(
        "blind", xalanguage["blind"], _blind, 1)
    xaextendedpunishments.xapunishments.registerPunishment(
        "freeze", xalanguage["freeze"], _freeze, 1)
    xaextendedpunishments.xapunishments.registerPunishment(
        "gimp", xalanguage["gimp"], _gimp, 1)
    xaextendedpunishments.xapunishments.registerPunishment(
        "drug", xalanguage["drug"], _drug, 1)
    xaextendedpunishments.xapunishments.registerPunishment(
        "beacon", xalanguage["beacon"], _beacon, 1)
    xaextendedpunishments.xapunishments.registerPunishment(
        "noclip", xalanguage["noclip"], _noclip, 1)
    xaextendedpunishments.xapunishments.registerPunishment(
        "freezebomb", xalanguage["freezebomb"], _freeze_bomb, 1)
    xaextendedpunishments.xapunishments.registerPunishment(
        "timebomb", xalanguage["timebomb"], _time_bomb, 1)
    xaextendedpunishments.xapunishments.registerPunishment(
        "firebomb", xalanguage["firebomb"], _fire_bomb, 1)
    xaextendedpunishments.xapunishments.registerPunishment(
        "rocket", xalanguage["rocket"], _rocket, 1)
    if int(xa_adminmute_on):
        xaextendedpunishments.xapunishments.registerPunishment(
            "mute", xalanguage["mute"], _mute, 1)
    gamethread.delayedname(1, 'blind_loop', _blind_loop)
    """ Make sure if XA is loaded late, add all players """
    for player in es.getUseridList():
        player_activate({'userid': player})
Example #3
0
def player_hurt(event_var):
    """
    When a player is damaged, check for team attacks, then if the weapon is
    a secondary weapon then freeze the player
    
    @PARAM event_var - an automatically passed event instance
    """
    userid   = event_var['userid']
    attacker = event_var['attacker']
    if int(attacker):
        """ The attacker did not hurt themselves """
        player = sourcerpg.players[attacker]
        level  = player[skillName]
        if level:
            """ The player has at least level 1 in this skill """
            if event_var['es_userteam'] <> event_var['es_attackerteam']:
                """ It was not a team kill """
                if event_var['weapon'] in map(lambda x: x.split('_')[-1], weaponlib.getWeaponNameList('#secondary')):
                    victim = sourcerpg.players[userid]
                    speed  = victim['maxSpeed']
                    if not victim['slowed']:
                        """ If they're frozen, there's no point (i,e Ice Stab) """
                        playerlibInstance = playerlib.getPlayer(userid)
                        if not playerlibInstance.getFreeze():
                            """ Ensure that they're only slowed once """
                            victim['slowed'] = True
                            speed /= 2.0
                            victim['maxSpeed'] = speed
                            playerlibInstance.speed = speed
                            playerlibInstance.setColor(0, 0, 255)
                            gamethread.delayedname(float(freezeTime) * level, 'sourcerpg_slow_user%s' % userid, speedUp, (userid, speed * 2.0))
                    else:
                        gamethread.cancelDelayed("sourcerpg_slow_user%s" % userid)
                        gamethread.delayedname(float(freezeTime) * level, 'sourcerpg_slow_user%s' % userid, speedUp, (userid, speed * 2.0))
Example #4
0
def KI_regen(userid):
    global gusers
    userid = str(userid)
    if not superhero.hasHero(userid, 'Goku'):
        return
    player = playerlib.getPlayer(userid)
    if not playerlib.getPlayer(userid).isdead:
        gusers[userid] = {}
        gusers[userid]['GokuJump'] = 1.0
        if player.armor < 450:
            player.armor = player.armor + 5
        if player.armor < 150:
            hsay(userid, 'Your LVL is 0!\nKI = %i' % player.armor)
            gusers[userid]['LVL'] = 0
        if player.armor in range(150, 226):
            hsay(userid, 'Your LVL is 1!\nKI = %i' % player.armor)
            gusers[userid]['LVL'] = 1
        elif player.armor in range(227, 301):
            hsay(userid, 'Your LVL is 2!\nKI = %i' % player.armor)
            gusers[userid]['LVL'] = 2
        elif player.armor in range(302, 376):
            hsay(userid, 'Your LVL is 3!\nKI = %i' % player.armor)
            gusers[userid]['LVL'] = 3
        elif player.armor > 375:
            hsay(userid, 'Your LVL is 4!\nKI = %i' % player.armor)
            gusers[userid]['LVL'] = 4
        gamethread.delayedname(KI_REGEN_DELAY, delayname % player, KI_regen,
                               player)
Example #5
0
 def sendReminders(self):
     for second in str(lmv_time_left_seconds).split(','):
         if second.isdigit() and 0 < int(second) < int(lmv_time_to_vote):
             second = int(second)
             seconds_to_wait = int(lmv_time_to_vote) - second
             allseconds.add(second)
             gamethread.delayedname(seconds_to_wait,'lmv_reminder_%s'%second,self.sendAllPlayersMessages,('One Second Remains' if second == 1 else 'Time Remaining',{'seconds':second},str(lmv_time_left_message_types).split(','),True))
Example #6
0
   def removeWeapon(self, weapon):
      """
      Executes "lastinv" on the client if the weapon to remove is the player's active weapon
      Removes the weapon by index
      Creates a new weapon at the player's feet if necessary
      Announces the restricted pickup
      """
      longname = 'weapon_' + weapon

      if es.createplayerlist(self.userid)[self.userid]['weapon'] == longname:
         es.cexec(self.userid, 'lastinv')

      for index in es.createentitylist(longname):
         if es.getindexprop(x, 'CBaseEntity.m_hOwnerEntity') <> self.handle: continue

         gamethread.delayedname(0.2, 'saferemove_%s'%index, saferemove, index)

         if (getTeam(2).isRestricted(weapon) and getTeam(3).isRestricted(weapon)) if int(removebanned) else False:
            lastgive = -1

         else:
            eye_angles = tuple(es.getplayerprop(self.userid, eyeangle_prop % x) for x in range(3))
            es.server.cmd('es_xsetang %s 90 0 0' % self.userid)

            es.server.cmd('es_xentcreate %s %s' % (self.userid, longname))
            lastgive = int(es.ServerVar('eventscripts_lastgive'))
            setNPCWeapon(longname)

            es.server.cmd('es_xsetang %s %s %s %s' % ((self.userid,) + eye_angles))

         self.announceRestrictedPickup(weapon, lastgive)

         break
Example #7
0
def player_death(event_var):
    """
    Removes the dead player's handle from the dictionary of living player handles
    Registers client command filter if this is the first unauthorized dead player
    Adds the player to the dictionary of dead players to monitor if the player is not authorized to observe opponents
    """
    userid = int(event_var['userid'])
    team   = int(event_var['es_userteam']) if event_var['es_userteam'] else 0
    handle = es.getplayerhandle(userid)

    if team in team_handles:
        for loop_userid in dead_players:
            if dead_players[loop_userid] == handle:
                gamethread.delayedname(float(spec_delay), 'xaobserve_%s' % loop_userid, end_spec_delay, loop_userid)
                if loop_userid not in delays:
                    delays.append(loop_userid)

        if handle in team_handles[team]:
            team_handles[team].remove(handle)

    if not xaobserve.isUseridAuthorized(userid, 'observe_opponent') and event_var['es_steamid'] <> 'BOT':
        if not dead_players:
            es.addons.registerClientCommandFilter(client_command_filter)

        dead_players[userid] = -1
        gamethread.delayedname(float(spec_delay), 'xaobserve_%s' % userid, end_spec_delay, (userid, True) )
        if userid not in delays:
            delays.append(userid)
Example #8
0
    def check_spawn(self):
        '''Used to check if a player should be
            spawned when joining a round late'''

        # Should players be spawned during the mid round?
        if not int(gg_elimination_spawn):

            # If not, return
            return

        # Is the round active?
        if not ActiveInfo.round:

            # If not, return
            return

        # Is the player on a team?
        if getplayerteam(self.userid) < 2:

            # If not, return
            return

        if self.reconnect:

            # If they are reconnecting, return
            return

        # Cancel the current delay (if it exists)
        cancelDelayed('gg_elimination_respawn_%s' % self.userid)

        # Add the player to the respawn list in 3 seconds
        delayedname(3, 'gg_elimination_respawn_%s' % self.userid,
                    respawn_players.append, [self.userid])
Example #9
0
 def _ticker(self):
     """
     Here we loop through all of the players, and check their gravity etc.
     """
     for player in self.gravityList.itervalues():
         player.update()
     gamethread.delayedname(0.25, 'gravity_check', self._ticker)        
def player_disconnect(ev): 
    userid = int(ev['userid']) 
    if userid in players: 
        del players[userid]

    if userid in map(int, muted): 
        gamethread.delayedname(int(xa_adminmute_deletetime), 'unmute_%s'%ev['networkid'], _unmute, ev['networkid'])
Example #11
0
    def _ticker(self):
        '''
        Here we loop through all of the players, and check their gravity etc.
        '''
        # Loop through all players in the gravity dictionary
        for player in self.gravityList:
            try:
                if es.exists('userid', player):
                    newaval = es.getplayerprop(player, 'CBasePlayer.m_fFlags')
                    newmval = es.getplayerprop(player, 'CBaseEntity.movetype')
                else:
                    newaval = 0
                    newmval = 2

                if (self.gravityList[player]['lastairvalue'] != newaval or
                  self.gravityList[player]['lastmovementvalue'] != newmval):

                    # Player has jumped or come off of a ladder
                    self._resetGravity(player,
                                       self.gravityList[player]['gravity'])

                self.gravityList[player]['lastairvalue'] = newaval
                self.gravityList[player]['lastmovementvalue'] = newmval
            except:
                continue

        gamethread.delayedname(0.25, 'gravity_check', self._ticker)
Example #12
0
    def addGravityChange(self, userid, amount):
        '''
        Check if there are already any players in the gravityChange list.
        If there isn't, start the tick listener. Following this, check
        if the userid is in the dictionary, if so, remove them. Then create
        a new instance.
        '''
        userid = int(userid)

        if not len(self.gravityList):
            gamethread.delayedname(0.25, 'gravity_check', self._ticker)

        if userid in self.gravityList:
            self.removeGravityChange(userid)

        if es.exists('userid', userid):
            self.gravityList[userid] = {
                'lastairvalue': es.getplayerprop(userid,
                                                 'CBasePlayer.m_fFlags'),
                'gravity': amount,
                'lastmovementvalue': es.getplayerprop(userid,
                                                      'CBaseEntity.movetype')
            }
        else:
            self.gravityList[userid] = {
                'lastairvalue': 0,
                'gravity': amount,
                'lastmovementvalue': 2
            }

        self._resetGravity(userid, amount)
def beacon(userid):
    userid = int(userid)
    for player in playerlib.getPlayerList('#alive'):
        if player.team == 2:
            iRed = 255
            iBlue = 0
        else:
            iRed = 0
            iBlue = 255
        spe_effects.beamRingPoint(
        userid, #'#all', # users
        0., # fDelay
        player.location, # vOrigin
        0., # fStartRadius
        600., # fEndRadius
        'sprites/lgtning.vmt', # szModelPath
        1, # iHaloIndex
        0, # iStartFrame
        255, # iFrameRate
        0.3, # fLife
        12, # fWidth
        0, # iSpread
        2., # fAmplitude
        iRed, # iRed
        0, # iGreen
        iBlue, # iBlue
        255, # iAlpha
        0.5, # iSpeed
        0, # iFlags
        )
    gamethread.delayedname(2, 'beacon_%i' % userid, beacon, userid)
Example #14
0
def Check_Runboost(userid):
    location = es.getplayerlocation(userid)
    steamid = es.getplayersteamid(userid)
    velocity = int(
        round(
            vector(
                (float(
                    es.getplayerprop(
                        userid, 'CBasePlayer.localdata.m_vecVelocity[0]')),
                 float(
                     es.getplayerprop(
                         userid, 'CBasePlayer.localdata.m_vecVelocity[1]')),
                 float(
                     es.getplayerprop(
                         userid,
                         'CBasePlayer.localdata.m_vecVelocity[2]')))).length(),
            2))
    gamethread.cancelDelayed("Check_Ground_%s" % userid)
    if playerOnTop(userid)[0] == "True":
        client[steamid]['loc'] = location
        client[steamid]['time'] = 0
        client[steamid]['avs'] = []
        client[steamid]['pre'] = velocity
    else:
        gamethread.cancelDelayed("Check_Ground_%s" % userid)
        Check_When_Grounded(userid, False, True)
        return

    gamethread.delayedname(0.001,
                           'Check_Runboost_%s' % userid,
                           Check_Runboost,
                           args=(userid))
def kickPlayer(ulib):
    '''
    Kicks the player
     - If an IP is set in the cfg then it tries to soft redirect them
    '''
    uid = int(ulib)  # we seemto need the uid alot so lets grab it here
    ip = str(xareserveslots.setting.getVariable("reserve_slots_redirect"))
    if ip != "0":
        # send them a dialogue box...
        msglib.VguiDialog(title=ip, time=15,
                          mode=msglib.VguiMode.ASKCONNECT).send(uid)
        # but also set them up for a kick in 15 seconds if they dont comply
        kick_delays.append(uid)
        gamethread.delayedname(
            15, 'res_redirect_%s' % uid, ulib.kick,
            (text("ip_kick_message", {"ip": ip}, ulib.get("lang"))))
        xareserveslots.logging.log(
            "being redirected to %s for taking a reserve slot" % ip, uid)
    else:
        if str(xareserveslots.setting.getVariable(
                "reserve_slots_kick_message")) == "0":
            # PLEASE use langlib :)
            msg = text("kick_message", None, ulib.get("lang"))
        else:
            msg = str(
                xareserveslots.setting.getVariable(
                    "reserve_slots_kick_message"))
        xareserveslots.logging.log("being kicked for taking a reserve slot",
                                   uid)
        ulib.kick(msg)
Example #16
0
def server_cvar(event_var):
    value = event_var['cvarvalue']
    name = event_var['cvarname']

    if name == "mp_timelimit" and startTime is not None and int(
            time_before_end_of_map_vote):
        gamethread.cancelDelayed('votemap_timer')
        timeLimit = int(value) * 60
        if timeLimit:
            delay = timeLimit - int(time_before_end_of_map_vote) - (
                time.time() - startTime)
            if delay:
                gamethread.delayedname(delay, 'votemap_timer', EndOfMapVote,
                                       "mp_timelimit changing")
            else:
                EndOfMapVote('mp_timelimit changing')

    if name == "mp_maxrounds" and int(rounds_before_mp_maxrounds):
        maxRounds = int(value)
        if maxRounds:
            maxrounds = maxRounds - int(rounds_before_mp_maxrounds)
            if round_count['round_counting'] >= maxrounds:
                EndOfMapVote('mp_maxrounds')

    if name == "mp_winlimit" and int(rounds_before_mp_winlimit):
        winlimit = int(value)
        if winlimit:
            winlimit = winlimit - int(rounds_before_mp_winlimit)
            maxwins = max(round_count['t_wins'], round_count['c_wins'])
            if maxwins >= winlimit:
                EndOfMapVote('mp_winlimit')
Example #17
0
    def __mainloop(self):
        '''
        Creates the beacon, plays the sound and calls the callbacks.
        '''

        if self.duration != 'indefinitely':
            self.duration -= self.interval

        if self.duration <= 0:
            return stop(self.__userid)

        self.precallback(self.__userid, self)
        origin = es.getplayerlocation(self.__userid)
        origin = tuple(origin[x]+self.offset[y] for x, y in enumerate('xyz'))
        beamRingPoint(self.users, 0, origin, self.startradius, self.endradius,
            self.model, self.halo, self.startframe, self.framerate,
            self.interval, self.width, self.spread, self.amplitude, self.r,
            self.g, self.b, self.a, self.speed, self.flags)

        if self.soundtype == 'emitsound':
            es.emitsound('player', self.__userid, self.sound, self.volume,
                self.attenuation)

        elif self.soundtype == 'playsound':
            es.playsound(self.__userid, self.sound, self.volume)

        self.postcallback(self.__userid, self)
        gamethread.delayedname(self.interval, self.__name, self.__mainloop)
Example #18
0
def startProtect(userid):
    # Retrieve player objects
    pPlayer = getPlayer(userid)

    # Add them to the list of protected players
    protectedList.append(userid)

    # Set color
    pPlayer.color = (gg_spawn_protect_red,
                     gg_spawn_protect_green,
                     gg_spawn_protect_blue,
                     gg_spawn_protect_alpha)

    # Start Invincible
    pPlayer.godmode = 1

    # Set PreventLevel if needed
    if not int(gg_spawn_protect_can_level_up):
        ggPlayer = Player(userid)

        if not 'gg_spawn_protect' in ggPlayer.preventlevel():
            ggPlayer.preventlevel.append('gg_spawn_protect')

    # Start the delay to cancel spawn protection
    gamethread.delayedname(int(gg_spawn_protect),
        'ggSpawnProtect%s' % userid, endProtect, (userid))
Example #19
0
def player_say(ev):
    userid = ev['userid']
    text = ev['text']
    plyinst = playerlib.getPlayer(userid)
    if text == '!block' or text == '!unghost':
        if int(es.ServerVar('noblock_allow_block')) >= 1:
            if not plyinst.isdead and plyinst.teamid != 1 and plyinst.teamid != 0:
                try:
                    if not players[userid]['queued']:
                        plyinst.noblock(0)
                        gamethread.delayedname(float(es.ServerVar('noblock_block_time')), userid, noblock, userid)
                        players[userid]['queued'] = True
                        es.tell(userid, '#multi', '#green[NoBlock]#default You are now solid for ' + float(es.ServerVar('noblock_block_time')) + ' seconds')
                    else:
                        es.tell(userid, '#multi', '#green[NoBlock]#default You are already blocking')
                except KeyError:
                    es.msg('#green', 'Error in keys')
                    for k, v in players.items():
                        es.msg('#green', str(k) + '=' + str(v))
            else:
                es.tell(userid, '#multi', '#green[NoBlock]#default You cannot block when you are dead or not on a team')
        else:
            es.tell(userid, '#multi', '#green[NoBlock]#default Blocking is not allowed on this server')
    if text == '!noblock' or text == '!unblock' or text == '!ghost':
        if int(es.ServerVar('noblock_allow_block')) >= 1:
            if not plyinst.isdead and plyinst.teamid != 1 and plyinst.teamid != 0:
                if players[userid]['queued']:
                    gamethread.cancelDelayed(userid)
                    plyinst.noblock(1)
                    es.tell(userid, '#multi', '#green[NoBlock]#default You are no longer solid')
                else:
                    es.tell(userid, '#multi', '#green[NoBlock]#default You are not blocking')
            else: es.tell(userid, '#multi', '#green[NoBlock]#default You cannot unblock when dead or not on a team')
        else:
            es.tell(userid, '#multi', '#green[NoBlock]#default Cannot unblock because blocking is not allowed')
Example #20
0
def antispam():
    for userid in es.getUseridList():
        steamid = es.getplayersteamid(userid)
        if steamid not in client:
            QueueAPI.Validate(userid, 0)
        client[steamid]["spam"] = 0
    gamethread.delayedname(30, "spam", antispam)
Example #21
0
def DelayTimer():
    gamethread.cancelDelayed('votemap_timer')
    timeLimit = int(es.ServerVar('mp_timelimit')) * 60
    if timeLimit:
        delay = timeLimit - int(time_before_end_of_map_vote) - 10
        gamethread.delayedname(delay, 'votemap_timer', EndOfMapVote,
                               "timelimit")
Example #22
0
def player_death(event_var):
    """
    Removes the dead player's handle from the dictionary of living player handles
    Registers client command filter if this is the first unauthorized dead player
    Adds the player to the dictionary of dead players to monitor if the player is not authorized to observe opponents
    """
    userid = int(event_var['userid'])
    team = int(event_var['es_userteam']) if event_var['es_userteam'] else 0
    handle = es.getplayerhandle(userid)

    if team in team_handles:
        for loop_userid in dead_players:
            if dead_players[loop_userid] == handle:
                gamethread.delayedname(float(spec_delay),
                                       'xaobserve_%s' % loop_userid,
                                       end_spec_delay, loop_userid)
                if loop_userid not in delays:
                    delays.append(loop_userid)

        if handle in team_handles[team]:
            team_handles[team].remove(handle)

    if not xaobserve.isUseridAuthorized(
            userid, 'observe_opponent') and event_var['es_steamid'] <> 'BOT':
        if not dead_players:
            es.addons.registerClientCommandFilter(client_command_filter)

        dead_players[userid] = -1
        gamethread.delayedname(float(spec_delay), 'xaobserve_%s' % userid,
                               end_spec_delay, (userid, True))
        if userid not in delays:
            delays.append(userid)
Example #23
0
    def _ticker(self):
        '''
        Here we loop through all of the players, and check their gravity etc.
        '''
        # Loop through all players in the gravity dictionary
        for player in self.gravityList:
            try:
                if es.exists('userid', player):
                    newaval = es.getplayerprop(player, 'CBasePlayer.m_fFlags')
                    newmval = es.getplayerprop(player, 'CBaseEntity.movetype')
                else:
                    newaval = 0
                    newmval = 2

                if (self.gravityList[player]['lastairvalue'] != newaval
                        or self.gravityList[player]['lastmovementvalue'] !=
                        newmval):

                    # Player has jumped or come off of a ladder
                    self._resetGravity(player,
                                       self.gravityList[player]['gravity'])

                self.gravityList[player]['lastairvalue'] = newaval
                self.gravityList[player]['lastmovementvalue'] = newmval
            except:
                continue

        gamethread.delayedname(0.25, 'gravity_check', self._ticker)
Example #24
0
    def check_spawn(self):
        '''Used to check if a player should be
            spawned when joining a round late'''

        # Should players be spawned during the mid round?
        if not int(gg_elimination_spawn):

            # If not, return
            return

        # Is the round active?
        if not ActiveInfo.round:

            # If not, return
            return

        # Is the player on a team?
        if getplayerteam(self.userid) < 2:

            # If not, return
            return

        if self.reconnect:

            # If they are reconnecting, return
            return

        # Cancel the current delay (if it exists)
        cancelDelayed('gg_elimination_respawn_%s' % self.userid)

        # Add the player to the respawn list in 3 seconds
        delayedname(3,
            'gg_elimination_respawn_%s' % self.userid,
            respawn_players.append, [self.userid])
Example #25
0
def player_spawn(ev):
    dbg('player_spawn')
    if not es.isbot(ev['userid']):
        steamid = es.getplayersteamid(ev['userid'])
        if not steamid:
            dbg('NO STEAM ID!!!')
            return
        if steamid == 'STEAM_ID_PENDING':
            dbg('STEAM_ID_PENDING')
            gamethread.delayedname(1, 'xs_delayed_%s' % ev['userid'], pendingCheck, kw={userid:ev['userid']})
            pending.append(ev['userid']) 
            return
        if not ev['userid'] in newconnected:
            return
        if not steamid in players:
            players.newplayer(steamid)
        if not steamid in toplist:
            toplist.newplayer(steamid)
        players.increment(steamid,'sessions')
        players.update(steamid,'sessionstart',time.time())
        players.update(steamid,'lastseen',time.time())
        players.update(steamid,'teamchange_time',time.time())
        newname = es.getplayername(ev['userid'])
        players.name(steamid,newname)
        newconnected.remove(ev['userid'])
        if ev['userid'] in pending:
            pending.remove(ev['userid'])
        dbg('player spawned: %s' % steamid)
Example #26
0
def load():
    global adverts, time_between_advert, adverts_chat_area, adverts_top_left, advert_col_red, advert_col_green, advert_col_blue, advert_dead_only, adverts_bottom_area, xaadvertlist

    # make config vars
    adverts = xaadvert.setting.createVariable('adverts', 1,
                                              'Turns adverts on or off')
    time_between_advert = xaadvert.setting.createVariable(
        'time_between_advert', 120, 'Time between adverts displayed')
    adverts_chat_area = xaadvert.setting.createVariable(
        'adverts_chat_area', 1, 'Allow adverts in chat area of screen')
    adverts_top_left = xaadvert.setting.createVariable(
        'adverts_top_left', 1, 'Allow adverts in top left corner of screen')
    advert_col_red = xaadvert.setting.createVariable(
        'advert_col_red', 0, 'Red component colour of adverts (255 = max)')
    advert_col_green = xaadvert.setting.createVariable(
        'advert_col_green', 0, 'Green component colour of adverts (255 = max)')
    advert_col_blue = xaadvert.setting.createVariable(
        'advert_col_blue', 255, 'Blue component colour of adverts (255 = max)')
    advert_dead_only = xaadvert.setting.createVariable(
        'advert_dead_only', 0,
        'Specify if all players or only dead players can see adverts')
    adverts_bottom_area = xaadvert.setting.createVariable(
        'adverts_bottom_area', 0, 'Show adverts in the hint text area')

    # get advert list
    if xa.isManiMode():
        xaadvertlist = xaadvert.configparser.getList(
            'cfg/mani_admin_plugin/adverts.txt', True)
    else:
        xaadvertlist = xaadvert.configparser.getList('adverts.txt')

    # start timer
    gamethread.delayedname(time_between_advert, 'adverts', display_advert)
def load():
	print("BlueZM Enabled")
	es.server.queuecmd("mp_restartgame 1")
	es.server.queuecmd("mp_autoteambalance 0")
	es.server.queuecmd("eventscripts_noisy 1")
	
#****************************************** Lists ******************************************
	global Zombies,Survivors,Spec
	Zombies = []
	Survivors = []
	Spec = []

#****************************************** Vars ******************************************
	#Grace period to ignore player deaths/roundswaps pregame.
	global Grace,Kicked_Bots,LastMan
	LastMan = 0
	Kicked_Bots = 0
	Grace = 1

#****************************************** Utility Blocks ******************************************
	es.addons.registerSayFilter(TeamChat)
	es.addons.registerClientCommandFilter(CommandFilter)

	gamethread.delayedname(.5,"Deplete_Infected_Ammo",Deplete_Infected_Ammo,())
	gamethread.delayedname(5,"Request_RoundType_Update",Request_RoundType_Update,())
Example #28
0
def beacon(userid):
    userid = int(userid)
    for player in playerlib.getPlayerList('#alive'):
        if player.team == 2:
            iRed = 255
            iBlue = 0
        else:
            iRed = 0
            iBlue = 255
        spe_effects.beamRingPoint(
            userid,  #'#all', # users
            0.,  # fDelay
            player.location,  # vOrigin
            0.,  # fStartRadius
            600.,  # fEndRadius
            'sprites/lgtning.vmt',  # szModelPath
            1,  # iHaloIndex
            0,  # iStartFrame
            255,  # iFrameRate
            0.3,  # fLife
            12,  # fWidth
            0,  # iSpread
            2.,  # fAmplitude
            iRed,  # iRed
            0,  # iGreen
            iBlue,  # iBlue
            255,  # iAlpha
            0.5,  # iSpeed
            0,  # iFlags
        )
    gamethread.delayedname(2, 'beacon_%i' % userid, beacon, userid)
Example #29
0
def KI_regen(userid):
    global gusers
    userid = str(userid)
    if not superhero.hasHero(userid, 'Goku'):
        return
    player = playerlib.getPlayer(userid)
    if not playerlib.getPlayer(userid).isdead:
        gusers[userid] = {}
        gusers[userid]['GokuJump'] = 1.0
        if player.armor < 450:
            player.armor = player.armor + 5
        if player.armor < 150:
            hsay(userid, 'Your LVL is 0!\nKI = %i'%player.armor)
            gusers[userid]['LVL'] = 0
        if player.armor in range(150, 226):
            hsay(userid, 'Your LVL is 1!\nKI = %i'%player.armor)
            gusers[userid]['LVL'] = 1
        elif player.armor in range(227, 301):
            hsay(userid, 'Your LVL is 2!\nKI = %i'%player.armor)
            gusers[userid]['LVL'] = 2
        elif player.armor in range(302, 376):
            hsay(userid, 'Your LVL is 3!\nKI = %i'%player.armor)
            gusers[userid]['LVL'] = 3
        elif player.armor > 375:
            hsay(userid, 'Your LVL is 4!\nKI = %i'%player.armor)
            gusers[userid]['LVL'] = 4
        gamethread.delayedname(KI_REGEN_DELAY, delayname % player, KI_regen, player)
Example #30
0
    def removeWeapon(self, weapon):
        """
      Executes "lastinv" on the client if the weapon to remove is the player's active weapon
      Removes the weapon by index
      Creates a new weapon at the player's feet if necessary
      Announces the restricted pickup
      """
        longname = "weapon_" + weapon
        xarestrict.logging.log("Weapon %s has been removed from user %s" % (weapon, es.getplayername(self.userid)))
        if es.createplayerlist(self.userid)[self.userid]["weapon"] == longname:
            es.cexec(self.userid, "lastinv")

        for index in es.createentitylist(longname):
            if es.getindexprop(x, "CBaseEntity.m_hOwnerEntity") <> self.handle:
                continue

            gamethread.delayedname(0.2, "saferemove_%s" % index, saferemove, index)

            if (getTeam(2).isRestricted(weapon) and getTeam(3).isRestricted(weapon)) if int(removebanned) else False:
                lastgive = -1

            else:
                eye_angles = tuple(es.getplayerprop(self.userid, eyeangle_prop % x) for x in range(3))
                es.server.cmd("es_xsetang %s 90 0 0" % self.userid)

                es.server.cmd("es_xentcreate %s %s" % (self.userid, longname))
                lastgive = int(es.ServerVar("eventscripts_lastgive"))
                setNPCWeapon(longname)

                es.server.cmd("es_xsetang %s %s %s %s" % ((self.userid,) + eye_angles))

            self.announceRestrictedPickup(weapon, lastgive)

            break
Example #31
0
def drunk(users, lifetime=0, iFov=155):
    '''Drunk a player for the given time...'''
    
    # Loop through all matching players...
    for userid in _get_matching_players(users):
        
        # Is the player a bot?
        if es.isbot(userid):
            
            # Don't go further...
            continue
            
        # Set the fov to the given value...
        es.setplayerprop(userid, 'CBasePlayer.m_iDefaultFOV', iFov)
        es.setplayerprop(userid, 'CBasePlayer.m_iFOV', iFov)
        
        # Is there any time given?
        if not lifetime:
            
            # Don't go further...
            continue
            
        # Undrunk the player after the given time...
        gamethread.delayedname(
            lifetime, '_wcs_delay', _reset_player_fov, userid)
Example #32
0
    def addGravityChange(self, userid, amount):
        '''
        Check if there are already any players in the gravityChange list.
        If there isn't, start the tick listener. Following this, check
        if the userid is in the dictionary, if so, remove them. Then create
        a new instance.
        '''
        userid = int(userid)

        if not len(self.gravityList):
            gamethread.delayedname(0.25, 'gravity_check', self._ticker)

        if userid in self.gravityList:
            self.removeGravityChange(userid)

        if es.exists('userid', userid):
            self.gravityList[userid] = {
                'lastairvalue':
                es.getplayerprop(userid, 'CBasePlayer.m_fFlags'),
                'gravity':
                amount,
                'lastmovementvalue':
                es.getplayerprop(userid, 'CBaseEntity.movetype')
            }
        else:
            self.gravityList[userid] = {
                'lastairvalue': 0,
                'gravity': amount,
                'lastmovementvalue': 2
            }

        self._resetGravity(userid, amount)
Example #33
0
def player_hurt(ev):
    attacker = ev['attacker']
    player = playerlist[ev['attacker']]
    # If damage is not NULL
    if ev['damage'].isdigit():
        damage = int(ev['damage'])
    elif ev['dmg_health'].isdigit():
        damage = int(ev['dmg_health'])
    player = playerlist[ev['userid']]
    userid = player.userid  
    # If Attacker and Victim are not frozen: 
    if ev['weapon'] == 'knife':
        if attacker and int(attacker) in frozen:
            quit()
        if damage >= 35:
            player = playerlist[ev['attacker']]
            level = player.GetSkillLevel(skillname)
            if level:
                if userid not in frozen:
                    frozen.append(userid)
                # Freeze the player
                gamethread.cancelDelayed('rpg_%s_%s' % (skillname, userid))
                es.emitsound('player', userid, 'physics/glass/glass_impact_bullet%s.wav' % random.randint(1,4), '1.0', '0.5')
                player = playerlib.getPlayer(userid)
                player.freeze(True)
                player.setColor(0, 0, 255)
                # Delay
                delayname = 'rpg_%s_%s' %(skillname, userid)
                gamethread.cancelDelayed(delayname)
                gamethread.delayedname(0.42 * level, delayname, rpg_unfreeze, (player.userid))   
    if ev['weapon'] != 'knife':
        if userid in frozen:
            player = playerlib.getPlayer(userid)
            player.health += int(damage / 100 * 98)
Example #34
0
 def _ticker(self):
     """
     Here we loop through all of the players, and check their gravity etc.
     """
     for player in self.gravityList.itervalues():
         player.update()
     gamethread.delayedname(0.25, 'gravity_check', self._ticker)
Example #35
0
def Set_Location(userid):
    check = es.getplayerprop(userid, 'CBasePlayer.m_fFlags')
    location = es.getplayerlocation(userid)
    steamid = es.getplayersteamid(userid)
    player = playerlib.getPlayer(userid)
    velocity = int(
        round(
            vector(
                (float(
                    es.getplayerprop(
                        userid, 'CBasePlayer.localdata.m_vecVelocity[0]')),
                 float(
                     es.getplayerprop(
                         userid, 'CBasePlayer.localdata.m_vecVelocity[1]')),
                 float(
                     es.getplayerprop(
                         userid,
                         'CBasePlayer.localdata.m_vecVelocity[2]')))).length(),
            2))
    if not check & 1:
        if not playerOnTop(userid)[0] == "True":
            if velocity < 400:
                gamethread.cancelDelayed("Check_Runboost_%s" % userid)
                gamethread.cancelDelayed("Check_Ground_%s" % userid)
                Check_When_Grounded(userid, False, False)

            else:
                gamethread.cancelDelayed("Check_Runboost_%s" % userid)
                gamethread.cancelDelayed("Check_Ground_%s" % userid)
                Check_When_Grounded(userid, True, False)
        else:
            gamethread.cancelDelayed("Check_Runboost_%s" % userid)
            gamethread.cancelDelayed("Check_Ground_%s" % userid)
            Check_Runboost(userid)

        return
    else:
        client[steamid]['loc'] = location
        client[steamid]['time'] = 0
        client[steamid]['avs'] = []
        client[steamid]['pre'] = velocity
        gamethread.cancelDelayed("Check_Runboost_%s" % userid)
        gamethread.cancelDelayed("Check_Ground_%s" % userid)

    if player.isdead:
        gamethread.cancelDelayed("Check_Runboost_%s" % userid)
        gamethread.cancelDelayed("Check_Ground_%s" % userid)
        gamethread.cancelDelayed("Set_Location_%s" % userid)
        esc.tell(
            userid,
            "#255,51,0[#255,137,0LJStats#255,51,0] #snowis no longer tracking you!"
        )
        client[steamid]['lj'] = 0
        return

    gamethread.delayedname(0.001,
                           'Set_Location_%s' % userid,
                           Set_Location,
                           args=(userid))
 def endDelay(self):
     if self.mode == 1:
         self.sendAll(self.advertList[self.index])
         self.index += 1
         if self.index == len(self.advertList): self.index = 0
     elif self.mode == 2:
         self.sendAll(random.choice(self.advertList))
     gamethread.delayedname(self.delay, 'advertDelay', self.endDelay)
def fuel_regen(userid):
    userid = str(userid)
    player = playerlib.getPlayer(userid)
    if not playerlib.getPlayer(userid).isdead:
        value = player.armor = (player.armor + 1)  #min(player.armor + 1, 150)
        if value < 150:
            gamethread.delayedname(FUEL_REGEN_DELAY, delayname % player,
                                   fuel_regen, player)
Example #38
0
def server_cvar(event_var):
    if event_var['cvarname'] == "mp_timelimit" and startTime is not None and int(time_before_end_of_map_vote):
        gamethread.cancelDelayed('votemap_timer')
        delay = es.ServerVar('mp_timelimit') * 60 - int(time_before_end_of_map_vote) - (time.time() - startTime)
        if delay:
            gamethread.delayedname(delay, 'votemap_timer', EndOfMapVote)
        else:
            EndOfMapVote()
def Deplete_Infected_Ammo():
	gamethread.delayedname(.5,"Deplete_Infected_Ammo",Deplete_Infected_Ammo,())
	for Userid in es.getUseridList():
		if es.exists('userid',Userid):
			if es.getplayerteam(Userid) == 2:
				es.setplayerprop(Userid,"CObjectTeleporter.baseclass.m_iUpgradeMetal",0)
				for num in range(4):
					es.setplayerprop(Userid,"CTFPlayer.baseclass.localdata.m_iAmmo.00%s"%num,0)
def check_nade(userid):
    userid = str(userid)
    player = playerlib.getPlayer(userid)
    if not playerlib.getPlayer(userid).isdead:
        if int(es.getplayerprop(userid, "CBasePlayer.localdata.m_iAmmo.011")) != 1:
            gamethread.delayed(0.1, es.server.cmd, 'es_xgive %s weapon_hegrenade' % userid)
        gamethread.cancelDelayed(delayname % player)
        gamethread.delayedname(GOBHE_DELAY, delayname % player, check_nade, player)
Example #41
0
    def addEntity(self, entity, userid):
        """
        Add an entity into the contianer and begin a delay to remove the items

        @PARAM entity - the entity to add
        @PARAM userid - the id of the owner of the smoke grenade
        """
        self.entities[entity] = int(userid)
        gamethread.delayedname(18, "sourcerpg_smokegrenade_entity%s" % entity, self.removeEntity, entity)
def player_disconnect(ev):
    userid = int(ev['userid'])
    if userid in players:
        del players[userid]

    if userid in map(int, muted):
        gamethread.delayedname(int(xa_adminmute_deletetime),
                               'unmute_%s' % ev['networkid'], _unmute,
                               ev['networkid'])
Example #43
0
def load():
    es.set("simple_adverts", info.version)
    es.makepublic("simple_adverts")
    gamethread.delayedname(advert.delay, "advertDelay", advert.endDelay)
    cmdlib.registerServerCommand("dump_colors", advert.dumpColors, "")
    es.msg(
        "#multi",
        "\x07FF8D00[\x0703B0FFSimple Adverts\x07FF8D00] \x0703B0FF%s \x07FF8D00successfully loaded!" % info.version,
    )
def _beacon_loop(userid):
    if userid in playerlib.getUseridList("#alive"):
        es.emitsound('player', userid, xa_adminbeacon_sound, '1.0', '0.7') 
        r, g, b, a = str(xa_adminbeacon_color).split() 
        location = es.getplayerlocation(userid) 
        effectlib.drawCircle(location, 150, steps=50, model="materials/sprites/laser.vmt", seconds=0.2, width=20, endwidth=10, red=r, green=g, blue=b, brightness = a, speed=70) 
        gamethread.delayedname(0.8, 'beacon_%s'%userid, _beacon_loop, userid)
    else:
        players[userid]['beaconed'] = 0 
def player_disconnect(event_var): 
    userid = int(event_var['userid']) 
    if userid in players: 
        del players[userid]

    if userid in mute.muted:
        mute.addSteamidToWaitingList(event_var['networkid']) 
        gamethread.delayedname(int(xa_adminmute_deletetime), 'unmute_%s' % event_var['networkid'], mute.removeSteamidFromWaitingList, event_var['networkid'])
        mute.muted.remove(userid)
Example #46
0
 def endDelay(self):
     if self.mode == 1:
         self.sendAll(self.advertList[self.index])
         self.index += 1
         if self.index == len(self.advertList):
             self.index = 0
     elif self.mode == 2:
         self.sendAll(random.choice(self.advertList))
     gamethread.delayedname(self.delay, "advertDelay", self.endDelay)
Example #47
0
    def auto_respawn(self, message):
        '''Respawns the player in 5 seconds if suicide or team-killed'''

        # Add the player to the respawn list in 3 seconds
        delayedname(4, 'gg_elimination_respawn_%s' % self.userid,
                    respawn_players.append, [self.userid])

        # Send the player a message that they will be respawned soon
        ggPlayer(self.userid).msg(message, prefix=True)
Example #48
0
    def start(self):
        global started, changed
        self.useridList = es.getUseridList()
        
        for userid in self.useridList:
            player = playerlib.getPlayer(userid)
            if player.team < 2 or player.isdead:
                self.useridList.remove(userid)        
        
        if len(self.useridList) < 3:
            es.centermsg("You have to have more than 3 players to play the Assassin mod!")
            return None
        
        if self.useridList:
            ultilib.removeMapObjective()
            
            if self.manualAssassinID:
                self.assassinID = self.manualAssassinID
                self.useridList.remove(self.assassinID)
            else:
                self.assassinID = self._selectOneUserid()
                
            if self.manualVipID:
                self.vipID = self.manualVipID
                self.useridList.remove(self.vipID)
            else:
                self.vipID = self._selectOneUserid()        
            
            self.vip = VIP(self.vipID)
            self.assassin = Assassin(self.assassinID)

            self.guards = {}
            for userid in self.useridList:
                self.guards[userid] = Guard(userid)

            self.vip.prepare(self)
            self.assassin.prepare(self)
            for userid in self.guards.keys():
                self.guards[userid].prepare(self)

            self.aInvisibilityInfo = {"userid": None, "weapon": None, "color": None}
            
            if not changed:

                es.set("mp_limitteams", 20)
                es.set("mp_friendlyfire", 1)
                es.set("mp_autoteambalance", 0)
                es.set("sv_alltalk", 1)
                changed = True
            started = True
            roundtime = int(float(es.ServerVar("mp_roundtime")) * 60.0)
            roundtime += int(float(es.ServerVar("mp_freezetime")) * 60.0)
            gamethread.cancelDelayed("vipwins")
            gamethread.delayedname(roundtime,"vipwins", self.vipWins)
            es.msg("#multi", "#green[UltiAssassin 1.1]#defaultYou're playing the UltiAssassin!")
            
        self.started = True
def load():
    es.set('simple_adverts', info.version)
    es.makepublic('simple_adverts')
    gamethread.delayedname(advert.delay, 'advertDelay', advert.endDelay)
    cmdlib.registerServerCommand('dump_colors', advert.dumpColors, '')
    es.msg(
        '#multi',
        '\x07FF8D00[\x0703B0FFSimple Adverts\x07FF8D00] \x0703B0FF%s \x07FF8D00successfully loaded!'
        % info.version)
def LastMan_Enable(Team):
	global LastMan,ClockTime
	ClockTime = 30
	LastMan = 1
	Teams = {2:"Infected",3:"Survivors"}
	Name = Teams[Team]
	Msg("TimeLimit Enabled! #green%s#default Seconds before #green%s#default lose!"%(30,Name))
	gamethread.delayedname(30,"LastMan",ForceLose,(Team))
	gamethread.delayedname(1,"clock",Clock,())
Example #51
0
    def addEntity(self, entity, userid):
        """
        Add an entity into the contianer and begin a delay to remove the items

        @PARAM entity - the entity to add
        @PARAM userid - the id of the owner of the smoke grenade
        """
        self.entities[entity] = int(userid)
        gamethread.delayedname(18, "sourcerpg_smokegrenade_entity%s" % entity,
                               self.removeEntity, entity)
Example #52
0
def effectLoop(userid, start, red=0, green=255, blue=0):
    """ A method to loop the effects """
    effectlib.drawBox(start,
                      es.getplayerlocation(userid),
                      red=red,
                      green=green,
                      blue=blue,
                      seconds=0.1)
    gamethread.delayedname(0.1, 'surftimer_effects', effectLoop,
                           (userid, start, red, green, blue))
def advertisement(index=0):
    if training_advertise > 0 and ip_trainingserver_enable > 0:
        if len(advertisements):
            es.msg("#multi", advertisements[index])
        index += 1
        
        if index >= len(advertisements):
            index = 0
            
        gamethread.delayedname(training_advert_timer, "advertisements", advertisement, index)
def auto_heal(userid):
    userid = str(userid)
    if not superhero.hasHero(userid,'Wolverine'):
        return
    player = playerlib.getPlayer(userid)
    if not playerlib.getPlayer(userid).isdead:
        health = player.health
        if health < 100:
            player.health = health + 1
        gamethread.delayedname(WOLVERINE_DELAY, delayname % player, auto_heal, player)
Example #55
0
    def auto_respawn(self, message):
        '''Respawns the player in 5 seconds if suicide or team-killed'''

        # Add the player to the respawn list in 3 seconds
        delayedname(4,
            'gg_elimination_respawn_%s' % self.userid,
            respawn_players.append, [self.userid])

        # Send the player a message that they will be respawned soon
        ggPlayer(self.userid).msg(message, prefix=True)
def check_nade(userid):
    userid = str(userid)
    player = playerlib.getPlayer(userid)
    if not playerlib.getPlayer(userid).isdead:
        if int(es.getplayerprop(userid,
                                "CBasePlayer.localdata.m_iAmmo.011")) != 1:
            gamethread.delayed(0.1, es.server.cmd,
                               'es_xgive %s weapon_hegrenade' % userid)
        gamethread.cancelDelayed(delayname % player)
        gamethread.delayedname(GOBHE_DELAY, delayname % player, check_nade,
                               player)
Example #57
0
def load():
    # Register the drop command to prevent it from being used.
    es.addons.registerClientCommandFilter(drop_filter)

    #Start the idle weapon removal loop
    gamethread.delayedname(5, "gg_removeIdleLoop", removeIdleLoop)

    # Make sure that all owned weapons can NOT be picked up
    for userid in es.getUseridList():
        for weapon in spe.getWeaponDict(userid):
            set_spawn_flags(userid, weapon[7:], 2)
Example #58
0
def server_cvar(event_var):
    if event_var[
            'cvarname'] == "mp_timelimit" and startTime is not None and int(
                time_before_end_of_map_vote):
        gamethread.cancelDelayed('votemap_timer')
        delay = es.ServerVar('mp_timelimit') * 60 - int(
            time_before_end_of_map_vote) - (time.time() - startTime)
        if delay:
            gamethread.delayedname(delay, 'votemap_timer', EndOfMapVote)
        else:
            EndOfMapVote()
def _count_down(amount, bombType, userid):
    if amount:
        es.centermsg(amount)
        amount -= 1
        gamethread.delayedname(1, '%s_%s' % (bombType, userid), _count_down,
                               (amount, bombType, userid))
        es.emitsound('player', userid, xa_adminbomb_sound, '1.0', '0.7')
        r, g, b, a = str(xa_adminbomb_beaconcolor).split()
        location = es.getplayerlocation(userid)
        effectlib.drawCircle(location,
                             150,
                             steps=50,
                             model="materials/sprites/laser.vmt",
                             seconds=0.2,
                             width=20,
                             endwidth=10,
                             red=r,
                             green=g,
                             blue=b,
                             brightness=a,
                             speed=70)
    elif bombType == "timebomb":
        for index in es.createentitylist('env_explosion'):
            es.server.cmd('es_xremove %s' % index)
        es.server.cmd('es_xgive %s env_explosion' % userid)
        es.server.cmd('es_xfire %s env_explosion addoutput "imagnitude 300"' %
                      userid)
        es.server.cmd(
            'es_xfire %s env_explosion addoutput "iradiusoverride 600"' %
            userid)
        es.setindexprop(es.ServerVar('eventscripts_lastgive'),
                        'CBaseEntity.m_hOwnerEntity',
                        es.getplayerhandle(userid))
        es.server.cmd('es_xfire %s env_explosion explode' % userid)
        es.server.cmd('es_xfire %s env_explosion kill' % userid)
        players[userid]['timebombed'] = 0
    elif bombType == "freezebomb":
        x, y, z = es.getplayerlocation(userid)
        for player in es.getUseridList():
            xx, yy, zz = es.getplayerlocation(player)
            if (((xx - x)**2 + (yy - y)**2 + (zz - z)**2)**0.5) <= 300:
                player = playerlib.Player(userid)
                gamethread.queue(player.set, ('noclip', 1))
                gamethread.queue(player.set, ('freeze', 1))
        players[userid]['freezebombed'] = 0
    elif bombType == "firebomb":
        x, y, z = es.getplayerlocation(userid)
        for player in es.getUseridList():
            xx, yy, zz = es.getplayerlocation(player)
            if (((xx - x)**2 + (yy - y)**2 + (zz - z)**2)**0.5) <= 300:
                es.server.cmd('es_xfire %s !self ignite' % player)
                gamethread.delayedname(xa_adminfirebomb_duration,
                                       'remove_fire', _extinguish, player)
        players[userid]['firebombed'] = 0
Example #60
0
def load():
    # Register the drop command to prevent it from being used.
    es.addons.registerClientCommandFilter(drop_filter)

    #Start the idle weapon removal loop
    gamethread.delayedname(5, "gg_removeIdleLoop", removeIdleLoop)

    # Make sure that all owned weapons can NOT be picked up
    for userid in es.getUseridList():
        for weapon in spe.getWeaponDict(userid):
            set_spawn_flags(userid, weapon[7:], 2)