def effect112(model, origin, angle, size, velocity, randomization, count, time,
flags):
"""
est_effect_12 <player filter> <delay> <model> <origin x y z> <angle p y r> <Size x y z> <velocity x y z> <randomization> <count> <time> <flags>
"""
if not isinstance(model, Model):
model = Model(model)
if not isinstance(origin, Vector):
origin = Vector(*origin)
if not isinstance(angle, QAngle):
angle = QAngle(*angle)
if not isinstance(size, Vector):
size = Vector(*size)
if not isinstance(velocity, Vector):
velocity = Vector(*velocity)
te = TempEntity('Break Model')
te.model = model
te.origin = origin
te.rotation = angle
te.size = size
te.velocity = velocity
te.randomization = randomization
te.count = count
te.life_time = time
te.flags = flags
return te
def effect120(model,
position,
scale,
frame_rate,
flags,
radius,
magnitude,
normal=None,
material=None):
"""
est_effect_20 <player filter> <delay> <model> <position x y z> <scale> <framerate> <flags> <radius> <magnitude> [normal x y z] [material type]
"""
if not isinstance(position, Vector):
position = Vector(*position)
te = TempEntity('Explosion')
te.position = position
te.scale = scale
te.frame_rate = frame_rate
te.flags = flags
te.radius = radius
te.magnitude = magnitude
if normal is not None:
if not isinstance(normal, Vector):
normal = Vector(*normal)
te.normal = normal
if material is not None:
te.material_type = material
return te
def square(recipients, start, end, **kwargs):
"""Create a square using the temporary effect ``BeamPoints``.
:param RecipientFilter recipients:
Players that should see the beam.
:param Vector start:
Upper left corner of the square.
:param Vector end:
Lower right corner of the square.
:param kwargs:
Additional attributes that will be send to the effect.
"""
x1, y1, z1 = start
x2, y2, z2 = end
a = start
b = Vector(x2, y2, z1)
c = Vector(x1, y1, z2)
d = end
lines = (
(a, b),
(b, d),
(d, c),
(c, a),
)
for p1, p2 in lines:
entity = TempEntity('BeamPoints')
entity.start_point = p1
entity.end_point = p2
for attr, value in kwargs.items():
setattr(entity, attr, value)
entity.create(recipients)
def effect127(model, skin, position, angle, velocity, flags, effects):
"""
est_effect_27 <player filter> <delay> <model> <subtype/skin> <position x y z> <angle p y r> <velocity x y z> <flags> <effects>
"""
if not isinstance(model, Model):
model = Model(model)
if not isinstance(position, Vector):
position = Vector(*position)
if not isinstance(angle, QAngle):
angle = QAngle(*angle)
if not isinstance(velocity, Vector):
velocity = Vector(*velocity)
te = TempEntity('physicsprop')
te.model = model
te.skin = skin
te.origin = position
te.angles = angle
te.velocity = velocity
te.flags = flags
te.effects = effects
return te
class ArmorRicochet(_EffectBase):
function = temp_entities.armor_ricochet
args = OrderedDict([
('delay', 0),
('position', Vector()),
('direction', Vector())
])
def effect107(model, start_point, end_point, frame_rate, life_time, width,
fade_length, amplitude, red, green, blue, alpha, speed):
"""
est_effect_07 <player filter> <delay> <model> <start entity> <end entity> <framerate> <life> <width> <spread> <amplitude> <red> <green> <blue> <alpha> <speed>
"""
if not isinstance(model, Model):
model = Model(model)
if not isinstance(start_point, Vector):
start_point = Vector(*start_point)
if not isinstance(end_point, Vector):
end_point = Vector(*end_point)
te = TempEntity('BeamPoints')
te.model = model
te.halo = model
te.start_point = start_point
te.end_point = end_point
te.frame_rate = frame_rate
te.life_time = life_time
te.start_width = width
te.end_width = width
te.fade_length = fade_length
te.amplitude = amplitude
te.red = red
te.green = green
te.blue = blue
te.alpha = alpha
te.speed = speed
return te
def wcs_nearcoord_command(command_info, var:str, players:convert_identifier_to_players, x:float, y:float, z:float, distance:float, command:str):
vector = Vector(x, y, z)
for player in players:
if vector.get_distance(player.origin) <= distance:
for cmd in [f'es_xset {var} {player.userid}'] + command.split(';'):
execute_server_command(*split(cmd))
def vampiric_aura(event, wcsplayer, variables):
if randint(0, 100) <= variables['chance']:
wcsvictim = Player.from_userid(event['userid'])
victim = wcsvictim.player
if not victim.dead:
attacker = wcsplayer.player
if not attacker.dead:
vector1 = Vector(*victim.origin)
vector2 = Vector(*attacker.origin)
vector1.z += 20
vector2.z += 20
vampiric_aura_effect_0.create(start_point=vector1,
end_point=vector2)
vampiric_aura_effect_1.create(start_point=vector1,
end_point=vector2)
vampiric_aura_effect_2.create(start_point=vector1,
end_point=vector2)
vector2.z += 8
vampiric_aura_effect_3.create(center=vector2)
health = attacker.health
if health < max_health:
value = randint(min_health_gain, max_health_gain)
value = value if health + value <= max_health else health + value - max_health
attacker.health = health + value
vampiric_aura_leech_message.send(wcsplayer.index,
value=value)
def effect102(model, start_entity_index, start_point, end_entity_index,
end_point, frame_rate, life_time, start_width, end_width,
fade_length, amplitude, red, green, blue, alpha, speed):
"""
est_effect_02 <player filter> <delay> <model> <start entity> <start position x y z> <end entity> <end position x y z> <framerate> <life> <start width> <end width> <fade distance> <amplitude> <red> <green> <blue> <alpha> <speed>
"""
if not isinstance(model, Model):
model = get_model_instance(model)
if not isinstance(start_point, Vector):
start_point = Vector(*start_point)
if not isinstance(end_point, Vector):
end_point = Vector(*end_point)
te = TempEntity('BeamEntPoint')
te.model = model
te.halo = model
te.start_entity_index = start_entity_index
te.start_point = start_point
te.end_entity_index = end_entity_index
te.end_point = end_point
te.frame_rate = frame_rate
te.life_time = life_time
te.start_width = start_width
te.end_width = end_width
te.fade_length = fade_length
te.amplitude = amplitude
te.red = red
te.green = green
te.blue = blue
te.alpha = alpha
te.speed = speed
return te
def bash(event, wcsplayer, variables):
if randint(0, 100) <= variables['chance']:
wcsvictim = Player.from_userid(event['userid'])
stuck = wcsvictim.data.get('stuck', 0)
if not stuck:
if not wcsvictim.data.get('noclip'):
wcsvictim.player.move_type = MoveType.NONE
wcsvictim.data['stuck'] = stuck + 1
delay = Delay(1, _reset_bash, (wcsvictim, ))
delay.args += (delay, )
_delays[wcsvictim].append(delay)
bash_attacker_message.send(wcsplayer.index, name=wcsvictim.name)
bash_victim_message.send(wcsvictim.index, name=wcsplayer.name)
vector1 = Vector(*wcsplayer.player.origin)
vector2 = Vector(*wcsvictim.player.origin)
vector1.z += 20
vector2.z += 20
bash_effect_0.create(start_point=vector1, end_point=vector2)
vector2.z += 5
bash_effect_1.create(center=vector2)
def est_effect_02(command):
if len(command) == 19:
#est_Effect_02 <player Filter> <delay> <model> <start ent> <start position "X Y Z"> <end ent> <end position "X Y Z"> <framerate> <life> <start width> <end width> <fade distance> <amplitude> <R> <G> <B> <A> <speed>
str_vec = command[5]
str_vec = str_vec.split(",")
vec = Vector(float(str_vec[0]), float(str_vec[1]), float(str_vec[2]))
str_vec = command[7]
str_vec = str_vec.split(",")
vec2 = Vector(float(str_vec[0]), float(str_vec[1]), float(str_vec[2]))
te = TempEntity('BeamEntPoint',
start_entity_index=int(command[4]),
start_point=Vector(float(command[5])),
end_entity_index=int(command[6]),
end_point=vec2,
model_index=Model(str(command[3])).index,
halo_index=Model(str(command[3])).index,
frame_rate=int(command[8]),
life_time=float(command[9]),
start_width=int(command[10]),
end_width=int(command[11]),
fade_length=int(command[12]),
amplitude=int(command[13]),
red=int(command[14]),
green=int(command[15]),
blue=int(command[16]),
alpha=int(command[17]),
speed=int(command[18]))
te.create(delay=float(command[2]))
def calculate_offset(number, size, angle=None):
"""Calculates the offset for centering the 'point_worldtext' entity on the
'decoy_projectile'.
Args:
number (str): Number that the 'point_worldtext' entity will display.
size (int): Size of the number.
angle (QAngle): Angle of the number.
Returns:
Vector: Offset for centering the 'point_worldtext' entity on a
'decoy_projectile' based on the given arguments.
"""
offset_x = 0
offset_y = 0.3 * size * (len(number) + 0.733)
offset_z = size * -0.58
if angle is not None:
# Get the forward direction of the given 'angle'.
forward = Vector()
angle.get_angle_vectors(forward)
# Adjust the offsets.
offset_x = offset_y * -forward[1]
offset_y *= forward[0]
return Vector(offset_x, offset_y, offset_z)
def square(
recipients, delay, start, end, model_index, halo_index, start_frame,
frame_rate, life, width, end_width, fade_length, amplitude, red,
green, blue, alpha, speed):
"""Create a square by using _TempEntities.beam_points()."""
if not isinstance(start, Vector) or not isinstance(end, Vector):
raise TypeError('"start" and "end" must be Vector objects.')
x1, y1, z1 = tuple(start)
x2, y2, z2 = tuple(end)
a = start
b = Vector(x2, y2, z1)
c = Vector(x1, y1, z2)
d = end
lines = (
(a, b),
(b, d),
(d, c),
(c, a),
)
for p1, p2 in lines:
temp_entities.beam_points(
recipients, delay, p1, p2, model_index,
halo_index, start_frame, frame_rate, life, width, end_width,
fade_length, amplitude, red, green, blue, alpha, speed)
def effect110(model, origin, direction, red, green, blue, alpha, size):
"""
est_effect_10 <player filter> <delay> <model> <origin x y z> <direction x y z> <red> <green> <blue> <alpha> <size>
"""
if not isinstance(model, Model):
model = Model(model)
if not isinstance(origin, Vector):
origin = Vector(*origin)
if not isinstance(direction, Vector):
direction = Vector(*direction)
te = TempEntity('Blood Sprite')
te.drop_model = model
te.spray_model = model
te.origin = origin
te.direction = direction
te.red = red
te.green = green
te.blue = blue
te.alpha = alpha
te.size = size
return te
def _on_player_jump(self, player, **kwargs):
if self.longjump:
velocity = Vector()
player.get_velocity(velocity, None)
velocity.x *= 2
velocity.y *= 2
velocity.z = 10
player.base_velocity = velocity
def get_wall_between_command(command_info, var:ConVar, x:float, y:float, z:float, x2:float, y2:float, z2:float):
vector = Vector(x, y, z)
vector2 = Vector(x, y, z)
trace = GameTrace()
ray = Ray(vector, vector2)
engine_trace.trace_ray(ray, ContentMasks.ALL, None, trace)
var.set_int(trace.did_hit_world())
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 wcs_teleport_command(command_info, player:convert_userid_to_player, x:float, y:float, z:float):
if player is None:
return
location = Vector(x, y, z)
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
playerinfo = player.playerinfo
mins, maxs = playerinfo.mins, playerinfo.maxs
players = TraceFilterSimple(PlayerIter())
for _ in range(100):
ray = Ray(location, location, mins, maxs)
trace = GameTrace()
engine_trace.trace_ray(ray, ContentMasks.PLAYER_SOLID, players, trace)
if not trace.did_hit():
player.teleport(origin=location)
break
location -= forward
if location.get_distance(origin) <= 10.0:
break
class Bubbles(_EffectBase):
function = temp_entities.bubbles
args = OrderedDict([
('delay', 0),
('start_position', Vector()),
('end_position', Vector()),
('height', 1),
('model', None),
('count', 1),
('speed', 1)
])
class BubbleTrail(_EffectBase):
function = temp_entities.bubble_trail
args = OrderedDict([
('delay', 0),
('start_position', Vector()),
('end_position', Vector()),
('water_level', 0),
('model', None),
('count', 1),
('speed', 1)
])
def chain_lightning(wcsplayer, variables):
player = wcsplayer.player
if not player.dead:
team = player.team_index
if team >= 2:
max_targets = variables['max_targets']
radius = variables['radius']
targets = []
immune = 0
vector = Vector(*player.origin)
# TODO: Check if there's a wall between the two players
for target, wcstarget in PlayerReadyIter(['alive', 'ct' if wcsplayer.player.team_index == 2 else 't']):
if wcstarget.data.get('ulti_immunity', False):
immune += 1
chain_lightning_block_victim_message.send(target.index)
else:
vector2 = target.origin
distance = vector.get_distance(vector2)
if distance <= radius:
targets.append((wcstarget, Vector(*vector2)))
max_targets -= 1
if not max_targets:
break
if immune:
chain_lightning_block_attacker_message.send(wcsplayer.index, count=immune)
if targets:
wcsplayer.skills['chain_lightning'].reset_cooldown()
vector.z += 35
damage = variables['damage']
for (wcstarget, vector2) in targets:
wcstarget.take_damage(damage, wcsplayer.index, 'orcish_horde-chain_lightning')
vector2.z += 35
chain_lightning_0_effect.create(start_point=vector, end_point=vector2)
chain_lightning_1_effect.create(start_point=vector, end_point=vector2)
chain_lightning_2_effect.create(start_point=vector, end_point=vector2)
chain_lightning_count_message.send(wcsplayer.index, count=len(targets))
else:
chain_lightning_failed_message.send(wcsplayer.index)
def construct_areas(self):
area_count = self.read('I')
for x in range(0, area_count):
area = Area()
area.id = x
area.flags = self.read('B') if self.version <= 8 else self.read('H')
x1, y1, z1, x2, y2, z2 = self.read('ffffff')
vector1, vector2 = Vector(x1, y1, z1), Vector(x2, y2, z2)
area.extent = Ray(vector1, vector2)
area.center = area.extent.center
def _getdistance(command):
var = str(command[1])
x1 = float(command[2])
y1 = float(command[3])
z1 = float(command[4])
x2 = float(command[5])
y2 = float(command[6])
z2 = float(command[7])
vec1 = Vector(x1, y1, z1)
vec2 = Vector(x2, y2, z2)
distance = vec1.get_distance(vec2)
ConVar(var).set_float(distance)
class BloodSprite(_EffectBase):
function = temp_entities.blood_sprite
args = OrderedDict([
('delay', 0),
('position', Vector()),
('direction', Vector()),
('red', 0),
('green', 0),
('blue', 0),
('alpha', 255),
('size', 5)
])
class BloodStream(_EffectBase):
function = temp_entities.blood_stream
args = OrderedDict([
('delay', 0),
('position', Vector()),
('direction', Vector()),
('red', 0),
('green', 0),
('blue', 0),
('alpha', 255),
('amount', 5)
])
def effect1(model, x, y, z, dx, dy, dz):
"""
est_effect 1 <player filter> <delay> <model> (position <x> <y> <z>) (direction <x> <y> <z>)
"""
if not isinstance(model, Model):
model = Model(model)
te = TempEntity('Armor Ricochet')
te.position = Vector(x, y, z)
te.direction = Vector(dx, dy, dz)
return te
def effect8(model, x, y, z, dx, dy, dz):
"""
est_effect 8 <player filter> <delay> <model> <x> <y> <z> (towards <x> <y> <z>)
"""
if not isinstance(model, Model):
model = Model(model)
te = TempEntity('Metal Sparks')
te.position = Vector(x, y, z)
te.direction = Vector(dx, dy, dz)
return te
def critical_strike(event, wcsplayer, variables):
if randint(0, 100) <= variables['chance']:
userid = event['userid']
wcsvictim = Player.from_userid(userid)
wcsvictim.take_delayed_damage(event['info'].damage * variables['multiplier'], wcsplayer.index, 'orcish_horde-critical_strike')
vector1 = Vector(*wcsplayer.player.origin)
vector2 = Vector(*wcsvictim.player.origin)
vector1.z += 20
vector2.z += 20
critical_strike_effect.create(start_point=vector1, end_point=vector2)
class BreakModel(_EffectBase):
function = temp_entities.break_model
args = OrderedDict([
('delay', 0),
('position', Vector()),
('angle', 0),
('size', Vector()),
('velocity', Vector()),
('model', None),
('randomization', 0),
('count', 1),
('flags', 0)
])
def effect9(model, x, y, z, dx, dy, dz, type_):
"""
est_effect 9 <player filter> <delay> <model> <x> <y> <z> (towards <x> <y> <z>) <type>
"""
if not isinstance(model, Model):
model = Model(model)
te = TempEntity('GaussExplosion')
te.origin = Vector(x, y, z)
te.direction = Vector(dx, dy, dz)
te.type = type_
return te
class InertialessMissile(Missile): #TODO: add AI for this, mess with pathing--doesn't need to brake. Goes slow using pathToDest for some reason. def increaseThrust(self, dt, mul): #increase speed up to max speed angleRadians = -math.radians(self.rotation) self.vel = Vector(math.cos(angleRadians), math.sin(angleRadians)) * (self.thrust * dt * mul) s = self.vel.length() if s > self.maxSpeed: self.vel *= self.maxSpeed / s
def increaseThrust(self, dt, mul): #increase speed up to max speed angleRadians = -math.radians(self.rotation) self.vel = Vector(math.cos(angleRadians), math.sin(angleRadians)) * (self.thrust * dt * mul) s = self.vel.length() if s > self.maxSpeed: self.vel *= self.maxSpeed / s
