def laser_catcher_skins(ctx: Context):
"""Fix Valve's bug where reloading saves causes lasers to get their skin wrong."""
for ent in ctx.vmf.by_class['prop_laser_catcher']:
if not conv_bool(ent['src_fix_skins'], True):
continue
deact_skin, act_skin = '23' if ent['SkinType'] == '1' else '01'
# Look for outputs which do this already.
name = ent['targetname']
has_act = has_deact = False
for out in ent.outputs:
if has_act and has_deact:
break
if out.target == name or out.target == '!self':
if out.input.casefold() == 'skin':
if out.params == act_skin:
has_act = True
elif out.params == act_skin:
has_act = True
if not has_act:
ent.add_out(Output('OnPowered', '!self', 'Skin', act_skin))
if not has_deact:
ent.add_out(Output('OnUnPowered', '!self', 'Skin', deact_skin))
def sceneset(ctx: Context):
"""Chains a set of choreographed scenes together."""
for ent in ctx.vmf.by_class['comp_choreo_sceneset']:
scenes = [
ent['scene{:02}'.format(i)] for i in range(1, 21)
if ent['scene{:02}'.format(i)]
]
if not scenes:
LOGGER.warning(
'"{}" at ({}) has no scenes!',
ent['targetname'],
ent['origin'],
)
continue
if conv_bool(ent['play_dings']):
scenes.insert(0, 'scenes/npc/glados_manual/ding_on.vcd')
scenes.append('scenes/npc/glados_manual/ding_off.vcd')
delay = conv_float(ent['delay'], 0.1)
only_once = conv_bool(ent['only_once'])
ent.remove()
start_ent = None
name = ent['targetname'] or '_choreo_{}'.format(ent.id)
for i, scene in enumerate(scenes):
part = ctx.vmf.create_ent(
classname='logic_choreographed_scene',
targetname=('{}_{}'.format(name, i) if i > 0 else name),
origin=ent['origin'],
scenefile=scene,
)
if i + 1 < len(scenes):
part.add_out(
Output(
'OnCompletion',
'{}_{}'.format(name, i + 1),
'Start',
delay=delay,
))
if only_once:
# When started blank the name so it can't be triggered,
# then clean up after finished
part.add_out(
Output('OnStart', '!self', 'AddOutput', 'targetname '),
Output('OnCompletion', '!self', 'Kill'),
)
if start_ent is None:
start_ent = part
assert start_ent is not None, "Has scenes but none made?"
for out in ent.outputs:
if out.output.casefold() == 'onstart':
start_ent.add_out(out)
elif out.output.casefold() == 'onfinish':
# Part is the last in the loop.
out.output = 'OnCompletion'
part.add_out(out)
def res_sendificator(vmf: VMF, inst: Entity):
"""Implement Sendificators."""
# For our version, we know which sendtor connects to what laser,
# so we can couple the logic together (avoiding @sendtor_mutex).
sendtor_name = inst['targetname']
sendtor = connections.ITEMS[sendtor_name]
sendtor.enable_cmd += (Output(
'',
'@{}_las_relay_*'.format(sendtor_name),
'Trigger',
delay=0.01,
), )
for ind, conn in enumerate(list(sendtor.outputs), start=1):
las_item = conn.to_item
conn.remove()
try:
targ_offset, targ_normal = SENDTOR_TARGETS[las_item.name]
except KeyError:
LOGGER.warning('"{}" is not a Sendificator target!', las_item.name)
continue
angles = Vec.from_str(las_item.inst['angles'])
targ_offset = targ_offset.copy()
targ_normal = targ_normal.copy().rotate(*angles)
targ_offset.localise(
Vec.from_str(las_item.inst['origin']),
angles,
)
relay_name = '@{}_las_relay_{}'.format(sendtor_name, ind)
relay = vmf.create_ent(
'logic_relay',
targetname=relay_name,
origin=targ_offset,
angles=targ_normal.to_angle(),
)
relay.add_out(
Output('OnTrigger', '!self', 'RunScriptCode',
'::sendtor_source <- self;'),
Output('OnTrigger', '@sendtor_fire', 'Trigger'),
)
if not las_item.inputs:
# No other inputs, make it on always. PeTI automatically turns
# it off when inputs are connected, which is annoying.
las_item.inst.fixup['$start_enabled'] = '1'
is_on = True
else:
is_on = las_item.inst.fixup.bool('$start_enabled')
relay['StartDisabled'] = not is_on
las_item.enable_cmd += (Output('', relay_name, 'Enable'), )
las_item.disable_cmd += (Output('', relay_name, 'Disable'), )
LOGGER.info('Relay: {}', relay)
def make_tag_coop_inst(tag_loc: str):
"""Make the coop version of the tag instances.
This needs to be shrunk, so all the logic entities are not spread
out so much (coop tubes are small).
This way we avoid distributing the logic.
"""
global TAG_COOP_INST_VMF
TAG_COOP_INST_VMF = vmf = VMF.parse(
os.path.join(tag_loc, TAG_GUN_COOP_INST)
)
def logic_pos():
"""Put the entities in a nice circle..."""
while True:
for ang in range(0, 44):
ang *= 360/44
yield Vec(16*math.sin(ang), 16*math.cos(ang), 32)
pos = logic_pos()
# Move all entities that don't care about position to the base of the player
for ent in TAG_COOP_INST_VMF.iter_ents():
if ent['classname'] == 'info_coop_spawn':
# Remove the original spawn point from the instance.
# That way it can overlay over other dropper instances.
ent.remove()
elif ent['classname'] in ('info_target', 'info_paint_sprayer'):
pass
else:
ent['origin'] = next(pos)
# These originally use the coop spawn point, but this doesn't
# always work. Switch to the name of the player, which is much
# more reliable.
if ent['classname'] == 'logic_measure_movement':
ent['measuretarget'] = '!player_blue'
# Add in a trigger to start the gel gun, and reset the activated
# gel whenever the player spawns.
trig_brush = vmf.make_prism(
Vec(-32, -32, 0),
Vec(32, 32, 16),
mat='tools/toolstrigger',
).solid
start_trig = vmf.create_ent(
classname='trigger_playerteam',
target_team=3, # ATLAS
spawnflags=1, # Clients only
origin='0 0 8',
)
start_trig.solids = [trig_brush]
start_trig.add_out(
# This uses the !activator as the target player so it must be via trigger.
Output('OnStartTouchBluePlayer', '@gel_ui', 'Activate', delay=0, only_once=True),
# Reset the gun to fire nothing.
Output('OnStartTouchBluePlayer', '@blueisenabled', 'SetValue', 0, delay=0.1),
Output('OnStartTouchBluePlayer', '@orangeisenabled', 'SetValue', 0, delay=0.1),
)
def run_transformations(
vmf: VMF,
filesys: FileSystem,
pack: PackList,
) -> None:
"""Run all transformations."""
context = Context(
filesys,
vmf,
pack,
)
for func_name, func in TRANSFORMS.items():
LOGGER.info('Running "{}"...', func_name)
func(context)
LOGGER.info('Remapping outputs...')
for ent in vmf.entities:
for out in ent.outputs[:]:
try:
# noinspection PyProtectedMember
remaps = context._io_remaps[out.target.casefold(),
out.input.casefold(), ]
except KeyError:
continue
ent.outputs.remove(out)
for new_out in remaps:
ent.outputs.append(
Output(
out.output,
new_out.target,
new_out.input,
new_out.params or out.params,
out.delay + new_out.delay,
times=min(new_out.only_once, out.only_once),
))
def add_output(inst: Entity) -> None:
"""Add the output."""
if out_type in ('activate', 'deactivate'):
try:
item_type = connections.ITEM_TYPES[out_id.casefold()]
except KeyError:
LOGGER.warning('"{}" has no connections!', out_id)
return
if out_type[0] == 'a':
if item_type.output_act is None:
return
inst_out, output = item_type.output_act
else:
if item_type.output_deact is None:
return
inst_out, output = item_type.output_deact
else:
output = out_id
inst_out = conf_inst_out
inst.add_out(
Output(
inst.fixup.substitute(output),
conditions.local_name(inst, inst.fixup.substitute(targ))
or inst['targetname'],
inst.fixup.substitute(input_name),
inst.fixup.substitute(parm),
srctools.conv_float(inst.fixup.substitute(delay)),
times=times,
inst_out=inst.fixup.substitute(inst_out) or None,
inst_in=inst.fixup.substitute(inst_in) or None,
))
def add_choreo(
vmf: VMF,
c_line: str,
targetname: str,
loc: Vec,
use_dings=False,
is_first=True,
is_last=True,
only_once=False,
) -> Entity:
"""Create a choreo scene."""
# Add this to the beginning, since all scenes need it...
if not c_line.startswith('scenes/'):
c_line = 'scenes/' + c_line
choreo = vmf.create_ent(
classname='logic_choreographed_scene',
targetname=targetname,
origin=loc,
scenefile=c_line,
busyactor="1", # Wait for actor to stop talking
onplayerdeath='0',
)
if use_dings:
# Play ding_on/off before and after the line.
if is_first:
choreo.add_out(
Output('OnUser1', '@ding_on', 'Start', only_once=only_once),
Output('OnUser1',
targetname,
'Start',
delay=0.2,
only_once=only_once),
)
if is_last:
choreo.add_out(Output('OnCompletion', '@ding_off', 'Start'), )
elif is_first:
choreo.add_out(
Output('OnUser1', targetname, 'Start', only_once=only_once))
if only_once:
# Remove each section after it's played..
choreo.add_out(Output('OnCompletion', '!self', 'Kill'), )
return choreo
def res_locking_input(inst: Entity, res: Property):
"""Executed on the input item, and evaluates to True if successful.
The parameter is an `instance:name;Input` value, which resets the item.
This must be executed after the `MarkLocking` results have run.
"""
from vbsp import IND_ITEM_NAMES, IND_PANEL_NAMES, VMF
in_name, in_inp = Output.parse_name(res.value)
targets = {
out.target
for out in
inst.outputs
# Skip toggle or indicator panel items.
if out.target not in IND_ITEM_NAMES
}
# No outputs, or 2+ - we can't convert in that case
if len(targets) != 1:
return False
target, = targets
try:
targ_inst, targ_out_name, targ_out, out_relay = LOCKABLE_ITEMS[target]
except KeyError:
# Some other item...
return False
# Remove the indicator panel instances.
ind_panels = {
out.target
for out in
inst.outputs
# Skip toggle or indicator panel items.
if out.target in IND_PANEL_NAMES
}
for pan_inst in VMF.by_class['func_instance']:
if pan_inst['targetname'] in ind_panels:
pan_inst.remove()
# Add an output pointing in the opposite direction.
if out_relay is None:
targ_inst.add_out(Output(
out=targ_out,
inst_out=targ_out_name,
targ=inst['targetname'],
inp=in_inp,
inst_in=in_name,
))
else:
from conditions.instances import add_global_input
add_global_input(
inst,
in_name,
in_inp,
rl_name=out_relay,
output=targ_out,
)
return True
def add_output(inst: Entity, prop: Property, target: str) -> None:
"""Add a customisable output to an instance."""
inst.add_out(Output(
prop['output', ''],
target,
prop['input', ''],
inst_in=prop['targ_in', ''],
inst_out=prop['targ_out', ''],
))
def res_add_output(inst: Entity, res: Property):
"""Add an output from an instance to a global or local name.
Values:
- `output`: The output name. Can be `<ITEM_ID:activate>` or `<ITEM_ID:deactivate>`
to lookup that item type.
- `target`: The name of the target entity
- `input`: The input to give
- `parm`: Parameters for the input
- `delay`: Delay for the output
- `only_once`: True to make the input last only once (overrides times)
- `times`: The number of times to trigger the input
"""
(
out_type,
out_id,
targ,
input_name,
parm,
delay,
times,
inst_in,
inst_out,
) = res.value
if out_type in ('activate', 'deactivate'):
try:
item_type = connections.ITEM_TYPES[out_id.casefold()]
except KeyError:
LOGGER.warning('"{}" has no connections!', out_id)
return
if out_type[0] == 'a':
if item_type.output_act is None:
return
inst_out, output = item_type.output_act
else:
if item_type.output_deact is None:
return
inst_out, output = item_type.output_deact
else:
output = resolve_value(inst, out_id)
inst_out = resolve_value(inst, inst_out)
inst.add_out(
Output(
resolve_value(inst, output),
local_name(inst, resolve_value(inst, targ)) or inst['targetname'],
resolve_value(inst, input_name),
resolve_value(inst, parm),
srctools.conv_float(resolve_value(inst, delay)),
times=times,
inst_out=resolve_value(inst, inst_out) or None,
inst_in=resolve_value(inst, inst_in) or None,
))
def add_output(inst, prop, target):
"""Add a customisable output to an instance."""
inst.add_out(
Output(
prop['output', ''],
target,
prop['input', ''],
inst_in=prop['targ_in', ''],
inst_out=prop['targ_out', ''],
))
def comp_trigger_goo(ctx: Context):
"""Creates triggers for Toxic Goo."""
for trig in ctx.vmf.by_class['comp_trigger_p2_goo']:
trig.remove()
outputs = trig.outputs.copy()
trig.outputs.clear()
failsafe_delay = conv_float(trig['failsafe_delay'], 0.5)
del trig['failsafe_delay']
if failsafe_delay < 0.01:
failsafe_delay = 0.01
hurt = trig.copy()
diss = trig.copy()
ctx.vmf.add_ents([hurt, diss])
hurt['classname'] = 'trigger_hurt'
hurt['damagetype'] = 262144 # Radiation
hurt['damage'] = hurt['damagecap'] = 10000
hurt['damagemodel'] = 0 # No doubling
hurt['nodmgforce'] = 1 # Don't throw players around.
hurt['spawnflags'] = 1 # Players.
del hurt['filtername']
diss['classname'] = 'trigger_multiple'
diss['spawnflags'] = 1096 # Physics, physics debris, everything
diss['wait'] = 0 # No delay.
diss['filtername'] = trig['dissolve_filter']
diss.add_out(
Output('OnStartTouch', '!activator', 'SilentDissolve'),
Output('OnStartTouch', '!activator', 'Kill', delay=failsafe_delay),
)
for out in outputs:
if out.output.casefold() == 'onkillplayer':
out.output = 'OnStartTouch'
hurt.add_out(out)
elif out.output.casefold() == 'ondissolvephysics':
out.output = 'OnStartTouch'
diss.add_out(out)
def res_add_output(inst: Entity, res: Property):
"""Add an output from an instance to a global or local name.
Values:
- output: The output name.Can be <ITEM_ID:activate> or <ITEM_ID:deactivate>
to lookup that item type.
- target: The name of the target entity
- input: The input to give
- parm: Parameters for the input
- delay: Delay for the output
- only_once: True to make the input last only once (overrides times)
- times: The number of times to trigger the input
"""
(
out_type,
out_id,
targ,
input_name,
parm,
delay,
times,
inst_in,
inst_out,
) = res.value
LOGGER.info('Conn: {}', res.value)
if out_type in ('activate', 'deactivate'):
try:
connection = CONNECTIONS[out_id]
except KeyError:
LOGGER.warning('"{}" has no connections!', out_id)
return
if out_type[0] == 'a':
inst_out, output = connection.out_act
else:
inst_out, output = connection.out_deact
else:
output = resolve_value(inst, out_id)
inst_out = resolve_value(inst, inst_out)
inst.add_out(
Output(
resolve_value(inst, output),
local_name(inst, resolve_value(inst, targ)),
resolve_value(inst, input_name),
resolve_value(inst, parm),
srctools.conv_float(resolve_value(inst, delay)),
times=times,
inst_out=resolve_value(inst, inst_out) or None,
inst_in=resolve_value(inst, inst_in) or None,
))
def add_io_command(
self,
output: Optional[Tuple[Optional[str], str]],
target: Union[Entity, str],
inp_cmd: str,
params: str = '',
delay: float = 0.0,
times: int = -1,
inst_in: Optional[str]=None,
) -> None:
"""Add an output to this item.
For convenience, if the output is None this does nothing.
"""
if output is None:
return
out_name, out_cmd = output
if not out_name:
out_name = '' # Dump the None.
out_name = conditions.resolve_value(self.inst, out_name)
if isinstance(target, Entity):
target = target['targetname']
try:
kv_setter = self._kv_setters[out_name]
except KeyError:
if out_name:
full_name = conditions.local_name(self.inst, out_name)
else:
full_name = self.name
kv_setter = self._kv_setters[out_name] = self.inst.map.create_ent(
'comp_kv_setter',
origin=self.inst['origin'],
target=full_name,
)
kv_setter.add_out(Output(
conditions.resolve_value(self.inst, out_cmd),
target,
inp_cmd,
params,
delay=delay,
times=times,
inst_in=inst_in,
))
def add_locking(item: Item):
"""Create IO to control buttons from the target item.
This allows items to customise how buttons behave.
"""
# If more than one, it's not logical to lock the button.
try:
[lock_conn] = item.inputs # type: Connection
except ValueError:
return
lock_button = lock_conn.from_item
if item.item_type.inf_lock_only and lock_button.timer is not None:
return
# Check the button doesn't also activate other things -
# we need exclusive control.
# Also the button actually needs to be lockable.
if len(lock_button.outputs) != 1 or not lock_button.item_type.lock_cmd:
return
instance_traits.get(item.inst).add('locking_targ')
instance_traits.get(lock_button.inst).add('locking_btn')
for output, input_cmds in [
(item.item_type.output_lock, lock_button.item_type.lock_cmd),
(item.item_type.output_unlock, lock_button.item_type.unlock_cmd)
]:
if not output:
continue
out_name, out_cmd = output
for cmd in input_cmds:
if cmd.target:
target = conditions.local_name(lock_button.inst, cmd.target)
else:
target = lock_button.inst
item.inst.add_out(
Output(
out_cmd,
target,
cmd.input,
cmd.params,
delay=cmd.delay,
times=cmd.times,
inst_out=out_name,
))
def res_global_input_setup(res: Property):
if res.has_children():
name = res['name', '']
inp_name, inp_command = Output.parse_name(res['input'])
return name, Output(
out=res['output', 'OnTrigger'],
targ=res['target', ''],
inp=inp_command,
inst_in=inp_name,
delay=srctools.conv_float(res['delay', '']),
param=res['param', ''],
)
else:
out = Output.parse(res)
out.output = '' # Don't need to store GlobalInput...
return '', out
def comp_trigger_coop(ctx: Context):
"""Creates a trigger which only activates with both players."""
for trig in ctx.vmf.by_class['comp_trigger_coop']:
trig['classname'] = 'trigger_playerteam'
trig['target_team'] = 0
only_once = conv_bool(trig['trigger_once'])
trig['trigger_once'] = 0
trig_name = trig['targetname']
if not trig_name:
# Give it something unique
trig['targetname'] = trig_name = '_comp_trigger_coop_' + str(
trig['hammer_id'])
man_name = trig_name + '_man'
manager = ctx.vmf.create_ent(
classname='logic_coop_manager',
origin=trig['origin'],
targetname=man_name,
# Should make it die if the trigger does.
parentname=trig_name,
)
for out in list(trig.outputs):
folded_out = out.output.casefold()
if folded_out == 'onstarttouchboth':
out.output = 'OnChangeToAllTrue'
elif folded_out == 'onendtouchboth':
out.output = 'OnChangeToAnyFalse'
else:
continue
trig.outputs.remove(out)
manager.add_out(out)
trig.add_out(
Output('OnStartTouchBluePlayer', man_name, 'SetStateATrue'),
Output('OnStartTouchOrangePlayer', man_name, 'SetStateBrue'),
Output('OnEndTouchBluePlayer', man_name, 'SetStateAFalse'),
Output('OnEndTouchOrangePlayer', man_name, 'SetStateBFalse'),
)
if only_once:
manager.add_out(
Output('OnChangeToAllTrue', man_name, 'Kill'),
Output('OnChangeToAllTrue', trig_name, 'Kill'),
)
# Only keep OnChangeToAllTrue outputs, and remove
# them once they've fired.
for out in list(manager):
if out.output.casefold() == 'onchangetoalltrue':
out.only_once = True
else:
manager.outputs.remove(out)
def res_global_input(inst: Entity, res: Property):
"""Trigger an input either on map spawn, or when a relay is triggered.
Arguments:
- "Input": the input to use, either a name or an instance: command.
- "Target": If set, a local name to send commands to.
- "Delay": Number of seconds to delay the input.
- "Name": If set the name of the logic_relay which must be triggered.
If not set the output will fire OnMapSpawn.
- "Output": The name of the output, defaulting to OnTrigger. Ignored
if Name is not set.
- "Param": The parameter for the output.
"""
name, inp_name, inp_command, output, delay, param, target = res.value
if name is not None:
name = conditions.resolve_value(inst, name)
if target is not None:
target = conditions.resolve_value(inst, target)
try:
glob_ent = GLOBAL_INPUT_ENTS[name]
except KeyError:
if name is None:
glob_ent = GLOBAL_INPUT_ENTS[None] = inst.map.create_ent(
classname='logic_auto',
origin=inst['origin'],
)
else:
glob_ent = GLOBAL_INPUT_ENTS[name] = inst.map.create_ent(
classname='logic_relay',
targetname=name,
origin=inst['origin'],
)
out = Output(
out=('OnMapSpawn' if name is None else output),
targ=(conditions.local_name(inst, target)
if target else inst['targetname']),
inp=inp_command,
inst_in=inp_name,
delay=delay,
param=conditions.resolve_value(inst, param),
)
glob_ent.add_out(out)
def res_global_input_setup(res: Property) -> tuple[str, Output]:
"""Pre-parse the global input."""
if res.has_children():
name = res['name', '']
if not name and res.bool('alsoonload'):
name = ON_LOAD
inp_name, inp_command = Output.parse_name(res['input'])
return name, Output(
out=res['output', 'OnTrigger'],
targ=res['target', ''],
inp=inp_command,
inst_in=inp_name,
delay=srctools.conv_float(res['delay', '']),
param=res['param', ''],
)
else:
out = Output.parse(res)
out.output = '' # Don't need to store GlobalInput...
return '', out
def global_input(
inst: Entity,
command: str,
proxy_name: str = None,
relay_name: str = None,
relay_out: str = 'OnTrigger',
target: str = None,
param='',
delay=0.0,
):
"""Create a global input."""
if relay_name is not None:
relay_name = conditions.resolve_value(inst, relay_name)
if target is not None:
target = conditions.resolve_value(inst, target)
try:
glob_ent = GLOBAL_INPUT_ENTS[relay_name]
except KeyError:
if relay_name is None:
glob_ent = GLOBAL_INPUT_ENTS[None] = inst.map.create_ent(
classname='logic_auto',
origin=inst['origin'],
)
else:
glob_ent = GLOBAL_INPUT_ENTS[relay_name] = inst.map.create_ent(
classname='logic_relay',
targetname=relay_name,
origin=inst['origin'],
)
out = Output(
out=('OnMapSpawn' if relay_name is None else relay_out),
targ=(conditions.local_name(inst, target)
if target else inst['targetname']),
inp=command,
inst_in=proxy_name,
delay=delay,
param=conditions.resolve_value(inst, param),
)
glob_ent.add_out(out)
def res_script_var(vmf: VMF, inst: Entity, res: Property):
"""Set a variable on a script, via a logic_auto.
Name is the local name for the script entity.
Var is the variable name.
Value is the value to set.
"""
global_input(
vmf,
inst['origin'],
Output(
'OnMapSpawn',
conditions.local_name(inst, inst.fixup.substitute(res['name'])),
'RunScriptCode',
param='{} <- {}'.format(
res['var'],
inst.fixup.substitute(res['value']),
),
),
)
def __init__(self, ent: Entity):
"""Convert the entity to have the right logic."""
self.scanner = None
self.persist_tv = conv_bool(ent.keys.pop('persist_tv', False))
pos = Vec.from_str(ent['origin'])
for prop in ent.map.by_class['prop_dynamic']:
if (Vec.from_str(prop['origin']) - pos).mag_sq() > 64**2:
continue
model = prop['model'].casefold().replace('\\', '/')
# Allow spelling this correctly, if you're not Valve.
if 'vacum_scanner_tv' in model or 'vacuum_scanner_tv' in model:
self.scanner = prop
prop.make_unique('_vac_scanner')
elif 'vacum_scanner_motion' in model or 'vacuum_scanner_motion' in model:
prop.make_unique('_vac_scanner')
ent.add_out(Output(self.pass_out_name, prop, "SetAnimation", "scan01"))
super(Straight, self).__init__(ent)
def res_fix_rotation_axis(ent: Entity, res: Property):
"""Generate a `func_rotating`, `func_door_rotating` or any similar entity.
This uses the orientation of the instance to detemine the correct
spawnflags to make it rotate in the correct direction. The brush
will be 2x2x2 units large, and always set to be non-solid.
- `Pos` and `name` are local to the
instance, and will set the `origin` and `targetname` respectively.
- `Keys` are any other keyvalues to be be set.
- `Flags` sets additional spawnflags. Multiple values may be
separated by `+`, and will be added together.
- `Classname` specifies which entity will be created, as well as
which other values will be set to specify the correct orientation.
- `AddOut` is used to add outputs to the generated entity. It takes
the options `Output`, `Target`, `Input`, `Param` and `Delay`. If
`Inst_targ` is defined, it will be used with the input to construct
an instance proxy input. If `OnceOnly` is set, the output will be
deleted when fired.
Permitted entities:
* `func_rotating`
* `func_door_rotating`
* `func_rot_button`
* `func_platrot`
"""
des_axis = res['axis', 'z'].casefold()
reverse = srctools.conv_bool(res['reversed', '0'])
door_type = res['classname', 'func_door_rotating']
# Extra stuff to apply to the flags (USE, toggle, etc)
flags = sum(
map(
# Add together multiple values
srctools.conv_int,
res['flags', '0'].split('+')))
name = conditions.local_name(ent, res['name', ''])
axis = Vec(**{des_axis: 1}).rotate_by_str(ent['angles', '0 0 0'])
pos = Vec.from_str(res['Pos', '0 0 0']).rotate_by_str(ent['angles',
'0 0 0'])
pos += Vec.from_str(ent['origin', '0 0 0'])
door_ent = vbsp.VMF.create_ent(
classname=door_type,
targetname=name,
origin=pos.join(' '),
)
conditions.set_ent_keys(door_ent, ent, res)
for output in res.find_all('AddOut'):
door_ent.add_out(
Output(
out=output['Output', 'OnUse'],
inp=output['Input', 'Use'],
targ=output['Target', ''],
inst_in=output['Inst_targ', None],
param=output['Param', ''],
delay=srctools.conv_float(output['Delay', '']),
times=(1 if srctools.conv_bool(output['OnceOnly',
False]) else -1),
))
# Generate brush
door_ent.solids = [vbsp.VMF.make_prism(pos - 1, pos + 1).solid]
if axis.x > 0 or axis.y > 0 or axis.z > 0:
# If it points forward, we need to reverse the rotating door
reverse = not reverse
flag_values = FLAG_ROTATING[door_type]
# Make the door always non-solid!
flags |= flag_values.get('solid_flags', 0)
# Add or remove flags as needed.
# flags |= bit sets it to 1.
# flags |= ~bit sets it to 0.
if axis.x != 0:
flags |= flag_values.get('x', 0)
else:
flags &= ~flag_values.get('x', 0)
if axis.y != 0:
flags |= flag_values.get('y', 0)
else:
flags &= ~flag_values.get('y', 0)
if axis.z != 0:
flags |= flag_values.get('z', 0)
else:
flags &= ~flag_values.get('z', 0)
if door_type == 'momentary_rot_button':
door_ent['startdirection'] = '1' if reverse else '-1'
else:
if reverse:
flags |= flag_values.get('rev', 0)
else:
flags &= ~flag_values.get('rev', 0)
door_ent['spawnflags'] = str(flags)
def res_conveyor_belt(vmf: VMF, inst: Entity, res: Property) -> None:
"""Create a conveyor belt.
* Options:
* `SegmentInst`: Generated at each square. (`track` is the name of the
path to attach to.)
* `TrackTeleport`: Set the track points so they teleport trains to the start.
* `Speed`: The fixup or number for the train speed.
* `MotionTrig`: If set, a trigger_multiple will be spawned that
`EnableMotion`s weighted cubes. The value is the name of the relevant filter.
* `EndOutput`: Adds an output to the last track. The value is the same as
outputs in VMFs.
`RotateSegments`: If true (default), force segments to face in the
direction of movement.
* `BeamKeys`: If set, a list of keyvalues to use to generate an env_beam
travelling from start to end. The origin is treated specially - X is
the distance from walls, y is the distance to the side, and z is the
height.
`RailTemplate`: A template for the track sections. This is made into a
non-solid func_brush, combining all sections.
* `NoPortalFloor`: If set, add a `func_noportal_volume` on the floor
under the track.
* `PaintFizzler`: If set, add a paint fizzler underneath the belt.
"""
move_dist = inst.fixup.int('$travel_distance')
if move_dist <= 2:
# There isn't room for a conveyor, so don't bother.
inst.remove()
return
orig_orient = Matrix.from_angle(Angle.from_str(inst['angles']))
move_dir = Vec(1, 0, 0) @ Angle.from_str(inst.fixup['$travel_direction'])
move_dir = move_dir @ orig_orient
start_offset = inst.fixup.float('$starting_position')
teleport_to_start = res.bool('TrackTeleport', True)
segment_inst_file = instanceLocs.resolve_one(res['SegmentInst', ''])
rail_template = res['RailTemplate', None]
track_speed = res['speed', None]
start_pos = Vec.from_str(inst['origin'])
end_pos = start_pos + move_dist * move_dir
if start_offset > 0:
# If an oscillating platform, move to the closest side..
offset = start_offset * move_dir
# The instance is placed this far along, so move back to the end.
start_pos -= offset
end_pos -= offset
if start_offset > 0.5:
# Swap the direction of movement..
start_pos, end_pos = end_pos, start_pos
inst['origin'] = start_pos
norm = orig_orient.up()
if res.bool('rotateSegments', True):
orient = Matrix.from_basis(x=move_dir, z=norm)
inst['angles'] = orient.to_angle()
else:
orient = orig_orient
# Add the EnableMotion trigger_multiple seen in platform items.
# This wakes up cubes when it starts moving.
motion_filter = res['motionTrig', None]
# Disable on walls, or if the conveyor can't be turned on.
if norm != (0, 0, 1) or inst.fixup['$connectioncount'] == '0':
motion_filter = None
track_name = conditions.local_name(inst, 'segment_{}')
rail_temp_solids = []
last_track = None
# Place tracks at the top, so they don't appear inside wall sections.
track_start: Vec = start_pos + 48 * norm
track_end: Vec = end_pos + 48 * norm
for index, pos in enumerate(track_start.iter_line(track_end, stride=128),
start=1):
track = vmf.create_ent(
classname='path_track',
targetname=track_name.format(index) + '-track',
origin=pos,
spawnflags=0,
orientationtype=0, # Don't rotate
)
if track_speed is not None:
track['speed'] = track_speed
if last_track:
last_track['target'] = track['targetname']
if index == 1 and teleport_to_start:
track['spawnflags'] = 16 # Teleport here..
last_track = track
# Don't place at the last point - it doesn't teleport correctly,
# and would be one too many.
if segment_inst_file and pos != track_end:
seg_inst = conditions.add_inst(
vmf,
targetname=track_name.format(index),
file=segment_inst_file,
origin=pos,
angles=orient,
)
seg_inst.fixup.update(inst.fixup)
if rail_template:
temp = template_brush.import_template(
vmf,
rail_template,
pos,
orient,
force_type=template_brush.TEMP_TYPES.world,
add_to_map=False,
)
rail_temp_solids.extend(temp.world)
if rail_temp_solids:
vmf.create_ent(
classname='func_brush',
origin=track_start,
spawnflags=1, # Ignore +USE
solidity=1, # Not solid
vrad_brush_cast_shadows=1,
drawinfastreflection=1,
).solids = rail_temp_solids
if teleport_to_start:
# Link back to the first track..
last_track['target'] = track_name.format(1) + '-track'
# Generate an env_beam pointing from the start to the end of the track.
try:
beam_keys = res.find_key('BeamKeys')
except LookupError:
pass
else:
beam = vmf.create_ent(classname='env_beam')
beam_off = beam_keys.vec('origin', 0, 63, 56)
for prop in beam_keys:
beam[prop.real_name] = prop.value
# Localise the targetname so it can be triggered..
beam['LightningStart'] = beam['targetname'] = conditions.local_name(
inst, beam['targetname', 'beam'])
del beam['LightningEnd']
beam['origin'] = start_pos + Vec(
-beam_off.x,
beam_off.y,
beam_off.z,
) @ orient
beam['TargetPoint'] = end_pos + Vec(
+beam_off.x,
beam_off.y,
beam_off.z,
) @ orient
# Allow adding outputs to the last path_track.
for prop in res.find_all('EndOutput'):
output = Output.parse(prop)
output.output = 'OnPass'
output.inst_out = None
output.comma_sep = False
output.target = conditions.local_name(inst, output.target)
last_track.add_out(output)
if motion_filter is not None:
motion_trig = vmf.create_ent(
classname='trigger_multiple',
targetname=conditions.local_name(inst, 'enable_motion_trig'),
origin=start_pos,
filtername=motion_filter,
startDisabled=1,
wait=0.1,
)
motion_trig.add_out(
Output('OnStartTouch', '!activator', 'ExitDisabledState'))
# Match the size of the original...
motion_trig.solids.append(
vmf.make_prism(
start_pos + Vec(72, -56, 58) @ orient,
end_pos + Vec(-72, 56, 144) @ orient,
mat=consts.Tools.TRIGGER,
).solid)
if res.bool('NoPortalFloor'):
# Block portals on the floor..
floor_noportal = vmf.create_ent(
classname='func_noportal_volume',
origin=track_start,
)
floor_noportal.solids.append(
vmf.make_prism(
start_pos + Vec(-60, -60, -66) @ orient,
end_pos + Vec(60, 60, -60) @ orient,
mat=consts.Tools.INVISIBLE,
).solid)
# A brush covering under the platform.
base_trig = vmf.make_prism(
start_pos + Vec(-64, -64, 48) @ orient,
end_pos + Vec(64, 64, 56) @ orient,
mat=consts.Tools.INVISIBLE,
).solid
vmf.add_brush(base_trig)
# Make a paint_cleanser under the belt..
if res.bool('PaintFizzler'):
pfizz = vmf.create_ent(
classname='trigger_paint_cleanser',
origin=start_pos,
)
pfizz.solids.append(base_trig.copy())
for face in pfizz.sides():
face.mat = consts.Tools.TRIGGER
def res_resizeable_trigger(vmf: VMF, res: Property):
"""Replace two markers with a trigger brush.
This is run once to affect all of an item.
Options:
* `markerInst`: <ITEM_ID:1,2> value referencing the marker instances, or a filename.
* `markerItem`: The item's ID
* `previewConf`: A item config which enables/disables the preview overlay.
* `previewInst`: An instance to place at the marker location in preview mode.
This should contain checkmarks to display the value when testing.
* `previewMat`: If set, the material to use for an overlay func_brush.
The brush will be parented to the trigger, so it vanishes once killed.
It is also non-solid.
* `previewScale`: The scale for the func_brush materials.
* `previewActivate`, `previewDeactivate`: The VMF output to turn the
previewInst on and off.
* `triggerActivate, triggerDeactivate`: The `instance:name;Output`
outputs used when the trigger turns on or off.
* `coopVar`: The instance variable which enables detecting both Coop players.
The trigger will be a trigger_playerteam.
* `coopActivate, coopDeactivate`: The `instance:name;Output` outputs used
when coopVar is enabled. These should be suitable for a logic_coop_manager.
* `coopOnce`: If true, kill the manager after it first activates.
* `keys`: A block of keyvalues for the trigger brush. Origin and targetname
will be set automatically.
* `localkeys`: The same as above, except values will be changed to use
instance-local names.
"""
marker = instanceLocs.resolve(res['markerInst'])
marker_names = set()
for inst in vmf.by_class['func_instance']:
if inst['file'].casefold() in marker:
marker_names.add(inst['targetname'])
# Unconditionally delete from the map, so it doesn't
# appear even if placed wrongly.
inst.remove()
if not marker_names: # No markers in the map - abort
return RES_EXHAUSTED
item_id = res['markerItem']
# Synthesise the item type used for the final trigger.
item_type_sp = connections.ItemType(
id=item_id + ':TRIGGER',
output_act=Output.parse_name(res['triggerActivate',
'OnStartTouchAll']),
output_deact=Output.parse_name(res['triggerDeactivate',
'OnEndTouchAll']),
)
# For Coop, we add a logic_coop_manager in the mix so both players can
# be handled.
try:
coop_var = res['coopVar']
except LookupError:
coop_var = item_type_coop = None
coop_only_once = False
else:
coop_only_once = res.bool('coopOnce')
item_type_coop = connections.ItemType(
id=item_id + ':TRIGGER_COOP',
output_act=Output.parse_name(res['coopActivate',
'OnChangeToAllTrue']),
output_deact=Output.parse_name(res['coopDeactivate',
'OnChangeToAnyFalse']),
)
# Display preview overlays if it's preview mode, and the config is true
pre_act = pre_deact = None
if vbsp.IS_PREVIEW and vbsp_options.get_itemconf(res['previewConf', ''],
False):
preview_mat = res['previewMat', '']
preview_inst_file = res['previewInst', '']
preview_scale = res.float('previewScale', 0.25)
# None if not found.
with suppress(LookupError):
pre_act = Output.parse(res.find_key('previewActivate'))
with suppress(LookupError):
pre_deact = Output.parse(res.find_key('previewDeactivate'))
else:
# Deactivate the preview_ options when publishing.
preview_mat = preview_inst_file = ''
preview_scale = 0.25
# Now go through each brush.
# We do while + pop to allow removing both names each loop through.
todo_names = set(marker_names)
while todo_names:
targ = todo_names.pop()
mark1 = connections.ITEMS.pop(targ)
for conn in mark1.outputs:
if conn.to_item.name in marker_names:
mark2 = conn.to_item
conn.remove() # Delete this connection.
todo_names.discard(mark2.name)
del connections.ITEMS[mark2.name]
break
else:
if not mark1.inputs:
# If the item doesn't have any connections, 'connect'
# it to itself so we'll generate a 1-block trigger.
mark2 = mark1
else:
# It's a marker with an input, the other in the pair
# will handle everything.
# But reinstate it in ITEMS.
connections.ITEMS[targ] = mark1
continue
inst1 = mark1.inst
inst2 = mark2.inst
is_coop = coop_var is not None and vbsp.GAME_MODE == 'COOP' and (
inst1.fixup.bool(coop_var) or inst2.fixup.bool(coop_var))
bbox_min, bbox_max = Vec.bbox(Vec.from_str(inst1['origin']),
Vec.from_str(inst2['origin']))
origin = (bbox_max + bbox_min) / 2
# Extend to the edge of the blocks.
bbox_min -= 64
bbox_max += 64
out_ent = trig_ent = vmf.create_ent(
classname='trigger_multiple', # Default
targetname=targ,
origin=origin,
angles='0 0 0',
)
trig_ent.solids = [
vmf.make_prism(
bbox_min,
bbox_max,
mat=const.Tools.TRIGGER,
).solid,
]
# Use 'keys' and 'localkeys' blocks to set all the other keyvalues.
conditions.set_ent_keys(trig_ent, inst, res)
if is_coop:
trig_ent['spawnflags'] = '1' # Clients
trig_ent['classname'] = 'trigger_playerteam'
out_ent = manager = vmf.create_ent(
classname='logic_coop_manager',
targetname=conditions.local_name(inst, 'man'),
origin=origin,
)
item = connections.Item(
out_ent,
item_type_coop,
mark1.ant_floor_style,
mark1.ant_wall_style,
)
if coop_only_once:
# Kill all the ents when both players are present.
manager.add_out(
Output('OnChangeToAllTrue', manager, 'Kill'),
Output('OnChangeToAllTrue', targ, 'Kill'),
)
trig_ent.add_out(
Output('OnStartTouchBluePlayer', manager, 'SetStateATrue'),
Output('OnStartTouchOrangePlayer', manager, 'SetStateBTrue'),
Output('OnEndTouchBluePlayer', manager, 'SetStateAFalse'),
Output('OnEndTouchOrangePlayer', manager, 'SetStateBFalse'),
)
else:
item = connections.Item(
trig_ent,
item_type_sp,
mark1.ant_floor_style,
mark1.ant_wall_style,
)
# Register, and copy over all the antlines.
connections.ITEMS[item.name] = item
item.ind_panels = mark1.ind_panels | mark2.ind_panels
item.antlines = mark1.antlines | mark2.antlines
item.shape_signs = mark1.shape_signs + mark2.shape_signs
if preview_mat:
preview_brush = vmf.create_ent(
classname='func_brush',
parentname=targ,
origin=origin,
Solidity='1', # Not solid
drawinfastreflection='1', # Draw in goo..
# Disable shadows and lighting..
disableflashlight='1',
disablereceiveshadows='1',
disableshadowdepth='1',
disableshadows='1',
)
preview_brush.solids = [
# Make it slightly smaller, so it doesn't z-fight with surfaces.
vmf.make_prism(
bbox_min + 0.5,
bbox_max - 0.5,
mat=preview_mat,
).solid,
]
for face in preview_brush.sides():
face.scale = preview_scale
if preview_inst_file:
pre_inst = vmf.create_ent(
classname='func_instance',
targetname=targ + '_preview',
file=preview_inst_file,
# Put it at the second marker, since that's usually
# closest to antlines if present.
origin=inst2['origin'],
)
if pre_act is not None:
out = pre_act.copy()
out.inst_out, out.output = item.output_act()
out.target = conditions.local_name(pre_inst, out.target)
out_ent.add_out(out)
if pre_deact is not None:
out = pre_deact.copy()
out.inst_out, out.output = item.output_deact()
out.target = conditions.local_name(pre_inst, out.target)
out_ent.add_out(out)
for conn in mark1.outputs | mark2.outputs:
conn.from_item = item
return RES_EXHAUSTED
def res_fix_rotation_axis(vmf: VMF, ent: Entity, res: Property):
"""Properly setup rotating brush entities to match the instance.
This uses the orientation of the instance to determine the correct
spawnflags to make it rotate in the correct direction.
This can either modify an existing entity (which may be in an instance),
or generate a new one. The generated brush will be 2x2x2 units large,
and always set to be non-solid.
For both modes:
- `Axis`: specifies the rotation axis local to the instance.
- `Reversed`: If set, flips the direction around.
- `Classname`: Specifies which entity, since the spawnflags required varies.
For application to an existing entity:
- `ModifyTarget`: The local name of the entity to modify.
For brush generation mode:
- `Pos` and `name` are local to the
instance, and will set the `origin` and `targetname` respectively.
- `Keys` are any other keyvalues to be be set.
- `Flags` sets additional spawnflags. Multiple values may be
separated by `+`, and will be added together.
- `Classname` specifies which entity will be created, as well as
which other values will be set to specify the correct orientation.
- `AddOut` is used to add outputs to the generated entity. It takes
the options `Output`, `Target`, `Input`, `Inst_targ`, `Param` and `Delay`. If
`Inst_targ` is defined, it will be used with the input to construct
an instance proxy input. If `OnceOnly` is set, the output will be
deleted when fired.
Permitted entities:
* [`func_door_rotating`](https://developer.valvesoftware.com/wiki/func_door_rotating)
* [`func_platrot`](https://developer.valvesoftware.com/wiki/func_platrot)
* [`func_rot_button`](https://developer.valvesoftware.com/wiki/func_rot_button)
* [`func_rotating`](https://developer.valvesoftware.com/wiki/func_rotating)
* [`momentary_rot_button`](https://developer.valvesoftware.com/wiki/momentary_rot_button)
"""
des_axis = res['axis', 'z'].casefold()
reverse = res.bool('reversed')
door_type = res['classname', 'func_door_rotating']
orient = Matrix.from_angle(Angle.from_str(ent['angles']))
axis = round(Vec.with_axes(des_axis, 1) @ orient, 6)
if axis.x > 0 or axis.y > 0 or axis.z > 0:
# If it points forward, we need to reverse the rotating door
reverse = not reverse
axis = abs(axis)
try:
flag_values = FLAG_ROTATING[door_type]
except KeyError:
LOGGER.warning('Unknown rotating brush type "{}"!', door_type)
return
name = res['ModifyTarget', '']
door_ent: Entity | None
if name:
name = conditions.local_name(ent, name)
setter_loc = ent['origin']
door_ent = None
spawnflags = 0
else:
# Generate a brush.
name = conditions.local_name(ent, res['name', ''])
pos = res.vec('Pos') @ Angle.from_str(ent['angles', '0 0 0'])
pos += Vec.from_str(ent['origin', '0 0 0'])
setter_loc = str(pos)
door_ent = vmf.create_ent(
classname=door_type,
targetname=name,
origin=pos.join(' '),
)
# Extra stuff to apply to the flags (USE, toggle, etc)
spawnflags = sum(
map(
# Add together multiple values
srctools.conv_int,
res['flags', '0'].split('+')
# Make the door always non-solid!
)) | flag_values.get('solid_flags', 0)
conditions.set_ent_keys(door_ent, ent, res)
for output in res.find_all('AddOut'):
door_ent.add_out(
Output(
out=output['Output', 'OnUse'],
inp=output['Input', 'Use'],
targ=output['Target', ''],
inst_in=output['Inst_targ', None],
param=output['Param', ''],
delay=srctools.conv_float(output['Delay', '']),
times=(1 if srctools.conv_bool(output['OnceOnly',
False]) else -1),
))
# Generate brush
door_ent.solids = [vmf.make_prism(pos - 1, pos + 1).solid]
# Add or remove flags as needed
for flag, value in zip(
('x', 'y', 'z', 'rev'),
[axis.x > 1e-6, axis.y > 1e-6, axis.z > 1e-6, reverse],
):
if flag not in flag_values:
continue
if door_ent is not None:
if value:
spawnflags |= flag_values[flag]
else:
spawnflags &= ~flag_values[flag]
else: # Place a KV setter to set this.
vmf.create_ent(
'comp_kv_setter',
origin=setter_loc,
target=name,
mode='flags',
kv_name=flag_values[flag],
kv_value_global=value,
)
if door_ent is not None:
door_ent['spawnflags'] = spawnflags
# This ent uses a keyvalue for reversing...
if door_type == 'momentary_rot_button':
vmf.create_ent(
'comp_kv_setter',
origin=setter_loc,
target=name,
mode='kv',
kv_name='StartDirection',
kv_value_global='1' if reverse else '-1',
)
def res_make_tag_fizzler(vmf: VMF, inst: Entity, res: Property):
"""Add an Aperture Tag Paint Gun activation fizzler.
These fizzlers are created via signs, and work very specially.
This must be before -250 so it runs before fizzlers and connections.
"""
(
sign_offset,
fizz_conn_conf,
inst_frame_double,
inst_frame_single,
blue_sign_on,
blue_sign_off,
oran_sign_on,
oran_sign_off,
) = res.value # type: int, Optional[connections.Config], str, str, str, str, str, str
import vbsp
if options.get(str, 'game_id') != utils.STEAM_IDS['TAG']:
# Abort - TAG fizzlers shouldn't appear in any other game!
inst.remove()
return
fizzler = None
fizzler_item = None
# Look for the fizzler instance we want to replace.
sign_item = connections.ITEMS[inst['targetname']]
for conn in list(sign_item.outputs):
if conn.to_item.name in FIZZLERS:
if fizzler is None:
fizzler = FIZZLERS[conn.to_item.name]
fizzler_item = conn.to_item
else:
raise ValueError('Multiple fizzlers attached to a sign!')
conn.remove() # Regardless, remove the useless output.
sign_item.delete_antlines()
if fizzler is None:
# No fizzler - remove this sign
inst.remove()
return
if fizzler.fizz_type.id == TAG_FIZZ_ID:
LOGGER.warning('Two tag signs attached to one fizzler...')
inst.remove()
return
# Swap to the special Tag Fizzler type.
fizzler.fizz_type = FIZZ_TYPES[TAG_FIZZ_ID]
# And also swap the connection's type.
if fizz_conn_conf is not None:
fizzler_item.config = fizz_conn_conf
fizzler_item.enable_cmd = fizz_conn_conf.enable_cmd
fizzler_item.disable_cmd = fizz_conn_conf.disable_cmd
fizzler_item.sec_enable_cmd = fizz_conn_conf.sec_enable_cmd
fizzler_item.sec_disable_cmd = fizz_conn_conf.sec_disable_cmd
sign_loc = (
# The actual location of the sign - on the wall
Vec.from_str(inst['origin']) +
Vec(0, 0, -64).rotate_by_str(inst['angles']))
fizz_norm_axis = fizzler.normal().axis()
# Now deal with the visual aspect:
# Blue signs should be on top.
blue_enabled = inst.fixup.bool('$start_enabled')
oran_enabled = inst.fixup.bool('$start_reversed')
# If True, single-color signs will also turn off the other color.
# This also means we always show both signs.
# If both are enabled or disabled, this has no effect.
disable_other = (not inst.fixup.bool('$disable_autorespawn', True)
and blue_enabled != oran_enabled)
# Delete fixups now, they aren't useful.
inst.fixup.clear()
if not blue_enabled and not oran_enabled:
# Hide the sign in this case!
inst.remove()
inst_angle = srctools.parse_vec_str(inst['angles'])
inst_normal = Vec(0, 0, 1).rotate(*inst_angle)
loc = Vec.from_str(inst['origin'])
if disable_other or (blue_enabled and oran_enabled):
inst['file'] = inst_frame_double
# On a wall, and pointing vertically
if inst_normal.z == 0 and Vec(y=1).rotate(*inst_angle).z:
# They're vertical, make sure blue's on top!
blue_loc = Vec(loc.x, loc.y, loc.z + sign_offset)
oran_loc = Vec(loc.x, loc.y, loc.z - sign_offset)
# If orange is enabled, with two frames put that on top
# instead since it's more important
if disable_other and oran_enabled:
blue_loc, oran_loc = oran_loc, blue_loc
else:
offset = Vec(0, sign_offset, 0).rotate(*inst_angle)
blue_loc = loc + offset
oran_loc = loc - offset
else:
inst['file'] = inst_frame_single
# They're always centered
blue_loc = loc
oran_loc = loc
if inst_normal.z != 0:
# If on floors/ceilings, rotate to point at the fizzler!
sign_floor_loc = sign_loc.copy()
sign_floor_loc.z = 0 # We don't care about z-positions.
s, l = Vec.bbox(itertools.chain.from_iterable(fizzler.emitters))
if fizz_norm_axis == 'z':
# For z-axis, just compare to the center point of the emitters.
sign_dir = ((s.x + l.x) / 2, (s.y + l.y) / 2, 0) - sign_floor_loc
else:
# For the other two, we compare to the line,
# or compare to the closest side (in line with the fizz)
if fizz_norm_axis == 'x': # Extends in Y direction
other_axis = 'y'
side_min = s.y
side_max = l.y
normal = s.x
else: # Extends in X direction
other_axis = 'x'
side_min = s.x
side_max = l.x
normal = s.y
# Right in line with the fizzler. Point at the closest emitter.
if abs(sign_floor_loc[other_axis] - normal) < 32:
# Compare to the closest side.
sign_dir = min(
(sign_floor_loc - Vec.with_axes(
fizz_norm_axis,
side_min,
other_axis,
normal,
), sign_floor_loc - Vec.with_axes(
fizz_norm_axis,
side_max,
other_axis,
normal,
)),
key=Vec.mag,
)
else:
# Align just based on whether we're in front or behind.
sign_dir = Vec.with_axes(
fizz_norm_axis,
normal - sign_floor_loc[fizz_norm_axis]).norm()
sign_yaw = math.degrees(math.atan2(sign_dir.y, sign_dir.x))
# Round to nearest 90 degrees
# Add 45 so the switchover point is at the diagonals
sign_yaw = (sign_yaw + 45) // 90 * 90
# Rotate to fit the instances - south is down
sign_yaw = int(sign_yaw - 90) % 360
if inst_normal.z > 0:
sign_angle = '0 {} 0'.format(sign_yaw)
elif inst_normal.z < 0:
# Flip upside-down for ceilings
sign_angle = '0 {} 180'.format(sign_yaw)
else:
raise AssertionError('Cannot be zero here!')
else:
# On a wall, face upright
sign_angle = PETI_INST_ANGLE[inst_normal.as_tuple()]
# If disable_other, we show off signs. Otherwise we don't use that sign.
blue_sign = blue_sign_on if blue_enabled else blue_sign_off if disable_other else None
oran_sign = oran_sign_on if oran_enabled else oran_sign_off if disable_other else None
if blue_sign:
vmf.create_ent(
classname='func_instance',
file=blue_sign,
targetname=inst['targetname'],
angles=sign_angle,
origin=blue_loc.join(' '),
)
if oran_sign:
vmf.create_ent(
classname='func_instance',
file=oran_sign,
targetname=inst['targetname'],
angles=sign_angle,
origin=oran_loc.join(' '),
)
# Now modify the fizzler...
# Subtract the sign from the list of connections, but don't go below
# zero
fizzler.base_inst.fixup['$connectioncount'] = str(
max(
0,
srctools.conv_int(fizzler.base_inst.fixup['$connectioncount', ''])
- 1))
# Find the direction the fizzler normal is.
# Signs will associate with the given side!
bbox_min, bbox_max = fizzler.emitters[0]
sign_center = (bbox_min[fizz_norm_axis] + bbox_max[fizz_norm_axis]) / 2
# Figure out what the sides will set values to...
pos_blue = False
pos_oran = False
neg_blue = False
neg_oran = False
if sign_loc[fizz_norm_axis] < sign_center:
pos_blue = blue_enabled
pos_oran = oran_enabled
else:
neg_blue = blue_enabled
neg_oran = oran_enabled
# If it activates the paint gun, use different textures
fizzler.tag_on_pos = pos_blue or pos_oran
fizzler.tag_on_neg = neg_blue or neg_oran
# Now make the trigger ents. We special-case these since they need to swap
# depending on the sign config and position.
if vbsp.GAME_MODE == 'COOP':
# We need ATLAS-specific triggers
pos_trig = vmf.create_ent(classname='trigger_playerteam', )
neg_trig = vmf.create_ent(classname='trigger_playerteam', )
output = 'OnStartTouchBluePlayer'
else:
pos_trig = vmf.create_ent(classname='trigger_multiple', )
neg_trig = vmf.create_ent(
classname='trigger_multiple',
spawnflags='1',
)
output = 'OnStartTouch'
pos_trig['origin'] = neg_trig['origin'] = fizzler.base_inst['origin']
pos_trig['spawnflags'] = neg_trig['spawnflags'] = '1' # Clients Only
pos_trig['targetname'] = local_name(fizzler.base_inst, 'trig_pos')
neg_trig['targetname'] = local_name(fizzler.base_inst, 'trig_neg')
pos_trig['startdisabled'] = neg_trig['startdisabled'] = (
not fizzler.base_inst.fixup.bool('start_enabled'))
pos_trig.outputs = [
Output(output, neg_trig, 'Enable'),
Output(output, pos_trig, 'Disable'),
]
neg_trig.outputs = [
Output(output, pos_trig, 'Enable'),
Output(output, neg_trig, 'Disable'),
]
voice_attr = vbsp.settings['has_attr']
if blue_enabled or disable_other:
# If this is blue/oran only, don't affect the other color
neg_trig.outputs.append(
Output(
output,
'@BlueIsEnabled',
'SetValue',
param=srctools.bool_as_int(neg_blue),
))
pos_trig.outputs.append(
Output(
output,
'@BlueIsEnabled',
'SetValue',
param=srctools.bool_as_int(pos_blue),
))
if blue_enabled:
# Add voice attributes - we have the gun and gel!
voice_attr['bluegelgun'] = True
voice_attr['bluegel'] = True
voice_attr['bouncegun'] = True
voice_attr['bouncegel'] = True
if oran_enabled or disable_other:
neg_trig.outputs.append(
Output(
output,
'@OrangeIsEnabled',
'SetValue',
param=srctools.bool_as_int(neg_oran),
))
pos_trig.outputs.append(
Output(
output,
'@OrangeIsEnabled',
'SetValue',
param=srctools.bool_as_int(pos_oran),
))
if oran_enabled:
voice_attr['orangegelgun'] = True
voice_attr['orangegel'] = True
voice_attr['speedgelgun'] = True
voice_attr['speedgel'] = True
if not oran_enabled and not blue_enabled:
# If both are disabled, we must shutdown the gun when touching
# either side - use neg_trig for that purpose!
# We want to get rid of pos_trig to save ents
vmf.remove_ent(pos_trig)
neg_trig['targetname'] = local_name(fizzler.base_inst, 'trig_off')
neg_trig.outputs.clear()
neg_trig.add_out(
Output(output, '@BlueIsEnabled', 'SetValue', param='0'))
neg_trig.add_out(
Output(output, '@OrangeIsEnabled', 'SetValue', param='0'))
# Make the triggers.
for bbox_min, bbox_max in fizzler.emitters:
bbox_min = bbox_min.copy() - 64 * fizzler.up_axis
bbox_max = bbox_max.copy() + 64 * fizzler.up_axis
# The triggers are 8 units thick, with a 32-unit gap in the middle
neg_min, neg_max = Vec(bbox_min), Vec(bbox_max)
neg_min[fizz_norm_axis] -= 24
neg_max[fizz_norm_axis] -= 16
pos_min, pos_max = Vec(bbox_min), Vec(bbox_max)
pos_min[fizz_norm_axis] += 16
pos_max[fizz_norm_axis] += 24
if blue_enabled or oran_enabled:
neg_trig.solids.append(
vmf.make_prism(
neg_min,
neg_max,
mat='tools/toolstrigger',
).solid, )
pos_trig.solids.append(
vmf.make_prism(
pos_min,
pos_max,
mat='tools/toolstrigger',
).solid, )
else:
# If neither enabled, use one trigger
neg_trig.solids.append(
vmf.make_prism(
neg_min,
pos_max,
mat='tools/toolstrigger',
).solid, )
def res_piston_plat(vmf: VMF, inst: Entity, res: Property) -> None:
"""Generates piston platforms with optimized logic."""
template: template_brush.Template
visgroup_names: List[str]
inst_filenames: Dict[str, str]
has_dn_fizz: bool
automatic_var: str
color_var: str
source_ent: str
snd_start: str
snd_loop: str
snd_stop: str
(
template,
visgroup_names,
inst_filenames,
has_dn_fizz,
automatic_var,
color_var,
source_ent,
snd_start,
snd_loop,
snd_stop,
) = res.value
min_pos = inst.fixup.int(FixupVars.PIST_BTM)
max_pos = inst.fixup.int(FixupVars.PIST_TOP)
start_up = inst.fixup.bool(FixupVars.PIST_IS_UP)
# Allow doing variable lookups here.
visgroup_names = [
conditions.resolve_value(inst, name) for name in visgroup_names
]
if len(ITEMS[inst['targetname']].inputs) == 0:
# No inputs. Check for the 'auto' var if applicable.
if automatic_var and inst.fixup.bool(automatic_var):
pass
# The item is automatically moving, so we generate the dynamics.
else:
# It's static, we just make that and exit.
position = max_pos if start_up else min_pos
inst.fixup[FixupVars.PIST_BTM] = position
inst.fixup[FixupVars.PIST_TOP] = position
static_inst = inst.copy()
vmf.add_ent(static_inst)
static_inst['file'] = inst_filenames['fullstatic_' + str(position)]
return
init_script = 'SPAWN_UP <- {}'.format('true' if start_up else 'false')
if snd_start and snd_stop:
packing.pack_files(vmf, snd_start, snd_stop, file_type='sound')
init_script += '; START_SND <- `{}`; STOP_SND <- `{}`'.format(
snd_start, snd_stop)
elif snd_start:
packing.pack_files(vmf, snd_start, file_type='sound')
init_script += '; START_SND <- `{}`'.format(snd_start)
elif snd_stop:
packing.pack_files(vmf, snd_stop, file_type='sound')
init_script += '; STOP_SND <- `{}`'.format(snd_stop)
script_ent = vmf.create_ent(
classname='info_target',
targetname=local_name(inst, 'script'),
vscripts='BEE2/piston/common.nut',
vscript_init_code=init_script,
origin=inst['origin'],
)
if has_dn_fizz:
script_ent['thinkfunction'] = 'FizzThink'
if start_up:
st_pos, end_pos = max_pos, min_pos
else:
st_pos, end_pos = min_pos, max_pos
script_ent.add_out(
Output('OnUser1', '!self', 'RunScriptCode',
'moveto({})'.format(st_pos)),
Output('OnUser2', '!self', 'RunScriptCode',
'moveto({})'.format(end_pos)),
)
origin = Vec.from_str(inst['origin'])
angles = Vec.from_str(inst['angles'])
off = Vec(z=128).rotate(*angles)
move_ang = off.to_angle()
# Index -> func_movelinear.
pistons = {} # type: Dict[int, Entity]
static_ent = vmf.create_ent('func_brush', origin=origin)
for pist_ind in [1, 2, 3, 4]:
pist_ent = inst.copy()
vmf.add_ent(pist_ent)
if pist_ind <= min_pos:
# It's below the lowest position, so it can be static.
pist_ent['file'] = inst_filenames['static_' + str(pist_ind)]
pist_ent['origin'] = brush_pos = origin + pist_ind * off
temp_targ = static_ent
else:
# It's a moving component.
pist_ent['file'] = inst_filenames['dynamic_' + str(pist_ind)]
if pist_ind > max_pos:
# It's 'after' the highest position, so it never extends.
# So simplify by merging those all.
# That's before this so it'll have to exist.
temp_targ = pistons[max_pos]
if start_up:
pist_ent['origin'] = brush_pos = origin + max_pos * off
else:
pist_ent['origin'] = brush_pos = origin + min_pos * off
pist_ent.fixup['$parent'] = 'pist' + str(max_pos)
else:
# It's actually a moving piston.
if start_up:
brush_pos = origin + pist_ind * off
else:
brush_pos = origin + min_pos * off
pist_ent['origin'] = brush_pos
pist_ent.fixup['$parent'] = 'pist' + str(pist_ind)
pistons[pist_ind] = temp_targ = vmf.create_ent(
'func_movelinear',
targetname=local_name(pist_ent, 'pist' + str(pist_ind)),
origin=brush_pos - off,
movedir=move_ang,
startposition=start_up,
movedistance=128,
speed=150,
)
if pist_ind - 1 in pistons:
pistons[pist_ind]['parentname'] = local_name(
pist_ent,
'pist' + str(pist_ind - 1),
)
if not pist_ent['file']:
# No actual instance, remove.
pist_ent.remove()
temp_result = template_brush.import_template(
template,
brush_pos,
angles,
force_type=template_brush.TEMP_TYPES.world,
add_to_map=False,
additional_visgroups={visgroup_names[pist_ind - 1]},
)
temp_targ.solids.extend(temp_result.world)
template_brush.retexture_template(
temp_result,
origin,
pist_ent.fixup,
generator=GenCat.PANEL,
)
# Associate any set panel with the same entity, if it's present.
tile_pos = Vec(z=-128)
tile_pos.localise(origin, angles)
panel: Optional[Panel] = None
try:
tiledef = TILES[tile_pos.as_tuple(), off.norm().as_tuple()]
except KeyError:
pass
else:
for panel in tiledef.panels:
if panel.same_item(inst):
break
else: # Checked all of them.
panel = None
if panel is not None:
if panel.brush_ent in vmf.entities and not panel.brush_ent.solids:
panel.brush_ent.remove()
panel.brush_ent = pistons[max(pistons.keys())]
panel.offset = st_pos * off
if not static_ent.solids and (panel is None
or panel.brush_ent is not static_ent):
static_ent.remove()
if snd_loop:
script_ent['classname'] = 'ambient_generic'
script_ent['message'] = snd_loop
script_ent['health'] = 10 # Volume
script_ent['pitch'] = '100'
script_ent['spawnflags'] = 16 # Start silent, looped.
script_ent['radius'] = 1024
if source_ent:
# Parent is irrelevant for actual entity locations, but it
# survives for the script to read.
script_ent['SourceEntityName'] = script_ent[
'parentname'] = local_name(inst, source_ent)
def res_resizeable_trigger(res: Property):
"""Replace two markers with a trigger brush.
This is run once to affect all of an item.
Options:
'markerInst': <ITEM_ID:1,2> value referencing the marker instances, or a filename.
'markerItem': The item's ID
'previewVar': A stylevar which enables/disables the preview overlay.
'previewinst': An instance to place at the marker location in preview mode.
This should contain checkmarks to display the value when testing.
'previewMat': If set, the material to use for an overlay func_brush.
The brush will be parented to the trigger, so it vanishes once killed.
It is also non-solid.
'previewScale': The scale for the func_brush materials.
'previewActivate', 'previewDeactivate': The 'instance:name;Input' value
to turn the previewInst on and off.
'triggerActivate, triggerDeactivate': The outputs used when the trigger
turns on or off.
'coopVar': The instance variable which enables detecting both Coop players.
The trigger will be a trigger_playerteam.
'coopActivate, coopDeactivate': The outputs used when coopVar is enabled.
These should be suitable for a logic_coop_manager.
'coopOnce': If true, kill the manager after it first activates.
'keys': A block of keyvalues for the trigger brush. Origin and targetname
will be set automatically.
'localkeys': The same as above, except values will be changed to use
instance-local names.
"""
marker = resolve_inst(res['markerInst'])
markers = {}
for inst in vbsp.VMF.by_class['func_instance']:
if inst['file'].casefold() in marker:
markers[inst['targetname']] = inst
if not markers: # No markers in the map - abort
return RES_EXHAUSTED
trig_act = res['triggerActivate', 'OnStartTouchAll']
trig_deact = res['triggerDeactivate','OnEndTouchAll']
coop_var = res['coopVar', None]
coop_act = res['coopActivate', 'OnChangeToAllTrue']
coop_deact = res['coopDeactivate', 'OnChangeToAnyFalse']
coop_only_once = res.bool('coopOnce')
marker_connection = conditions.CONNECTIONS[res['markerItem'].casefold()]
mark_act_name, mark_act_out = marker_connection.out_act
mark_deact_name, mark_deact_out = marker_connection.out_deact
del marker_connection
preview_var = res['previewVar', ''].casefold()
# Display preview overlays if it's preview mode, and the style var is true
# or does not exist
if vbsp.IS_PREVIEW and (not preview_var or vbsp.settings['style_vars'][preview_var]):
preview_mat = res['previewMat', '']
preview_inst_file = res['previewInst', '']
pre_act_name, pre_act_inp = Output.parse_name(
res['previewActivate', ''])
pre_deact_name, pre_deact_inp = Output.parse_name(
res['previewDeactivate', ''])
preview_scale = srctools.conv_float(res['previewScale', '0.25'], 0.25)
else:
# Deactivate the preview_ options when publishing.
preview_mat = preview_inst_file = ''
pre_act_name = pre_deact_name = None
pre_act_inp = pre_deact_inp = ''
preview_scale = 0.25
# Now convert each brush
# Use list() to freeze it, allowing us to delete from the dict
for targ, inst in list(markers.items()): # type: str, VLib.Entity
for out in inst.output_targets():
if out in markers:
other = markers[out] # type: Entity
del markers[out] # Don't let it get repeated
break
else:
if inst.fixup['$connectioncount'] == '0':
# If the item doesn't have any connections, 'connect'
# it to itself so we'll generate a 1-block trigger.
other = inst
else:
continue # It's a marker with an input, the other in the pair
# will handle everything.
for ent in {inst, other}:
# Only do once if inst == other
ent.remove()
is_coop = vbsp.GAME_MODE == 'COOP' and (
inst.fixup.bool(coop_var) or
other.fixup.bool(coop_var)
)
bbox_min, bbox_max = Vec.bbox(
Vec.from_str(inst['origin']),
Vec.from_str(other['origin'])
)
# Extend to the edge of the blocks.
bbox_min -= 64
bbox_max += 64
out_ent = trig_ent = vbsp.VMF.create_ent(
classname='trigger_multiple', # Default
# Use the 1st instance's name - that way other inputs control the
# trigger itself.
targetname=targ,
origin=inst['origin'],
angles='0 0 0',
)
trig_ent.solids = [
vbsp.VMF.make_prism(
bbox_min,
bbox_max,
mat=const.Tools.TRIGGER,
).solid,
]
# Use 'keys' and 'localkeys' blocks to set all the other keyvalues.
conditions.set_ent_keys(trig_ent, inst, res)
if is_coop:
trig_ent['spawnflags'] = '1' # Clients
trig_ent['classname'] = 'trigger_playerteam'
out_ent_name = conditions.local_name(inst, 'man')
out_ent = vbsp.VMF.create_ent(
classname='logic_coop_manager',
targetname=out_ent_name,
origin=inst['origin']
)
if coop_only_once:
# Kill all the ents when both players are present.
out_ent.add_out(
Output('OnChangeToAllTrue', out_ent_name, 'Kill'),
Output('OnChangeToAllTrue', targ, 'Kill'),
)
trig_ent.add_out(
Output('OnStartTouchBluePlayer', out_ent_name, 'SetStateATrue'),
Output('OnStartTouchOrangePlayer', out_ent_name, 'SetStateBTrue'),
Output('OnEndTouchBluePlayer', out_ent_name, 'SetStateAFalse'),
Output('OnEndTouchOrangePlayer', out_ent_name, 'SetStateBFalse'),
)
act_out = coop_act
deact_out = coop_deact
else:
act_out = trig_act
deact_out = trig_deact
if preview_mat:
preview_brush = vbsp.VMF.create_ent(
classname='func_brush',
parentname=targ,
origin=inst['origin'],
Solidity='1', # Not solid
drawinfastreflection='1', # Draw in goo..
# Disable shadows and lighting..
disableflashlight='1',
disablereceiveshadows='1',
disableshadowdepth='1',
disableshadows='1',
)
preview_brush.solids = [
# Make it slightly smaller, so it doesn't z-fight with surfaces.
vbsp.VMF.make_prism(
bbox_min + 0.5,
bbox_max - 0.5,
mat=preview_mat,
).solid,
]
for face in preview_brush.sides():
face.scale = preview_scale
if preview_inst_file:
vbsp.VMF.create_ent(
classname='func_instance',
targetname=targ + '_preview',
file=preview_inst_file,
# Put it at the second marker, since that's usually
# closest to antlines if present.
origin=other['origin'],
)
if pre_act_name and trig_act:
out_ent.add_out(Output(
trig_act,
targ + '_preview',
inst_in=pre_act_name,
inp=pre_act_inp,
))
if pre_deact_name and trig_deact:
out_ent.add_out(Output(
trig_deact,
targ + '_preview',
inst_in=pre_deact_name,
inp=pre_deact_inp,
))
# Now copy over the outputs from the markers, making it work.
for out in inst.outputs + other.outputs:
# Skip the output joining the two markers together.
if out.target == other['targetname']:
continue
if out.inst_out == mark_act_name and out.output == mark_act_out:
ent_out = act_out
elif out.inst_out == mark_deact_name and out.output == mark_deact_out:
ent_out = deact_out
else:
continue # Skip this output - it's somehow invalid for this item.
if not ent_out:
continue # Allow setting the output to "" to skip
out_ent.add_out(Output(
ent_out,
out.target,
inst_in=out.inst_in,
inp=out.input,
param=out.params,
delay=out.delay,
times=out.times,
))
return RES_EXHAUSTED
def vactube_transform(ctx: Context) -> None:
"""Implements the dynamic Vactube system."""
all_nodes = list(nodes.parse(ctx.vmf))
if not all_nodes:
# No vactubes.
return
LOGGER.info('{} vactube nodes found.', len(all_nodes))
LOGGER.debug('Nodes: {}', all_nodes)
if ctx.studiomdl is None:
raise ValueError('Vactubes present, but no studioMDL path provided! '
'Set the path to studiomdl.exe in srctools.vdf.')
obj_count, vac_objects, objects_code = objects.parse(ctx.vmf, ctx.pack)
groups = set(objects_code)
if not obj_count:
raise ValueError('Vactube nodes present, but no objects. '
'You need to add comp_vactube_objects to your map '
'to define the contents.')
LOGGER.info('{} vactube objects found.', obj_count)
# Now join all the nodes to each other.
# Tubes only have 90 degree bends, so a system should mostly be formed
# out of about 6 different normals. So group by that.
inputs_by_norm: Dict[Tuple[float, float, float],
List[Tuple[Vec, nodes.Node]]] = defaultdict(list)
for node in all_nodes:
# Spawners have no inputs.
if isinstance(node, nodes.Spawner):
node.has_input = True
else:
inputs_by_norm[node.input_norm().as_tuple()].append(
(node.vec_point(0.0), node))
norm_inputs = [(Vec(norm), node_lst)
for norm, node_lst in inputs_by_norm.items()]
sources: List[nodes.Spawner] = []
LOGGER.info('Linking nodes...')
for node in all_nodes:
# Destroyers (or Droppers) have no inputs.
if isinstance(node, nodes.Destroyer):
continue
for dest_type in node.out_types:
node.outputs[dest_type] = find_closest(
norm_inputs,
node,
node.vec_point(1.0, dest_type),
node.output_norm(dest_type),
)
if isinstance(node, nodes.Spawner):
sources.append(node)
if node.group not in groups:
group_warn = (f'Node {node} uses group "{node.group}", '
'which has no objects registered!')
if '' in groups:
# Fall back to ignoring the group, using the default
# blank one which is present.
LOGGER.warning("{} Using blank group.", group_warn)
node.group = ""
else:
raise ValueError(group_warn)
# Run through them again, check to see if any miss inputs.
for node in all_nodes:
if not node.has_input:
raise ValueError('No source found for junction '
f'{node.ent["targetname"]} at ({node.origin})!')
LOGGER.info('Generating animations...')
all_anims = animations.generate(sources)
# Sort the animations by their start and end, so they ideally are consistent.
all_anims.sort(key=lambda a: (a.start_node.origin, a.end_node.origin))
anim_mdl_name = Path('maps', ctx.bsp_path.stem, 'vac_anim.mdl')
# Now generate the animation model.
# First wipe the model.
full_loc = ctx.game.path / 'models' / anim_mdl_name
for ext in MDL_EXTS:
try:
full_loc.with_suffix(ext).unlink()
except FileNotFoundError:
pass
with TemporaryDirectory(prefix='vactubes_') as temp_dir:
# Make the reference mesh.
with open(temp_dir + '/ref.smd', 'wb') as f:
Mesh.build_bbox('root', 'demo', Vec(-32, -32, -32),
Vec(32, 32, 32)).export(f)
with open(temp_dir + '/prop.qc', 'w') as qc_file:
qc_file.write(QC_TEMPLATE.format(path=anim_mdl_name))
for i, anim in enumerate(all_anims):
anim.name = anim_name = f'anim_{i:03x}'
qc_file.write(
SEQ_TEMPLATE.format(name=anim_name, fps=animations.FPS))
with open(temp_dir + f'/{anim_name}.smd', 'wb') as f:
anim.mesh.export(f)
args = [
str(ctx.studiomdl),
'-nop4',
'-i', # Ignore warnings.
'-game',
str(ctx.game.path),
temp_dir + '/prop.qc',
]
LOGGER.info('Compiling vactube animations {}...', args)
subprocess.run(args)
# Ensure they're all packed.
for ext in MDL_EXTS:
try:
f = full_loc.with_suffix(ext).open('rb')
except FileNotFoundError:
pass
else:
with f:
ctx.pack.pack_file(Path('models',
anim_mdl_name.with_suffix(ext)),
data=f.read())
LOGGER.info('Setting up vactube ents...')
# Generate the shared template.
ctx.vmf.create_ent(
'prop_dynamic',
targetname='_vactube_temp_mover',
angles='0 270 0',
origin='-16384 0 1024',
model=str(Path('models', anim_mdl_name)),
rendermode=10,
solid=0,
spawnflags=64 | 256, # Use Hitboxes for Renderbox, collision disabled.
)
ctx.vmf.create_ent(
'prop_dynamic_override', # In case you use the physics model.
targetname='_vactube_temp_visual',
parentname='_vactube_temp_mover,move',
origin='-16384 0 1024',
model=nodes.CUBE_MODEL,
solid=0,
spawnflags=64 | 256, # Use Hitboxes for Renderbox, collision disabled.
)
ctx.vmf.create_ent(
'point_template',
targetname='_vactube_template',
template01='_vactube_temp_mover',
template02='_vactube_temp_visual',
origin='-16384 0 1024',
spawnflags='2', # Preserve names, remove originals.
)
# Group animations by their start point.
anims_by_start: Dict[nodes.Spawner,
List[animations.Animation]] = defaultdict(list)
for anim in all_anims:
anims_by_start[anim.start_node].append(anim)
# And create a dict to link droppers to the animation they want.
dropper_to_anim: Dict[nodes.Dropper, animations.Animation] = {}
for start_node, anims in anims_by_start.items():
spawn_maker = start_node.ent
spawn_maker['classname'] = 'env_entity_maker'
spawn_maker['entitytemplate'] = '_vactube_template'
spawn_maker['angles'] = '0 0 0'
orig_name = spawn_maker['targetname']
spawn_maker.make_unique('_vac_maker')
spawn_name = spawn_maker['targetname']
if start_node.is_auto:
spawn_timer = ctx.vmf.create_ent(
'logic_timer',
targetname=spawn_name + '_timer',
origin=start_node.origin,
startdisabled='0',
userandomtime='1',
lowerrandombound=start_node.time_min,
upperrandombound=start_node.time_max,
).make_unique()
spawn_timer.add_out(
Output('OnTimer', spawn_name, 'CallScriptFunction',
'make_cube'))
ctx.add_io_remap(
orig_name,
Output('EnableTimer', spawn_timer, 'Enable'),
Output('DisableTimer', spawn_timer, 'Disable'),
)
ctx.add_io_remap(
orig_name,
Output('ForceSpawn', spawn_name, 'CallScriptFunction',
'make_cube'),
)
# Now, generate the code so the VScript knows about the animations.
code = [
f'// Node: {start_node.ent["targetname"]}, {start_node.origin}'
]
for anim in anims:
target = anim.end_node
anim_speed = anim.start_node.speed
pass_code = ','.join([
f'Output({time:.2f}, "{node.ent["targetname"]}", '
f'{node.tv_code(anim_speed)})'
for time, node in anim.pass_points
])
cube_name = 'null'
if isinstance(target, nodes.Dropper):
cube_model = target.cube['model'].replace('\\', '/')
cube_skin = conv_int(target.cube['skin'])
try:
cube_name = vac_objects[start_node.group, cube_model,
cube_skin].id
except KeyError:
LOGGER.warning(
'Cube model "{}", skin {} is not a type of cube travelling '
'in this vactube!\n\n'
'Add a comp_vactube_object entity with this cube model'
# Mention groups if they're used, otherwise it's not important.
+ (f' with the group "{start_node.group}".'
if start_node.group else '.'),
cube_model,
cube_skin,
)
continue # Skip this animation so it's not broken.
else:
dropper_to_anim[target] = anim
code.append(f'{anim.name} <- anim("{anim.name}", {anim.duration}, '
f'{cube_name}, [{pass_code}]);')
spawn_maker['vscripts'] = ' '.join([
'srctools/vac_anim.nut',
objects_code[start_node.group],
ctx.pack.inject_vscript('\n'.join(code)),
])
# Now, go through each dropper and generate their logic.
for dropper, anim in dropper_to_anim.items():
# Pick the appropriate output to fire once left the dropper.
if dropper.cube['classname'] == 'prop_monster_box':
cube_input = 'BecomeMonster'
else:
cube_input = 'EnablePortalFunnel'
ctx.add_io_remap(
dropper.ent['targetname'],
# Used to dissolve the existing cube when respawning.
Output('FireCubeUser1', dropper.cube['targetname'], 'FireUser1'),
# Tell the spawn to redirect a cube to us.
Output(
'RequestSpawn',
anim.start_node.ent['targetname'],
'RunScriptCode',
f'{anim.name}.req_spawn = true',
),
Output('CubeReleased', '!activator', cube_input),
)
