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 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 _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 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 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 _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 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 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 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 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 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 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 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 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 convert_userid_identifier_to_players(filter_):
# TODO: Do not use es.getuserid
userid = es.getuserid(filter_)
try:
index_from_userid(userid)
except ValueError:
players = set()
append = True
for x in filter_:
if x == '#':
append = True
elif x == '!':
append = False
else:
found_players = PlayerIter(_team_convert.get(x, x))
if append:
players.update(found_players)
else:
players = players.difference(found_players)
yield from players
else:
yield from (Player.from_userid(userid), )
def _format_message(userid, name, args):
if _strings is None:
return tuple(), None
text = _strings.get(name)
if text is None:
return tuple(), None
if userid.isdigit():
try:
players = (Player.from_userid(int(userid)), )
except ValueError:
return tuple(), None
else:
players = convert_identifier_to_players(userid)
if args:
tokens = {}
for i in range(0, len(args), 2):
tokens[args[i]] = args[i + 1]
for language, message in text.items():
text[language] = Template(message).substitute(tokens)
return players, text
def convert_userid_to_player(userid):
userid = valid_userid(userid)
if userid is None:
return None
return Player.from_userid(userid)
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 _remove_overlay(userid):
try:
player = Player.from_userid(userid)
except ValueError:
pass
else:
player.client_command('r_screenoverlay 0')
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 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 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 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 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_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 send_message(self):
"""Send messages to players depending on their individual setting."""
# Was any damage done this round?
if not self:
return
# Sort the players by kills/damage
sorted_players = sorted(
self,
key=lambda userid: (self[userid]['kills'], self[userid]['damage']),
reverse=True)
# Get the userid of the most destructive player
top_userid = sorted_players[0]
# Set the tokens for the message
tokens = {
'name': Player.from_userid(top_userid).name,
'kills': self[top_userid]['kills'],
'damage': self[top_userid]['damage']
}
# Loop through all human player indexes
for player in _human_players:
# Get the current player's setting
places = int(self.location_setting.get_setting(player.index))
# Loop through the message types
for location, message in most_damage_messages.items():
# Does the current message need to be sent?
if places & location:
message.send(player.index, **tokens)
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 __init__(self, userid):
self.userid = int(userid)
self.user_id = -1
self.steamid = Player.from_userid(self.userid).uniqueid
bank_player_loaded[self.userid] = False
self.levels = 0
Thread(target=self._load_from_database).start()
def _regeneration_repeat(userid, value, maxhealth, radius):
try:
player = Player.from_userid(userid)
except ValueError:
repeats = _repeats.pop(userid, [])
for repeat in repeats:
if repeat.status == RepeatStatus.RUNNING:
repeat.stop()
else:
if player.team not in (2, 3):
repeats = _repeats.pop(userid, [])
for repeat in repeats:
if repeat.status == RepeatStatus.RUNNING:
repeat.stop()
return
if player.health < maxhealth:
player.health = min(player.health + value, maxhealth)
if radius:
origin = player.origin
for target in PlayerIter(['alive', 't' if player.team == 2 else 'ct']):
if not target == player:
if target.origin.get_distance(origin) <= radius:
if target.health < maxhealth:
target.health = min(target.health + value, maxhealth)
def drunk(userid, time=0, value=155):
userid = int(userid)
player = Player.from_userid(userid)
player.set_property_uchar('m_iDefaultFOV', value)
player.set_property_uchar('m_iFOV', value)
if time:
Delay(time, remove_drunk, (player, ))
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 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 _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 _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 getViewPlayer(command):
if len(command) == 3:
if exists(int(command[1])):
ConVar(str(command[2])).set_string(
str(
Player.from_userid(int(
command[1])).get_view_player().userid))
def strip(command):
if len(command) == 2:
if exists(int(command[1])):
player = Player.from_userid(int(command[1]))
entity = Entity.create('player_weaponstrip')
entity.call_input("Strip", activator=player)
entity.remove()
def getViewEntity(command):
if len(command) == 3:
if exists(int(command[1])):
ConVar(str(command[2])).set_string(
str(
Player.from_userid(int(
command[1])).get_view_entity().index))
def _wcs_teleport(command):
userid = int(command[1])
x = float(command[2])
y = float(command[3])
z = float(command[4])
target_location = Vector(
x,
y,
z,
)
player = Player.from_userid(userid)
origin = player.origin
angles = QAngle(*player.get_property_vector('m_angAbsRotation'))
forward = Vector()
right = Vector()
up = Vector()
angles.get_angle_vectors(forward, right, up)
forward.normalize()
forward *= 10.0
loop_limit = 100
can_teleport = 1
while is_player_stuck(player.index, target_location):
target_location -= forward
loop_limit -= 1
if target_location.get_distance(origin) <= 10.0 or loop_limit < 1:
can_teleport = 0
break
if can_teleport == 1:
player.teleport(target_location, None, None)
def register_center(args):
if len(args) >= 2:
userid = str(args[0])
text = str(args[1])
if userid.startswith('#'):
userid = getPlayerList(userid)
if not hasattr(userid, '__iter__'):
if not exists('userid', userid):
return
userid = (getPlayer(userid), )
hmm = []
if len(args) >= 4:
hmm = args[2:]
tokens = {}
for x in range(0, len(hmm), 2):
try:
tokens[hmm[x]] = hmm[x + 1]
except IndexError:
return
for user in userid:
if exists('userid', int(user)):
player = Player.from_userid(int(userid))
if not player.is_bot():
centertell(
user,
strings(text, tokens,
langlib.getLangAbbreviation(player.language)))
def wcs_ulti_roots():
userid = int(es.ServerVar('wcs_userid'))
player = Player.from_userid(userid)
if player.team >= 2:
count = 0
wcs_commands.fade(userid, 10, 55, 5, 200, 1)
radius = float(es.ServerVar('wcs_radius'))
time = float(es.ServerVar('wcs_duration'))
atk_origin = player.origin
for play in PlayerIter('alive'):
if play.team != player.team:
vic_origin = play.origin
if vic_origin.get_distance(atk_origin) <= radius:
if not wcsgroup.getUser(play.userid, 'ulti_immunity'):
play.move_type = MoveType.NONE
count += 1
Delay(time, remove_freeze, (play, ))
es.emitsound('player', play.userid, 'wcs/root.wav',
1.0, 0.6)
queue_command_string(
'es est_effect_06 #a 0 sprites/laser.vmt "%s,%s,%s" "%s,%s,%s" 10 1 5 5 10 4 0 160 0 155 2'
%
(atk_origin[0], atk_origin[1], atk_origin[2] + 35,
vic_origin[0], vic_origin[1], vic_origin[2] + 35))
queue_command_string(
'es est_effect_06 #a 0 sprites/laser.vmt "%s,%s,%s" "%s,%s,%s" 10 1 4 4 10 2 0 108 0 180 2'
%
(atk_origin[0], atk_origin[1], atk_origin[2] + 35,
vic_origin[0], vic_origin[1], vic_origin[2] + 35))
queue_command_string(
'es est_effect_06 #a 0 sprites/laser.vmt "%s,%s,%s" "%s,%s,%s" 10 1 5 5 10 4 0 80 0 190 2'
%
(atk_origin[0], atk_origin[1], atk_origin[2] + 35,
vic_origin[0], vic_origin[1], vic_origin[2] + 35))
queue_command_string(
'es est_effect 10 #a 0 sprites/laser.vmt %s %s %s 60 20 1 3 3 5 0 80 0 155 0 255 2'
%
(vic_origin[0], vic_origin[1], vic_origin[2] + 10))
queue_command_string(
'es est_effect 10 #a 0 sprites/laser.vmt %s %s %s 75 35 1 3 3 6 0 108 0 190 0 255 2'
%
(vic_origin[0], vic_origin[1], vic_origin[2] + 25))
else:
es.tell(
player.userid, '#multi',
'#lightgreenYour ultimate was blocked, the enemy is #greenimmune.'
)
es.tell(
play.userid, '#multi',
'#lightgreenYou #greenblocked #lightgreenan ultimate skill.'
)
if count > 0:
es.centertell(userid, 'Entangling Roots: %s' % (count))
else:
es.tell(
userid, '#multi',
'#lightgreenEntangling Roots #greenfailed#lightgreen, because no enemy is close enough.'
)
cancel(userid, 'player_ultimate')
def _gain_xp_vip(ev):
player = Player.from_userid(ev['userid'])
if ev['reason'] != "for beeing a VIP":
if str(player.steamid) in vips:
amount = int(
(ev['amount']) * (int(vips[player.steamid]['xp_gain']) / 100))
wcs.wcs.wcsplayers[player.userid].give_xp(amount,
"for beeing a VIP")
def convert_userid_identifier_to_players(filter_):
if filter_.isdigit():
try:
yield Player.from_userid(int(filter_))
except ValueError:
yield StopIteration()
else:
yield from convert_identifier_to_players(filter_)
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 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_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 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')
def get_player_cached_data(self, userid):
try:
player = Player.from_userid(userid)
self.player_data_lock.acquire()
if player.steamid in self.players:
row = self.players[player.steamid]
else:
row = None
self.player_data_lock.release()
return row
except:
msg('ERROR','could not get player cached data')
def _reset_team_killers(game_event):
userid = game_event['userid']
attacker = game_event['attacker']
# Suicide?
if attacker in (0, userid):
del multi_level_manager[userid]
return
# Not team-kill?
if Player.from_userid(userid).team != Player.from_userid(attacker).team:
del multi_level_manager[userid]
return
# Reset team-kill victim's multi-level?
if not tk_victim_reset.get_bool():
del multi_level_manager[userid]
# Reset the team-killer's multi-level?
if tk_attacker_reset.get_bool():
del multi_level_manager[attacker]
def insert_player_data(self, userid):
try:
player = Player.from_userid(userid)
if not player.address or player.steamid == 'BOT':
return
tmp_rank = {}
for item in self.classes:
tmp_rank[item] = 1
sql = "INSERT INTO `players` (`steamid`, `username`, `rank`, `cash`)VALUES(%s,%s,%s,%s)"
self.db.query(sql, (player.steamid,player.name,json.dumps(tmp_rank),0,), wait=False)
except:
msg('ERROR', 'could not insert player data')
def player_spawn(self, userid, flags):
try:
player = Player.from_userid(userid)
vector = self.get_random_spawnpoint(flags, self.get_player_team(player))
self.spawnprotection_start(player)
player.set_noblock(True)
player.set_frozen(True)
if not vector is None:
player.origin = vector
if not player.address:
self.delay_spawnprotection_end(player.userid)
except:
msg('ERROR', 'could not spawn player at specific spawn point...')
def _player_death(self, userid, attacker):
try:
player = Player.from_userid(userid)
if not player.address or player.steamid == 'BOT':
return
self.update_player_data(userid, {
'cash': player.cash,
'username': player.name
})
# give player cash
if userid != attacker:
self.player_add_cash(attacker, 25)
except:
msg('ERROR', 'could not save player rank data')
def respawnplayer(self, userid, ignore_team = False):
try:
player = Player.from_userid(userid)
if not player:
return
if not player.dead:
return
if player.team not in (2, 3) and ignore_team == False:
return
player.player_state = 0
player.life_state = LifeState.ALIVE
player.spawn()
except:
msg('ERROR', 'could not respawn player')
def player_spawn(self, userid):
try:
player = Player.from_userid(userid)
if not player.address or player.steamid == 'BOT':
return
pdata = self.get_player_data(userid)
self.player_spawn_logic(userid)
# get player team
pteam = self.get_player_team(userid)
# set player skin
if pteam in pdata['skin']:
if int(pdata['skin'][pteam]) != 0:
self.player_set_model(userid, pdata['skin'][pteam])
except:
msg('ERROR', 'could not execute player spawn function')
def _player_add_cash(self, data = ()):
try:
if len(data) == 2:
userid = data[0]
amount = data[1]
player = Player.from_userid(userid)
if not player.address or player.steamid == 'BOT':
return
player.cash = player.cash + amount
self.update_player_data(userid, {
'cash': player.cash
})
self.player_check_rank(userid)
except:
msg('ERROR', 'could not add {} cash to userid {}'.format(amount, userid))
def menu_select_sweapon(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)
menu = ExtendedPagedMenu(title='Secondary Weapon', select_callback=self.menu_select_sweapon_callback, on_close_menu=self.menu_select_sweapon_close_callback)
for item in self.weapons:
if int(self.weapons[item]['rank']) <= int(pdata['rank'][str(pdata['class'])]) and int(self.weapons[item]['type']) == 2 and pteam == self.weapons[item]['team'] and int(pdata['class']) == self.weapons[item]['class']:
menu.append(PagedOption('{}'.format(self.weapons[item]['name']), str(item), selectable=True))
menu.send(player.index)
except:
msg('ERROR', 'could not send select sweapon menu to player')
def create_medkit(self, userid, bombentindex, vector):
try:
locked = False
# get player and team
player = Player.from_userid(userid)
pdata = self.rank.get_player_data(userid)
if not int(pdata['class']) in self.rank.classes:
return
if not self.rank.classes[int(pdata['class'])]['can_have_medkit'] >= 1:
return
pteam = self.rank.get_player_team(userid)
# delete old medkit if we spawn a new one
self.delete_pack(userid)
# create healthpack
self.packs_lock.acquire()
locked = True
# set medkit color
if pteam == 'CT':
color = self.color_ct
else:
color = self.color_t
tmp_ent = Entity.create('prop_physics_override')
self.pack[player.userid] = {
'ent': tmp_ent.index,
'type': 'health',
'amount': 200,
'give': 10,
'distance': 100,
'userid': userid,
'team': pteam,
'next_glow': 0,
'color': color,
}
tmp_ent.origin = vector
tmp_ent.model = Model('models/props/cs_italy/bin01.mdl')
tmp_ent.spawn_flags = 4
tmp_ent.color = color
# spawn healthpack
tmp_ent.spawn()
# set health
tmp_ent.call_input('SetHealth', 100)
tmp_ent.set_property_uchar("m_takedamage", TakeDamage.YES)
self.packs_lock.release()
locked = False
except:
if locked:
self.packs_lock.release()
msg('ERROR', 'could not create healthpack')
