if exists(userid):
player = Player.from_userid(userid)
origin = player.origin
coords = player.view_coordinates
coords -= origin
player.set_property_vector('localdata.m_vecBaseVelocity',
coords * force)
# =============================================================================
# >> HOOKS
# =============================================================================
@EntityPreHook(
EntityCondition.equals_entity_classname('prop_physics_multiplayer'),
'on_take_damage')
def take_damage_hook(stack_data):
take_damage_info = make_object(TakeDamageInfo, stack_data[1])
attacker = Entity(take_damage_info.attacker)
victim = make_object(Entity, stack_data[0])
if victim.index in entity_health:
damage = take_damage_info.damage
if entity_health[victim.index] <= 0:
Delay(0.1, victim.remove)
else:
entity_health[victim.index] -= damage
else:
return
@Event('enter_buyzone')
def _on_enter_buy_zone(event):
player = Player(index_from_userid(event['userid']))
flag = flag_manager.find_by_carrier(player.index)
if flag:
flag_manager.on_enter_buy_zone(flag)
score_managers[teams_by_number[player.team]].score += 3
@Event('player_death')
def _on_player_death(event):
player = Player(index_from_userid(event['userid']))
flag = flag_manager.find_by_carrier(player.index)
if flag:
flag_manager.on_carried_death(flag)
score_managers[teams_by_number[5-player.team]].score += 1
## =================== HOOKS =======================
@EntityPreHook(EntityCondition.equals_entity_classname('prop_physics_override'), 'use')
def _on_entity_use(stack):
entity_index = index_from_pointer(stack[0])
player_index = make_object(InputData, stack[1]).activator.index
flag = flag_manager.find(entity_index)
other = flag_manager.find_by_carrier(player_index)
if flag and not other:
Delay(0.1, flag_manager.on_carrier_pickup, flag, Player(player_index))
'headshot_immunity')
if headshot_immunity != None:
if victim.hitgroup == HitGroup.HEAD:
headshot_immunity = float(headshot_immunity)
if headshot_immunity > 0:
headshot_immunity_dmg = damage * headshot_immunity
if int(headshot_immunity_dmg) > 0:
victim.health += int(headshot_immunity_dmg)
##wcs.wcs.tell(victim.userid,'\x04[WCS] \x05Your headshot immunity prevented %s damage!' % int(headshot_immunity_dmg))
# =============================================================================
# >> HOOKS
# =============================================================================
@EntityPreHook(
EntityCondition.equals_entity_classname('prop_physics_multiplayer'),
'on_take_damage')
def take_damage_hook(stack_data):
take_damage_info = make_object(TakeDamageInfo, stack_data[1])
victim = make_object(Entity, stack_data[0])
if victim.index in entity_health:
damage = take_damage_info.damage
if entity_health[victim.index] <= 0:
Delay(0.1, victim.remove)
else:
entity_health[victim.index] -= damage
else:
return
# TODO: Only register this callback when _game_models is populated
# =============================================================================
@EntityPreHook(EntityCondition.is_player, 'on_take_damage')
def pre_on_take_damage(stack_data):
rat = rats[index_from_pointer(stack_data[0])]
info = make_object(TakeDamageInfo, stack_data[1])
if info.attacker == rat.player.index or is_world_entity(info.attacker):
return
attacker = rats[info.attacker]
if rat.area_id != attacker.area_id:
return True
@EntityPreHook(
EntityCondition.equals_entity_classname(BLOCK_ENTITY), 'on_take_damage')
def pre_on_take_damage(stack_data):
index = index_from_pointer(stack_data[0])
if index not in _blocks_by_solids:
return
block = _blocks_by_solids[index]
info = make_object(TakeDamageInfo, stack_data[1])
if is_world_entity(info.attacker):
return True
attacker = rats[info.attacker]
for block_ in block.neighbours():
@OnEntitySpawned
def listener_on_entity_spawned(base_entity):
if base_entity.classname not in valid_npc_classnames:
return
entity = Entity(base_entity.index)
entity.spawn_flags |= 512
entity.set_key_value_int('sleepstate', 0)
entity.call_input('SetRelationship', 'player D_HT 99')
def make_event_killed(entity):
return entity.pointer.make_virtual_function(
EVENT_KILLED_INDEX,
Convention.THISCALL,
[DataType.POINTER, DataType.POINTER],
DataType.VOID
)
@EntityPreHook(EntityCondition.equals_entity_classname(*valid_npc_classnames),
make_event_killed)
def pre_event_killed(args):
entity = make_object(Entity, args[0])
if entity.classname not in valid_npc_classnames:
return
entity.remove()
return True
from entities.helpers import index_from_pointer
from entities.hooks import EntityCondition, EntityPreHook
from events import Event
from listeners import OnLevelEnd
from mathlib import Vector
from players.helpers import userid_from_edict
# Floating Damage Numbers
from .core.colors import WHITE, RED, YELLOW
from .core.config import world_damage, wall_bangs
from .core.constants import FL_EDICT_ALWAYS, DISTANCE_MULTIPLIER
from .core.floating_number import FloatingNumber, number_instances
from .core.players import PlayerFDN, player_instances
is_point_worldtext = EntityCondition.equals_entity_classname(
'point_worldtext')
def load():
"""Called when the plugin gets loaded."""
PlayerFDN.initialize_all_players()
@EntityPreHook(is_point_worldtext, 'set_transmit')
def pre_set_transmit(stack_data):
"""Hides 'point_worldtext' entities that are part of FloatingNumbers for
everyone except the specified recipient.
"""
index = index_from_pointer(stack_data[0])
try:
from enum import Enum
from entities.hooks import EntityPostHook, EntityCondition
from listeners import OnEntityDeleted, OnEntityOutput, OnLevelInit
from events import Event
from .containers import route_container, map_container
from .decorators import PostHookFilter
class ZoneEvents(Enum):
""" All possible zone events. """
ENTER = "start_touch"
EXIT = "end_touch"
@EntityPostHook(EntityCondition.equals_entity_classname("trigger_multiple"),
ZoneEvents.ENTER.value)
@PostHookFilter("trigger_multiple")
def on_start_touch(entity, player):
try:
zone = map_container.get_session().get_zone(entity.index)
except KeyError:
return
for route in route_container.get(zone.endpoint, ZoneEvents.ENTER):
route.call(zone, player)
@EntityPostHook(EntityCondition.equals_entity_classname("trigger_multiple"),
ZoneEvents.EXIT.value)
@PostHookFilter("trigger_multiple")
def on_end_touch(entity, player):
return
if get_mine_denial_reason(player) is not None:
return
trace = player.player.get_trace_ray()
distance = (trace.end_position - player.player.origin).length
if distance > config_manager['plant_distance']:
return
use_mine(player, trace.end_position, trace.plane.normal)
@EntityPreHook(
EntityCondition.equals_entity_classname('prop_physics_override'),
'on_take_damage')
def pre_take_damage(args):
victim_entity = make_object(Entity, args[0])
try:
victim_trip_mine = trip_mine_manager.get_by_prop_index(
victim_entity.index)
except IndexError:
return
if not victim_trip_mine.activated:
return False
info = make_object(TakeDamageInfo, args[1])
if info.attacker == WORLD_ENTITY_INDEX:
_round_end = True
@Event('player_death')
def on_player_death(game_event):
ctfplayer = ctfplayers.from_userid(game_event['userid'])
for flag in _flags.values():
if flag.ctfplayer is not None and flag.ctfplayer == ctfplayer:
flag.drop()
break
# =============================================================================
# >> HOOKS
# =============================================================================
@EntityPreHook(EntityCondition.equals_entity_classname('trigger_multiple'),
"start_touch")
def pre_start_touch(stack_data):
entity_index = index_from_pointer(stack_data[0])
other_index = index_from_pointer(stack_data[1])
_ecx_storage_start_touch_zones[
stack_data.registers.esp.address.address] = (entity_index, other_index)
@EntityPreHook(EntityCondition.equals_entity_classname('prop_dynamic_glow'),
"start_touch")
def pre_start_touch(stack_data):
entity_index = index_from_pointer(stack_data[0])
other_index = index_from_pointer(stack_data[1])
_ecx_storage_start_touch_flags[
stack_data.registers.esp.address.address] = (entity_index, other_index)
if not base_entity.is_networked():
return
zone_entities.pop(base_entity.index, None)
@Event('round_start')
def on_round_start(game_event):
create_zone_entities()
_ecx_storage_start_touch = {}
_ecx_storage_end_touch = {}
@EntityPreHook(EntityCondition.equals_entity_classname(ZONE_ENTITY_CLASSNAME),
"start_touch")
def pre_start_touch(args):
entity = make_object(Entity, args[0])
other = make_object(Entity, args[1])
_ecx_storage_start_touch[args.registers.esp.address.address] = (entity,
other)
@EntityPostHook(EntityCondition.equals_entity_classname(ZONE_ENTITY_CLASSNAME),
"start_touch")
def post_start_touch(args, ret_val):
entity, other = _ecx_storage_start_touch.pop(
args.registers.esp.address.address)
try:
else:
return False
# Is the player on a different team than the thrower?
if player.team != _flashbang_team:
return
# Allow self flash
if player.userid == _flashbang_thrower and flash_thrower.get_int():
return
# Block the flash for the player
return False
@EntityPreHook(EntityCondition.equals_entity_classname(
'flashbang_projectile'), 'detonate')
def _pre_flashbang_detonate(args):
"""Store the flashbang's thrower/team to compare against player teams."""
global _flashbang_team, _flashbang_thrower
# Get the weapon's instance
weapon = make_object(Weapon, args[0])
# Store the weapon's team
_flashbang_team = weapon.team
# Get the weapon's thrower
owner = weapon.current_owner
# Store the owner's userid
if owner is not None: