def __init__(self, start: Node, typ: NodeType) -> None:
self.type = typ # Antlaser or corner?
self.nodes: list[Node] = [start]
# We use a frozenset here to ensure we don't double-up the links -
# users might accidentally do that.
self.links: set[frozenset[Node]] = set()
# For antline corners, each endpoint + normal -> the segment
self.ant_seg: dict[tuple[tuple[float, float, float],
tuple[float, float, float], ],
antlines.Segment] = {}
# Create a comp_relay to attach I/O to.
# The corners have an origin on the floor whereas lasers are normal.
if typ is NodeType.CORNER:
logic_pos = start.pos + 8 * start.orient.up()
logic_conf = CONFIG_ANTLINE
else:
logic_pos = start.pos - 56 * start.orient.up()
logic_conf = CONFIG_ANTLASER
logic_ent = start.inst.map.create_ent(
'comp_relay',
origin=logic_pos,
targetname=start.item.name,
)
# Create the item for the entire group of markers.
self.item = connections.Item(
logic_ent,
logic_conf,
ant_floor_style=start.item.ant_floor_style,
ant_wall_style=start.item.ant_wall_style,
)
connections.ITEMS[self.item.name] = self.item
def __init__(self, start: connections.Item):
self.nodes: List[connections.Item] = [start]
# We use a frozenset here to ensure we don't double-up the links -
# users might accidentally do that.
self.links: Set[FrozenSet[connections.Item]] = set()
# Create the item for the entire group of markers.
logic_ent = start.inst.map.create_ent(
'info_target',
origin=start.inst['origin'],
targetname=start.name,
)
self.item = connections.Item(
logic_ent,
AntLaserConn,
start.ant_floor_style,
start.ant_wall_style,
)
connections.ITEMS[self.item.name] = self.item
def res_reshape_fizzler(vmf: VMF, shape_inst: Entity, res: Property):
"""Convert a fizzler connected via the output to a new shape.
This allows for different placing of fizzler items.
* Each `segment` parameter should be a `x y z;x y z` pair of positions
that represent the ends of the fizzler.
* `up_axis` should be set to a normal vector pointing in the new 'upward'
direction.
* If none are connected, a regular fizzler will be synthesized.
The following fixup vars will be set to allow the shape to match the fizzler:
* `$uses_nodraw` will be 1 if the fizzler nodraws surfaces behind it.
"""
shape_name = shape_inst['targetname']
shape_item = connections.ITEMS.pop(shape_name)
shape_orient = Matrix.from_angle(Angle.from_str(shape_inst['angles']))
up_axis: Vec = round(res.vec('up_axis') @ shape_orient, 6)
for conn in shape_item.outputs:
fizz_item = conn.to_item
try:
fizz = fizzler.FIZZLERS[fizz_item.name]
except KeyError:
continue
# Detach this connection and remove traces of it.
conn.remove()
fizz.emitters.clear() # Remove old positions.
fizz.up_axis = up_axis
fizz.base_inst['origin'] = shape_inst['origin']
fizz.base_inst['angles'] = shape_inst['angles']
break
else:
# No fizzler, so generate a default.
# We create the fizzler instance, Fizzler object, and Item object
# matching it.
# This is hardcoded to use regular Emancipation Fields.
base_inst = conditions.add_inst(
vmf,
targetname=shape_name,
origin=shape_inst['origin'],
angles=shape_inst['angles'],
file=resolve_one('<ITEM_BARRIER_HAZARD:fizz_base>'),
)
base_inst.fixup.update(shape_inst.fixup)
fizz = fizzler.FIZZLERS[shape_name] = fizzler.Fizzler(
fizzler.FIZZ_TYPES['VALVE_MATERIAL_EMANCIPATION_GRID'],
up_axis,
base_inst,
[],
)
fizz_item = connections.Item(
base_inst,
connections.ITEM_TYPES['item_barrier_hazard'],
ant_floor_style=shape_item.ant_floor_style,
ant_wall_style=shape_item.ant_wall_style,
)
connections.ITEMS[shape_name] = fizz_item
# Transfer the input/outputs from us to the fizzler.
for inp in list(shape_item.inputs):
inp.to_item = fizz_item
for conn in list(shape_item.outputs):
conn.from_item = fizz_item
# If the fizzler has no outputs, then strip out antlines. Otherwise,
# they need to be transferred across, so we can't tell safely.
if fizz_item.output_act() is None and fizz_item.output_deact() is None:
shape_item.delete_antlines()
else:
shape_item.transfer_antlines(fizz_item)
fizz_base = fizz.base_inst
fizz_base['origin'] = shape_inst['origin']
origin = Vec.from_str(shape_inst['origin'])
fizz.has_cust_position = True
# Since the fizzler is moved elsewhere, it's the responsibility of
# the new item to have holes.
fizz.embedded = False
# So tell it whether or not it needs to do so.
shape_inst.fixup['$uses_nodraw'] = fizz.fizz_type.nodraw_behind
for seg_prop in res.find_all('Segment'):
vec1, vec2 = seg_prop.value.split(';')
seg_min_max = Vec.bbox(
Vec.from_str(vec1) @ shape_orient + origin,
Vec.from_str(vec2) @ shape_orient + origin,
)
fizz.emitters.append(seg_min_max)
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()
inst = None
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()
del inst # Make sure we don't use this later.
if not marker_names: # No markers in the map - abort
return RES_EXHAUSTED
item_id = res['markerItem']
# Synthesise the connection config used for the final trigger.
conn_conf_sp = connections.Config(
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 = conn_conf_coop = None
coop_only_once = False
else:
coop_only_once = res.bool('coopOnce')
conn_conf_coop = connections.Config(
id=item_id + ':TRIGGER',
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 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=options.get(Vec, "global_ents_loc"),
angles='0 0 0',
)
trig_ent.solids = [
vmf.make_prism(
bbox_min,
bbox_max,
mat=consts.Tools.TRIGGER,
).solid,
]
# Use 'keys' and 'localkeys' blocks to set all the other keyvalues.
conditions.set_ent_keys(trig_ent, inst1, 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(inst1, 'man'),
origin=origin,
)
item = connections.Item(
out_ent,
conn_conf_coop,
ant_floor_style=mark1.ant_floor_style,
ant_wall_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,
conn_conf_sp,
ant_floor_style=mark1.ant_floor_style,
ant_wall_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