def set_model(command):
userid = int(command[1])
model = str(command[2])
if model == '0':
inthandle = _remove_model(userid)
if inthandle is not None:
Player.from_userid(userid).color = Color(255, 255, 255, 255)
return
_remove_model(userid)
if 'models/' not in model:
model = 'models/' + model
player = Player.from_userid(userid)
player.color = Color(255, 255, 255, 0)
model = Model(model)
entity = Entity.create('prop_dynamic_override')
entity.origin = player.origin
entity.parent = player
entity.set_model(model)
entity.spawn()
_game_models[entity.inthandle] = player.userid
entity.add_output('OnUser1 !self,Kill,,0,1')
def disable_damage_protection(player_index):
"""Disable spawn protection for the player."""
with suppress(ValueError):
player = Player(player_index)
player.godmode = False
player.color = WHITE
def player_action(game_event):
"""Called any time a player is hurt or killed."""
# Get the attacker's userid
attacker = game_event['attacker']
# Get the victim's userid
victim = game_event['userid']
# Is this self inflicted?
if attacker in (victim, 0):
return
# Was this a team inflicted?
if Player(index_from_userid(attacker)).team == Player(
index_from_userid(victim)).team:
return
# Is this player_death?
if game_event.name == 'player_death':
# Add a kill to the attacker's stats
most_damage[attacker]['kills'] += 1
# Go no further
return
# This is player_hurt, so add the damage
most_damage[attacker]['damage'] += game_event['dmg_health']
class Client(BaseClient):
def __init__(self, index):
super().__init__()
self.player = Player(index)
self.active_popup = None
def has_permission(self, permission):
return auth_manager.is_player_authorized(self.player.index, permission)
def send_popup(self, popup):
if self.active_popup is not None:
self.active_popup.close(self.player.index)
self.active_popup = popup
popup.send(self.player.index)
def tell(self, message):
chat_message(message, (self.player.index,))
def sync_execution(self, callback, args=(), kwargs=None):
self.player.delay(0, callback, args, kwargs)
@property
def name(self):
return self.player.name
@property
def steamid(self):
return self.player.steamid
def test(command):
player = Player.from_userid(int(command[1]))
target = Player.from_userid(int(command[2]))
if target:
angles = target.get_view_angle()
angle = math.radians(target.get_view_angle()[1]) # (0, angle)
x = -40 * math.cos(angle)
y = -40 * math.sin(angle)
new_position = Vector(target.origin[0] + x, target.origin[1] + y,
target.origin[2])
# Check if there's enough space behind the target.
trace = check_space(new_position, player.mins, player.maxs)
# Did the trace hit something solid?
if trace.did_hit():
# Increase the height(z) of the new position,
# in case the target was on sloped terrain.
new_position[2] += 20
# Is there enough space now?
trace2 = check_space(new_position, player.mins, player.maxs)
if trace2.did_hit():
# There's still something solid behind the target.
# Could be a wall or some other object.
return
# teleport(position, rotation, velocity)
player.teleport(new_position, None, None)
player.set_view_angle(angles)
def pre_on_take_damage(args):
# Get the victim
victim = make_object(Player, args[0])
# Get TakeDamageInfo object
info = make_object(TakeDamageInfo, args[1])
# Was it a self-inflicted damage?
if info.attacker == victim.index:
return
# Check if attacker is a player
entity = Entity(info.attacker)
if not entity.is_player():
return
# Get the attacker
attacker = Player(info.attacker)
# Do our thing
if attacker.is_bot() and not victim.is_bot():
info.damage *= caches_from[victim.index].multiplier
elif not attacker.is_bot() and victim.is_bot():
info.damage *= caches_to[attacker.index].multiplier
class BalancedPlayer:
def __init__(self, index):
self.player = Player(index)
def get_player_class(self):
return self.player.get_property_uchar("m_PlayerClass.m_iClass")
def set_player_class(self, player_class):
self.player.set_property_uchar("m_PlayerClass.m_iClass", player_class)
self.player.set_property_uchar("m_Shared.m_iDesiredPlayerClass",
player_class)
player_class = property(get_player_class, set_player_class)
def force_class_change(self, player_class):
self.player_class = player_class
if self.player.team in VGUI_PANEL_NAMES:
VGUIMenu(VGUI_PANEL_NAMES[self.player.team]).send(
self.player.index)
def is_authorized_to_bypass(self, player_class):
permission = (BYPASS_PERMISSION_BASE + '.' +
CLASS_NAME_BY_ID[player_class])
return auth_manager.is_player_authorized(self.player.index, permission)
def player_action(event_data):
if event_data['attacker'] in (event_data['userid'], 0):
return
attacker = Player.from_userid(event_data['attacker'])
victim = Player.from_userid(event_data['userid'])
if attacker.team == victim.team or attacker.steamid == 'BOT':
return
# Sometimes dmg_health key not exist
try:
damage = str(event_data['dmg_health'])
armor = str(event_data['dmg_armor'])
hitgroup = g_hitgroups_name[event_data['hitgroup']][
attacker.language[:2]]
except KeyError:
return
info = ('full' if g_configs['show_hit_member'].get_int() == 1
and g_configs['show_armor_hit'].get_int() == 1 else
('hitgroup' if g_configs['show_hit_member'].get_int() == 1 else
('armor'
if g_configs['show_armor_hit'].get_int() == 1 else 'damage')))
message = g_damage_message[g_configs['display_type'].get_int()][info]
# Display message
g_show_damage_type[g_configs['display_type'].get_int()](message).send(
attacker.index, hitgroup=hitgroup, damage=damage, armor=armor)
def _give(command):
userid = int(command[1])
weapon = command[2]
if "weapon_" not in weapon:
weapon = "weapon_" + command[2]
if exists(userid):
Player.from_userid(userid).give_named_item(weapon)
def _drug(command):
userid = int(command[1])
delay = float(command[2])
if exists(userid):
Player.from_userid(userid).client_command(
'r_screenoverlay effects/tp_eyefx/tp_eyefx')
Delay(delay, remove_drug, (userid, ))
def callback(popup, index, option):
player_from = Player(index)
try:
player_to = Player.from_userid(option.value)
except:
SAY_PLAYER_DISCONNECT.send(index)
else:
teleport_player_to_player(player_from, player_to)
def _spawn(command):
if len(command) >= 2:
userid = int(command[1])
if exists(userid):
if len(command) == 3:
force = int(command[2])
else:
force = 0
Player.from_userid(userid).spawn(force)
def pushed(command):
userid = int(command[1])
x_force = float(command[2])
y_force = float(command[3])
z_force = float(command[4])
if exists(userid):
vec = Vector(x_force, y_force, z_force)
player = Player(index_from_userid(userid))
player.set_property_vector("m_vecBaseVelocity", vec)
def respawn_bots(game_event):
userid = game_event.get_int("userid")
index = index_from_userid(userid)
player = Player(index)
playerinfo = playerinfo_from_index(index)
if playerinfo.is_fake_client():
SayText2("Respawning {0}".format(player.name)).send()
Delay(2, player=Player(index))
player.respawn()
def get_wall_between(command):
var = str(command[1])
user_one = int(command[2])
user_two = int(command[3])
origin_vector = Player.from_userid(user_one).origin
direction_vector = Player.from_userid(user_two).origin
trace = GameTrace()
engine_trace.trace_ray(Ray(origin_vector, direction_vector),
ContentMasks.ALL, None, trace)
ConVar(var).set_int(trace.did_hit_world())
def player_jump(ev):
userid = ev['userid']
player = Player(index_from_userid(userid))
value = wcsgroup.getUser(userid, 'longjump')
if value is not None:
value = float(value)
if value > 1.0:
vec = player.get_property_vector("m_vecVelocity")
vec_new = Vector(vec[0] * value, vec[1] * value, vec[2])
player.set_property_vector("m_vecBaseVelocity", vec_new)
def _resetscrore_say_command(command, index, team_only=None):
player = Player(index)
if player.kills != 0 or player.deaths != 0:
player.kills = 0
player.deaths = 0
SayText2(strings['Resetscore']).send(player.index)
else:
SayText2(strings['Already']).send(player.index)
return CommandReturn.BLOCK
def listener_on_client_active(index):
player = Player(index)
new_name = filter_text(player.name)
if new_name is None:
return
global name_change
name_change = True
player.name = CENSORED_NAME.format(userid=player.userid)
name_change = False
def player_death(ev):
atk_play = Player.from_userid(ev['attacker'])
vic_play = Player.from_userid(ev['userid'])
if vic_play.userid == atk_play.userid or not atk_play.userid or not teambounty and vic_play.team == atk_play.team:
return
kills = int(wcsgroup.getUser(atk_play.userid, "wcs_bounty_kills")) + 1
wcsgroup.setUser(atk_play.userid, "wcs_bounty_kills", kills)
bounty = int(wcsgroup.getUser(atk_play.userid, "wcs_bounty_bounty"))
if kills == int(streak):
wcsgroup.setUser(atk_play.userid, "wcs_bounty_bounty", int(xpstart))
if int(telltype):
wcs.wcs.tell(
atk_play.userid,
"\x04[WCS]\x05 You started a bounty of \x04%s\x05." % xpstart)
else:
for player in PlayerIter():
wcs.wcs.tell(
player.userid,
"\x04[WCS]\x05 Player \x04%s \x05has started a bounty of \x04%s\x05."
% (atk_play.name, xpstart))
elif kills > int(streak):
bounty += int(xpincrease)
wcsgroup.setUser(atk_play.userid, "wcs_bounty_bounty", bounty)
if int(telltype):
wcs.wcs.tell(
atk_play.userid,
"\x04[WCS]\x05 Your bounty increased to \x04%s\x05." % bounty)
else:
for player in PlayerIter():
wcs.wcs.tell(
player.userid,
"\x04[WCS]\x05Player \x04%s \x05bounty has increased to \x04%s\x05."
% (atk_play.name, bounty))
bounty = int(wcsgroup.getUser(ev["userid"], "wcs_bounty_bounty"))
kills = int(wcsgroup.getUser(ev["userid"], "wcs_bounty_kills"))
if bounty and kills:
wcs.wcs.getPlayer(atk_play.userid).giveXp(bounty, "bounty experience")
if int(telltype):
wcs.wcs.tell(
atk_play.userid,
"\x04[WCS]\x05 You stole \x05%s bounty of \x04%s\x05." %
(vic_play.name, bounty))
wcs.wcs.tell(
vic_play.userid,
"\x04[WCS]\x05 \x04%s \x05stole your bounty of \x04%s\x05." %
(atk_play.name, bounty))
else:
for player in PlayerIter():
wcs.wcs.tell(
player.userid,
"\x04[WCS]\x05 Player \x04%s\x05 has stolen \x04%s\x05 bounty of \x04%s\x05."
% (atk_play.name, vic_play.name, bounty))
wcsgroup.setUser(vic_play.userid, "wcs_bounty_kills", 0)
wcsgroup.setUser(vic_play.userid, "wcs_bounty_bounty", 0)
def callback(popup, index, option):
userid_from, userid_to = option.value, selected_p2p_first.pop(index)
try:
player_from = Player.from_userid(userid_from)
player_to = Player.from_userid(userid_to)
except ValueError:
SAY_PLAYER_DISCONNECT.send(index)
else:
teleport_player_to_player(player_from, player_to)
def _resetscrore_say_command(command, index, team_only=None):
player = Player(index)
if player.kills != 0 or player.deaths != 0:
player.kills = 0
player.deaths = 0
RESETSCORE_MSG.send(player.index)
else:
ALREADY_MSG.send(player.index)
if command[0] in ini_config['private_commands'] or team_only is None:
return CommandReturn.BLOCK
def get_colors(command):
userid = int(command[1])
r = command[2]
g = command[3]
b = command[4]
a = command[5]
if exists(userid):
ConVar(r).set_int(Player.from_userid(userid).color[0])
ConVar(g).set_int(Player.from_userid(userid).color[1])
ConVar(b).set_int(Player.from_userid(userid).color[2])
ConVar(a).set_int(Player.from_userid(userid).color[3])
def viewcoord(command):
userid = int(command[1])
xvar = str(command[2])
yvar = str(command[3])
zvar = str(command[4])
if exists(userid):
player = Player(index_from_userid(userid))
view_vec = player.get_view_coordinates()
ConVar(xvar).set_float(view_vec[0])
ConVar(yvar).set_float(view_vec[1])
ConVar(zvar).set_float(view_vec[2])
def remove(self):
"""Remove the weapon."""
# Avoid a cyclic import
from players.entity import Player
owner = self.owner
if owner is not None and owner.is_player():
player = Player(owner.index)
player.drop_weapon(self)
super().remove()
def remove(self):
"""Remove the weapon."""
# Avoid a cyclic import
from players.entity import Player
owner = self.owner
if owner is not None and owner.is_player():
player = Player(owner.index)
player.drop_weapon(self)
super().remove()
def wcs_steal(command):
userid = int(command[1])
victim_uid = int(command[2])
amount = int(command[3])
player = Player.from_userid(userid)
victim = Player.from_userid(victim_uid)
if victim.cash - amount < 0:
player.cash += victim.cash
victim.cash = 0
else:
player.cash += amount
victim.cash -= amount
def pre_hurt(ev):
victim = Player.from_userid(int(ev['userid']))
if ev['attacker'] != 0:
attacker = Player.from_userid(int(ev['attacker']))
weapon = ev['weapon']
damage = int(ev['dmg_health'])
absorb = wcsgroup.getUser(victim.userid, 'absorb')
if absorb != None:
absorb = float(absorb)
if absorb > 0:
absorb_dmg = damage * absorb
if int(absorb_dmg) > 0:
victim.health += int(absorb_dmg)
wcs.wcs.tell(
victim.userid,
'\x04[WCS] \x05You absorbed %s damage!' %
int(absorb_dmg))
return
resist = wcsgroup.getUser(victim.userid, 'resist_' + weapon)
if resist != None:
resist = float(resist)
if resist > 0:
resist_dmg = damage * resist
if int(resist_dmg) > 0:
victim.health += int(resist_dmg)
wcs.wcs.tell(
victim.userid,
'\x04[WCS] \x05You resisted %s damage!' %
int(absorb_dmg))
evasion = wcsgroup.getUser(victim.userid, 'evasion')
evasion_chance = wcsgroup.getUser(victim.userid, 'evasion_chance')
if evasion != None:
evasion = int(evasion)
if evasion > 0:
if randint(0, 100) <= int(evasion_chance):
victim.health += damage
wcs.wcs.tell(
victim.userid,
'\x04[WCS] \x05You evaded %s damage!' % damage)
else:
falldamage = wcsgroup.getUser(victim.userid, 'falldamage')
if falldamage != None:
falldamage = float(falldamage)
if falldamage != 1.0:
damage = int(ev['dmg_health'])
falldamage_dmg = damage - (damage * falldamage)
if falldamage_dmg > 0:
victim.health += int(falldamage_dmg)
wcs.wcs.tell(
victim.userid,
'\x04[WCS] \x05You blocked %s falldamage!' %
int(falldamage_dmg))
def doCommand(userid):
player_entity = Player(index_from_userid(userid))
if userid not in resetskills:
resetskills[userid] = 0
if resetskills[userid] == 1 or player_entity.dead:
player_entity.client_command("kill", True)
race = wcs.wcs.wcsplayers[userid].currace
raceinfo = wcs.wcs.racedb.getRace(race)
level = wcs.wcs.wcsplayers[userid].all_races[race]['level']
unused = wcs.wcs.wcsplayers[userid].all_races[race]['unused']
nol = raceinfo['numberoflevels']
nos = int(raceinfo['numberofskills'])
if ('|') in nol:
nol = nol.split('|')
if len(nol) == 1:
maxunused = int(nol) * nos
else:
maxunused = 0
for x in nol:
maxunused += int(x)
v = 0
for x in wcs.wcs.wcsplayers[userid].all_races[race]['skills'].split(
'|'):
v += int(x)
unused += v
if unused > maxunused:
unused = maxunused
skills = []
for x in range(1, 10):
skill = 'skill' + str(x)
if skill in wcs.wcs.racedb.races[race]:
skills.append('0')
skillst = '|'.join(skills)
wcs.wcs.wcsplayers[userid].all_races[race]['unused'] = unused
wcs.wcs.wcsplayers[userid].skills = skillst
wcs.wcs.wcsplayers[userid].all_races[race]['skills'] = skillst
wcs.wcs.wcsplayers[userid].save()
wcs.wcs.tell(
userid,
"\x04[WCS] \x05Your skills has been reset. Type \x04'spendskills' \x05to spend your \x04%s \x05unused skill points."
% wcs.wcs.wcsplayers[userid].all_races[race]['unused'])
else:
resetskills[userid] = 1
wcs.wcs.tell(
userid,
'\x04[WCS] \x05Type \x04resetskills \x05again to continue. You will \x04die!'
)
Delay(3.0, resetskills_dict, (userid, ))
def _pre_in_same_team(stack_data):
"""Always return False for bots from InSameTeam."""
other = stack_data[1]
if stack_data[0] == other:
return
entity = make_object(Entity, other)
if entity.classname != 'player':
return
player = Player(entity.index)
if player.is_fake_client():
return False
def __init__(self, index, files, callback, time_multiplier=1.5, size=0):
"""Initialize the send_files.
:param int index:
Index of the receiver.
:param tuple files:
The files to be sent.
:param callback:
A callable object to be called after all transfers are complete.
:param float time_multiplier:
The multiplier for the wait time to stop the downloader.
:param int size:
Total compressed file size to skip compression.
"""
global transfer_id
self.index = index
self.files = files
self.callback = callback
self.size = size
self.file = self.files[-1].encode("utf-8")
if not self.size:
compress = net_compresspackets.get_bool()
for file in files:
path = Path(GAME_PATH / file)
self.size += compress_file(
path) if compress else path.stat().st_size
self.estimated_time = (self.size / 256) * server.tick_interval
self.transfer_time = self.estimated_time
self.time_limit = self.estimated_time * time_multiplier
net_channel = Player(index).client.net_channel
for file in self.files:
if not net_channel.send_file(file, transfer_id):
self.delay = Delay(0.1,
self.transfer_error,
cancel_on_level_end=True)
break
transfer_id += 1
else:
self.net_channel = ctypes.c_void_p(net_channel._ptr().address)
self.delay = Delay(self.estimated_time,
self.transfer_end,
cancel_on_level_end=True)
self._send_files[id(self)] = self
def info_menu(self, userids = []):
try:
info_menu = SimpleMenu(build_callback=self.callback_info_menu)
list = []
if type(userids) is not list:
player = Player.from_userid(userids)
list = [player.index]
else:
for item in userids:
player = Player.from_userid(item)
list.append(player.index)
info_menu.send(list)
except:
msg('ERROR', 'could not send info menu to one or more players')
def __init__(self, index, disconnected):
self._disconnected = disconnected
player = Player(index)
self.userid = player.userid
self.steamid = player.steamid
self.name = player.name
self.address = player.address
# Add some stuff to be able to be filtered by filters.players...
self._fake_client = player.is_fake_client()
self._hltv = player.is_hltv()
self.dead = player.dead
self.team = player.team
def player_hurt(event):
victim = event.get_int('userid')
attacker = event.get_int('attacker')
weapon = event.get_string('weapon')
if victim:
vic_entity = Player(index_from_userid(victim))
if attacker:
atk_entity = Player(index_from_userid(attacker))
if attacker and victim and not weapon.lower() in ('point_hurt'):
if not victim == attacker:
if not atk_entity.team == vic_entity.team:
checkEvent(victim, 'player_victim')
checkEvent(attacker, 'player_attacker')
checkEvent(victim, 'player_hurt')
def wcs_leech(command):
userid = int(command[1])
victim_uid = int(command[2])
amount = int(command[3])
player = Player.from_userid(userid)
victim = Player.from_userid(victim_uid)
if victim.health - amount < 0:
player.health += victim.health
queue_command_string("es wcs_dealdamage %s %s %s" %
(victim_uid, userid, amount))
else:
player.health += amount
queue_command_string("es wcs_dealdamage %s %s %s" %
(victim_uid, userid, amount))
print(victim.armor)
def _player_death(game_event):
# Dead Strip
remove_idle_weapons(status=GunGameMatchStatus.WARMUP)
# Dissolver
victim = game_event['userid']
try:
inthandle = Player.from_userid(victim).ragdoll
except ValueError:
return
if inthandle == INVALID_ENTITY_INTHANDLE:
return
entity = Entity(index_from_inthandle(inthandle))
entity.target_name = f'ragdoll_{victim}'
dissolver_entity = Entity.find_or_create('env_entity_dissolver')
dissolver_entity.magnitude = 2
dissolver_entity.dissolve_type = 0
dissolver_entity.dissolve(f'ragdoll_{victim}')
# DeathMatch
Delay(
delay=2,
callback=_respawn_player,
args=(victim,),
cancel_on_level_end=True,
)
def convert_userid_to_player(userid):
userid = valid_userid(userid)
if userid is None:
return None
return Player.from_userid(userid)
def sp_ignite(source, command):
if command.get_arg_count() == 1:
source.message("c=(white)[c=(purple)SPc=(white)] Usage: "
"$c=(purple)sp_unfreeze $c=(white)<name|#userid|@filter>")
return CommandReturn.BLOCK
targets = target_filter(command[1], source.index)
if len(targets) == 0:
source.message("c=(white)[c=(purple)SPc=(white)] No Targets found.")
else:
for target in targets:
player = Player(target)
if player.move_type == MoveType.NONE:
player.move_type = MoveType.WALK
message_client(player.index, "You have been unfrozen.")
source.message("c=(white)[c=(purple)SPc=(white)] Froze " + str(len(targets)) + " players.")
return CommandReturn.BLOCK
def _print_all_registered_cfg_scripts(userid=0):
import es
from .logic import cfg_scripts
if userid > 0:
try:
player = Player.from_userid(userid)
except ValueError:
return
else:
player = None
header = 'EventScripts Script packs:'
sep = '------------------------------------------'
if player is not None:
player.client_command('echo {}'.format(header))
player.client_command('echo {}'.format(sep))
else:
es.dbgmsg(0, header)
es.dbgmsg(0, sep)
for index, (scriptpack, enabled) in enumerate(cfg_scripts.items()):
msg = '{:02d} {} "{}"'.format(index, '[on]' if enabled else '[off]', scriptpack)
if player is not None:
player.client_command('echo {}'.format(msg))
else:
es.dbgmsg(0, msg)
if player is not None:
player.client_command('echo {}'.format(sep))
else:
es.dbgmsg(0, sep)
def player_check_rank(self, userid):
try:
player = Player.from_userid(userid)
if not player.address or player.steamid == 'BOT':
return
# get player team
pteam = self.get_player_team(userid)
pdata = self.get_player_data(userid)
if player.steamid in self.players:
new_rank = int(pdata['rank'][str(pdata['class'])]) + 1
if new_rank in self.ranks:
if player.cash >= int(self.ranks[new_rank]['points_needed']):
player.cash = player.cash - int(self.ranks[new_rank]['points_needed'])
pdata['rank'][str(pdata['class'])] = int(new_rank)
self.update_player_data(userid, {
'cash': player.cash,
'rank': json.dumps(pdata['rank'])
})
SayText2('New Rank: {} ({})'.format(str(new_rank), self.classes[pdata['class']]['name'])).send(player.index)
for item in self.weapons:
if int(self.weapons[item]['rank']) == int(new_rank) and pteam == self.weapons[item]['team'] and int(pdata['class']) == self.weapons[item]['class']:
SayText2('New Weapon: {}'.format(self.weapons[item]['name'])).send(player.index)
# ability to change weapon on next spawn because of a new weapon
self.update_player_data(userid, {
'change_loadout1': 1
})
self.player_check_rank(userid)
#TODO: notification for new rank (e.G. Sound?)
except:
msg('ERROR', 'could not check player rank')
self.player_data_lock.release()
def update_player_data(self, userid, data):
try:
player = Player.from_userid(userid)
if not player.address or player.steamid == 'BOT':
return
tmp_keys = ''
tmp_values = []
lock = False
self.player_data_lock.acquire()
lock = True
for item in data:
tmp_keys = tmp_keys + ', ' + item + ' = %s'
tmp_values.append(data[item])
if item == 'rank':
data[item] = json.loads(data[item])
self.players[player.steamid][item] = data[item]
self.player_data_lock.release()
lock = False
tmp_values.append(player.steamid)
sql = "UPDATE `players` SET " + tmp_keys[1:] + " WHERE steamid = %s"
self.db.query(sql, tmp_values, wait=False)
except:
if lock:
self.player_data_lock.release()
msg('ERROR', 'could not update player data')
def player_give_weapon(self, userid):
try:
player = Player.from_userid(userid)
if not player.address or player.steamid == 'BOT':
return
if player.team not in (2,3):
return
# get player team
pteam = self.get_player_team(userid)
pdata = self.get_player_data(userid)
for index in player.weapon_indexes():
weapon = Entity(index)
player.drop_weapon(weapon.pointer, player.origin, player.origin)
weapon.remove()
# get new weapons
player.give_named_item('weapon_knife', 0, None, True)
if pteam in pdata['loadout1']:
if str(pdata['class']) in pdata['loadout1'][pteam]:
if 'primary' in pdata['loadout1'][pteam][str(pdata['class'])]:
player.give_named_item(pdata['loadout1'][pteam][str(pdata['class'])]['primary'], 0, None, True)
if 'secondary' in pdata['loadout1'][pteam][str(pdata['class'])]:
player.give_named_item(pdata['loadout1'][pteam][str(pdata['class'])]['secondary'], 0, None, True)
for item in self.weapons:
if int(self.weapons[item]['rank']) <= int(pdata['rank'][str(pdata['class'])]) and int(self.weapons[item]['type']) == 3 and pteam == self.weapons[item]['team'] and int(pdata['class']) == self.weapons[item]['class']:
for x in range(0, self.weapons[item]['amount']):
Delay(0, player.give_named_item, self.weapons[item]['slug'], 0, None, True)
# give kevlar (and helmet on lvl 20 or above)
if int(pdata['rank'][str(pdata['class'])]) < 20:
player.give_named_item('item_kevlar', 0, None, True)
else:
player.give_named_item('item_assaultsuit', 0, None, True)
# ready for spawn let other plugins know
self.callbacks.execute('player_is_spawned', player.userid)
except:
msg('INFO', 'could not give weapon to player')
def get_player_data(self, userid):
try:
player = Player.from_userid(userid)
if not player.address or player.steamid == 'BOT':
return
sql = "SELECT * FROM players WHERE steamid = %s LIMIT 0,1"
row = self.db.query(sql, (player.steamid,), fetch_all = False)
if row:
player.cash = row['cash']
if row['rank']:
row['rank'] = json.loads(row['rank'])
if row['skin']:
row['skin'] = json.loads(row['skin'])
if row['loadout1']:
row['loadout1'] = json.loads(row['loadout1'])
else:
# if user does not exist in our database
self.insert_player_data(userid)
row = self.get_player_data(userid)
self.player_data_lock.acquire()
self.players[player.steamid] = row
self.player_data_lock.release()
return row
except:
msg('ERROR','could not get player data')
def spawnprotection_end(self, userid):
try:
player = Player.from_userid(userid)
player.set_godmode(False)
self.msg_spawnprotection.send(player.index)
except:
msg('ERROR', 'could not disable godmode for player')
def execute(self, client, left_player):
if left_player.is_fake_client() or left_player.is_hltv():
client.tell(plugin_strings['error bot_cannot_ban'])
return
ip_address = extract_ip_address(left_player.address)
if banned_ip_address_manager.is_banned(ip_address):
client.tell(plugin_strings['error already_ban_in_effect'])
return
try:
player = Player.from_userid(left_player.userid)
except (OverflowError, ValueError):
pass
else:
language = get_client_language(player.index)
# Disconnect the player
player.kick(
plugin_strings['default_ban_reason'].get_string(language))
duration = int(plugin_config['settings']['default_ban_time_seconds'])
GameThread(
target=banned_ip_address_manager.save_ban_to_database,
args=(client.steamid, ip_address, left_player.name, duration)
).start()
for ws_ban_ip_address_page in _ws_ban_ip_address_pages:
ws_ban_ip_address_page.send_remove_id(left_player)
log_admin_action(plugin_strings['message banned'].tokenized(
admin_name=client.name,
player_name=left_player.name,
))
def sp_ignite(source, command):
if command.get_arg_count() == 1:
source.message("c=(white)[c=(purple)SPc=(white)] Usage: "
"c=(purple)sp_ignite $c=(white)<name|#userid|@filter> [time: 0]")
return CommandReturn.BLOCK
targets = target_filter(command[1], source.index)
time = int(command[2]) if command.get_arg_count() > 2 else 0
if len(targets) == 0:
source.message("c=(white)[c=(purple)SPc=(white)] No Targets found.")
else:
for target in targets:
player = Player(target)
player.ignite_lifetime(time) if time > 0 else player.ignite()
message_client(player.index, "You have been set on fire for " + str(time) + " seconds.")
source.message("c=(white)[c=(purple)SPc=(white)] Set " + str(len(targets)) + " players on fire.")
return CommandReturn.BLOCK
def player_set_model(self, userid, modelid):
try:
player = Player.from_userid(userid)
if int(modelid) in self.skins:
player.model = self.skins[int(modelid)]['model']
except:
msg('ERROR', 'could not set player model')
def _player_say(self, userid, text):
try:
player = Player.from_userid(userid)
if not player.address or player.steamid == 'BOT':
return
self.player_data_lock.acquire()
if player.steamid not in self.players:
self.player_data_lock.release()
return
self.player_data_lock.release()
# change weapons
change_weapons = ['!weapon','!weapons','!changeweapon','!changeweapons','!loadout','!changeloadout','!w','!cw']
if text in change_weapons:
self.update_player_data(userid, {
'change_loadout1': 1
})
SayText2('You can change your loadout on next respawn!').send(player.index)
# change class
change_class = ['!class','!selectclass','!changeclass','!c','!sc']
if text in change_class:
self.update_player_data(userid, {
'change_class': 1
})
SayText2('You can change your class on next respawn!').send(player.index)
# change skin
change_skin = ['!skin','!selectskin','!changeskin','!s']
if text in change_skin:
self.update_player_data(userid, {
'change_skin': 1
})
SayText2('You can change your skin on next respawn!').send(player.index)
except:
msg('ERROR', 'could not work with player say event')
def _remove_radar_from_player(userid):
"""Remove the player's radar."""
with suppress(KeyError):
del _flashed_players[userid]
player = Player.from_userid(userid)
player.flash_alpha = 0
player.flash_duration = time()
def dissolve_ragdoll(userid, current_type):
"""Dissolve/remove the player's ragdoll."""
# Get the ragdoll entity
try:
inthandle = Player.from_userid(userid).ragdoll
except ValueError:
return
if inthandle == INVALID_ENTITY_INTHANDLE:
return
entity = Entity(index_from_inthandle(inthandle))
# Should the ragdoll just be removed?
if current_type == _num_dissolve_types + 2:
entity.remove()
return
# Set the target name for the player's ragdoll
entity.target_name = 'ragdoll_{userid}'.format(userid=userid)
# Get the dissolver entity
dissolver_entity = Entity.find_or_create('env_entity_dissolver')
# Should a random dissolve type be chosen?
if current_type == _num_dissolve_types + 1:
current_type = randrange(_num_dissolve_types)
# Set the magnitude
dissolver_entity.magnitude = magnitude.get_int()
# Set the dissolve type
dissolver_entity.dissolve_type = current_type
# Dissolve the ragdoll
dissolver_entity.dissolve('ragdoll_{userid}'.format(userid=userid))
def menu_select_class(self, userid):
player = Player.from_userid(userid)
if not player.address or player.steamid == 'BOT':
return
pdata = self.get_player_data(userid)
menu = ExtendedPagedMenu(title='Select Class', select_callback=self.menu_select_class_callback, on_close_menu=self.menu_select_class_close_callback)
for item in self.classes:
menu.append(PagedOption('{}, Rank: {}'.format(self.classes[item]['name'], pdata['rank'][str(item)]), str(item), selectable=True))
menu.send(player.index)
def on_player_spawn(game_event):
# We refresh HLTV index every time in case somebody kicks that poor guy
player = Player.from_userid(game_event['userid'])
if not player.is_hltv():
return
global hltv_index
hltv_index = player.index
def on_saycommand_admin(command_info):
"""Send the Admin menu to the player."""
# Get a PlayerEntity instance for the player
player = Player(command_info.index)
# Protect the player indefinitely
enable_damage_protection(player)
# Remove all the player's weapons
for weapon in player.weapons():
weapon.remove()
# Send the Admin menu to the player
admin_menu.users.append(player.userid)
admin_menu.send(command_info.index)
# Block the text from appearing in the chat window
return False
def sp_ignite(source, command):
if command.get_arg_count() == 1:
source.message("c=(white)[c=(purple)SPc=(white)] Usage: "
"$c=(purple)sp_freeze $c=(white)<name|#userid|@filter> [time: 0]")
return CommandReturn.BLOCK
targets = target_filter(command[1], source.index)
time = int(command[2]) if command.get_arg_count() > 2 else 0
if len(targets) == 0:
source.message("c=(white)[c=(purple)SPc=(white)] No Targets found.")
else:
for target in targets:
player = Player(target)
player.move_type = MoveType.NONE
if time != 0:
Delay(time, unfreeze, player)
message_client(player.index, "You have been frozen for " + str(time) + " seconds.")
message_client(player.index, "You have been frozen.")
source.message("c=(white)[c=(purple)SPc=(white)] Froze " + str(len(targets)) + " players.")
return CommandReturn.BLOCK
def on_player_death(game_event):
"""Respawn the victim and handle attacker rewards."""
# Respawn the victim
victim = Player.from_userid(game_event['userid'])
victim.delay(int(cvar_respawn_delay), victim.spawn, (True, ))
# Handle attacker rewards, if the attacker and the victim are not on the same team
with suppress(ValueError):
attacker = Player.from_userid(game_event['attacker'])
if attacker.team != victim.team:
# Handle attacker attribute rewards
for attr, values in player_attribute_rewards.items():
handle_player_reward(attacker, attr, abs(int(values['value'])), abs(int(values.get('max_value', 0))))
# Handle weapon rewards
for basename, values in weapon_rewards.items():
handle_weapon_reward(attacker, values['type'], int(values['multiplier']), basename)
def send(self, *player_indexes, **tokens):
"""Send the Dialog message to the appropriate recipients.
:param player_indexes: Values can be a player index, multiple player
indexes (star args),
a :class:`filters.players.PlayerIter` instance,
or a :class:`filters.recipients.RecipientFilter` instance.
:param tokens: Keyword arguments used to replace values in messages.
"""
# Get a recipient filter of the given users
recipients = RecipientFilter(*player_indexes)
# Get the KeyValues instance
keyvalues = KeyValues(self.message_type.name.lower())
# Set the time for the message to display
keyvalues.set_int('time', self.time)
# Loop through all recipients
for index in recipients:
# Get a Player instance for the current player
player = Player(index)
# Is the player not human?
if player.is_fake_client():
continue
# Get the level for the message
level = self._get_player_level(player.userid)
# Set the level for the player
keyvalues.set_int('level', level)
# Set the title (value should be server IP address)
keyvalues.set_string(
'title', self._get_text(self.title, player, **tokens))
# Set any remaining keyvalues
self._set_keyvalues(keyvalues, player, **tokens)
# Send the message
create_message(player.edict, self.message_type, keyvalues)
def on_player_spawn(ev):
player = Player.from_userid(ev['userid'])
for ws_slay_page in _ws_slay_pages:
if not ws_slay_page.filter(player):
continue
ws_slay_page.send_add_player(player)
for ws_resurrect_page in _ws_resurrect_pages:
ws_resurrect_page.send_remove_id(player)
def _player_blind(game_event):
"""Add the player to a dictionary of flashed players to not remove HUD."""
userid = game_event['userid']
player = Player.from_userid(userid)
_cancel_delay(userid)
_flashed_players[userid] = Delay(
delay=player.flash_duration,
callback=_remove_radar_from_player,
args=(userid,),
cancel_on_level_end=True,
)
def get_player_team(self, userid):
try:
player = Player.from_userid(userid)
if player.team == 3:
return 'CT'
elif player.team == 2:
return 'T'
else:
return 'none'
except:
msg('ERROR', 'could not get player team')
def player_death(self, userid):
try:
player = Player.from_userid(userid)
if player.team not in (2, 3):
return
if player.team == 3:
self.tickets['ct'] = int(self.tickets['ct']) - 1
else:
self.tickets['t'] = int(self.tickets['t']) - 1
except:
msg('ERROR', 'could not remove a ticket on player_death')
