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 flag_has_trait(inst: Entity, flag: Property):
"""Check if the instance has a specific 'trait', which is set by code.
Current traits:
* `white`, `black`: If editoritems indicates the colour of the item.
* `arrival_departure_transition`: `arrival_departure_transition_ents`.
* `barrier`: Glass/grating instances:
* `barrier_128`: Segment instance.
* `barrier_frame`: Any frame part.
* `frame_convex_corner`: Convex corner (unused).
* `frame_short`: Shortened frame to fit a corner.
* `frame_straight`: Straight frame section.
* `frame_corner`: Frame corner section.
* `frame_left`: Left half of the frame.
* `frame_right`: Right half of the frame.
* `floor_button`: ItemButtonFloor type item:
* `btn_ball`: Button Type = Sphere.
* `btn_cube`: Button Type = Cube
* `weighted`: Button Type = Weighted
* `dropperless`: A dropperless Cube:
* `cube_standard`: Normal Cube.
* `cube_companion`: Companion Cube.
* `cube_ball`: Edgeless Safety Cube.
* `cube_reflect`: Discouragment Redirection Cube.
* `cube_franken`: FrankenTurret.
* `preplaced`: The various pre-existing instances:
* `coop_corridor`: A Coop exit Corridor.
* `sp_corridor`: SP entry or exit corridor.
* `corridor_frame`: White/black door frame.
* `corridor_1`-`7`: The specified entry/exit corridor.
* `elevator`: An elevator instance.
* `entry_elevator`: Entry Elevator.
* `exit_elevator`: Exit Elevator.
* `entry_corridor`: Entry SP Corridor.
* `exit_corridor`: Exit SP/Coop Corridor.
* `fizzler`: A fizzler item:
* `fizzler_base`: Logic instance.
* `fizzler_model`: Model instance.
* `cust_shape`: Set if the fizzler has been moved to a custom position
by ReshapeFizzler.
* `locking_targ`: Target of a locking pedestal button.
* `locking_btn`: Locking pedestal button.
* `paint_dropper`: Gel Dropper:
* `paint_dropper_bomb`: Bomb-type dropper.
* `paint_dropper_sprayer`: Sprayer-type dropper.
* `panel_angled`: Angled Panel-type item.
* `track_platform`: Track Platform-style item:
* `plat_bottom`: Bottom frame.
* `plat_bottom_grate`: Grating.
* `plat_middle`: Middle frame.
* `plat_single`: One-long frame.
* `plat_top`: Top frame.
* `plat_non_osc`: Non-oscillating platform.
* `plat_osc`: Oscillating platform.
* `tbeam_emitter`: Funnel emitter.
* `tbeam_frame`: Funnel frame.
"""
return flag.value.casefold() in instance_traits.get(inst)
def flag_has_trait(inst: Entity, flag: Property):
"""Check if the instance has a specific 'trait', which is set by code.
Current traits:
* `white`, `black`: If editoritems indicates the colour of the item.
* `arrival_departure_transition`: `arrival_departure_transition_ents`.
* `barrier`: Glass/grating instances:
* `barrier_128`: Segment instance.
* `barrier_frame`: Any frame part.
* `frame_convex_corner`: Convex corner (unused).
* `frame_short`: Shortened frame to fit a corner.
* `frame_straight`: Straight frame section.
* `frame_corner`: Frame corner section.
* `frame_left`: Left half of the frame.
* `frame_right`: Right half of the frame.
* `floor_button`: ItemButtonFloor type item:
* `btn_ball`: Button Type = Sphere.
* `btn_cube`: Button Type = Cube
* `weighted`: Button Type = Weighted
* `dropperless`: A dropperless Cube:
* `cube_standard`: Normal Cube.
* `cube_companion`: Companion Cube.
* `cube_ball`: Edgeless Safety Cube.
* `cube_reflect`: Discouragment Redirection Cube.
* `cube_franken`: FrankenTurret.
* `coop_corridor`: A Coop exit Corridor.
* `sp_corridor`: SP entry or exit corridor.
* `corridor_frame`: White/black door frame.
* `corridor_1`-`7`: The specified entry/exit corridor.
* `elevator`: An elevator instance.
* `entry_elevator`: Entry Elevator.
* `exit_elevator`: Exit Elevator.
* `entry_corridor`: Entry SP Corridor.
* `exit_corridor`: Exit SP/Coop Corridor.
* `fizzler`: A fizzler item:
* `fizzler_base`: Logic instance.
* `fizzler_model`: Model instance.
* `locking_targ`: Target of a locking pedestal button.
* `locking_btn`: Locking pedestal button.
* `paint_dropper`: Gel Dropper:
* `paint_dropper_bomb`: Bomb-type dropper.
* `paint_dropper_sprayer`: Sprayer-type dropper.
* `panel_angled`: Angled Panel-type item.
* `track_platform`: Track Platform-style item:
* `plat_bottom`: Bottom frame.
* `plat_bottom_grate`: Grating.
* `plat_middle`: Middle frame.
* `plat_single`: One-long frame.
* `plat_top`: Top frame.
* `plat_non_osc`: Non-oscillating platform.
* `plat_osc`: Oscillating platform.
* `tbeam_emitter`: Funnel emitter.
* `tbeam_frame`: Funnel frame.
"""
return flag.value.casefold() in instance_traits.get(inst)
def set_random_seed(inst: Entity, seed: str) -> None:
"""Compute and set a random seed for a specific entity."""
name = inst['targetname']
# The global instances like elevators always get the same name, or
# none at all so we cannot use those for the seed. Instead use the global
# seed.
if name == '' or 'preplaced' in instance_traits.get(inst):
import vbsp
random.seed('{}{}{}{}'.format(
vbsp.MAP_RAND_SEED, seed, inst['origin'], inst['angles'],
))
else:
# We still need to use angles and origin, since things like
# fizzlers might not get unique names.
random.seed('{}{}{}{}'.format(
inst['targetname'], seed, inst['origin'], inst['angles']
))
def set_random_seed(inst: Entity, seed: str) -> None:
"""Compute and set a random seed for a specific entity."""
name = inst['targetname']
# The global instances like elevators always get the same name, or
# none at all so we cannot use those for the seed. Instead use the global
# seed.
if name == '' or 'preplaced' in instance_traits.get(inst):
import vbsp
random.seed('{}{}{}{}'.format(
vbsp.MAP_RAND_SEED,
seed,
inst['origin'],
inst['angles'],
))
else:
# We still need to use angles and origin, since things like
# fizzlers might not get unique names.
random.seed('{}{}{}{}'.format(inst['targetname'], seed, inst['origin'],
inst['angles']))
def res_import_template(inst: Entity, res: Property):
"""Import a template VMF file, retexturing it to match orientation.
It will be placed overlapping the given instance.
Options:
- ID: The ID of the template to be inserted. Add visgroups to additionally
add after a colon, comma-seperated (temp_id:vis1,vis2)
- force: a space-seperated list of overrides. If 'white' or 'black' is
present, the colour of tiles will be overridden. If 'invert' is
added, white/black tiles will be swapped. If a tile size
('2x2', '4x4', 'wall', 'special') is included, all tiles will
be switched to that size (if not a floor/ceiling). If 'world' or
'detail' is present, the brush will be forced to that type.
- replace: A block of template material -> replacement textures.
This is case insensitive - any texture here will not be altered
otherwise.
- replaceBrush: The position of a brush to replace (0 0 0=the surface).
This brush will be removed, and overlays will be fixed to use
all faces with the same normal. Can alternately be a block:
- Pos: The position to replace.
- additionalIDs: Space-separated list of face IDs in the template
to also fix for overlays. The surface should have close to a
vertical normal, to prevent rescaling the overlay.
- removeBrush: If true, the original brush will not be removed.
- transferOverlay: Allow disabling transferring overlays to this
template. The IDs will be removed instead. (This can be an instvar).
- keys/localkeys: If set, a brush entity will instead be generated with
these values. This overrides force world/detail.
Specially-handled keys:
- "origin", offset automatically.
- "movedir" on func_movelinear - set a normal surrounded by <>,
this gets replaced with angles.
- colorVar: If this fixup var is set
to 'white' or 'black', that colour will be forced.
If the value is '<editor>', the colour will be chosen based on
the color of the surface for ItemButtonFloor, funnels or
entry/exit frames.
- invertVar: If this fixup value is true, tile colour will be
swapped to the opposite of the current force option. This applies
after colorVar.
- visgroup: Sets how visgrouped parts are handled. If 'none' (default),
they are ignored. If 'choose', one is chosen. If a number, that
is the percentage chance for each visgroup to be added.
- visgroup_force_var: If set and True, visgroup is ignored and all groups
are added.
"""
(
orig_temp_id,
replace_tex,
force_colour,
force_grid,
force_type,
replace_brush_pos,
rem_replace_brush,
transfer_overlays,
additional_replace_ids,
invert_var,
color_var,
visgroup_func,
visgroup_force_var,
key_block,
) = res.value
temp_id = conditions.resolve_value(inst, orig_temp_id)
if srctools.conv_bool(conditions.resolve_value(inst, visgroup_force_var)):
def visgroup_func(group):
"""Use all the groups."""
yield from group
temp_name, visgroups = template_brush.parse_temp_name(temp_id)
try:
template = template_brush.get_template(temp_name)
except template_brush.InvalidTemplateName:
# The template map is read in after setup is performed, so
# it must be checked here!
# We don't want an error, just quit
if temp_id != orig_temp_id:
LOGGER.warning('{} -> "{}" is not a valid template!', orig_temp_id,
temp_name)
else:
LOGGER.warning('"{}" is not a valid template!', temp_name)
return
if color_var.casefold() == '<editor>':
# Check traits for the colour it should be.
traits = instance_traits.get(inst)
if 'white' in traits:
force_colour = template_brush.MAT_TYPES.white
elif 'black' in traits:
force_colour = template_brush.MAT_TYPES.black
else:
LOGGER.warning(
'"{}": Instance "{}" '
"isn't one with inherent color!",
temp_id,
inst['file'],
)
elif color_var:
color_val = conditions.resolve_value(inst, color_var).casefold()
if color_val == 'white':
force_colour = template_brush.MAT_TYPES.white
elif color_val == 'black':
force_colour = template_brush.MAT_TYPES.black
# else: no color var
if srctools.conv_bool(conditions.resolve_value(inst, invert_var)):
force_colour = template_brush.TEMP_COLOUR_INVERT[force_colour]
# else: False value, no invert.
origin = Vec.from_str(inst['origin'])
angles = Vec.from_str(inst['angles', '0 0 0'])
temp_data = template_brush.import_template(
template,
origin,
angles,
targetname=inst['targetname', ''],
force_type=force_type,
visgroup_choose=visgroup_func,
add_to_map=True,
additional_visgroups=visgroups,
)
if key_block is not None:
conditions.set_ent_keys(temp_data.detail, inst, key_block)
br_origin = Vec.from_str(key_block.find_key('keys')['origin'])
br_origin.localise(origin, angles)
temp_data.detail['origin'] = br_origin
move_dir = temp_data.detail['movedir', '']
if move_dir.startswith('<') and move_dir.endswith('>'):
move_dir = Vec.from_str(move_dir).rotate(*angles)
temp_data.detail['movedir'] = move_dir.to_angle()
# Add it to the list of ignored brushes, so vbsp.change_brush() doesn't
# modify it.
vbsp.IGNORED_BRUSH_ENTS.add(temp_data.detail)
try:
# This is the original brush the template is replacing. We fix overlay
# face IDs, so this brush is replaced by the faces in the template
# pointing
# the same way.
if replace_brush_pos is None:
raise KeyError # Not set, raise to jump out of the try block
pos = Vec(replace_brush_pos).rotate(angles.x, angles.y, angles.z)
pos += origin
brush_group = SOLIDS[pos.as_tuple()]
except KeyError:
# Not set or solid group doesn't exist, skip..
pass
else:
LOGGER.info('IDS: {}', additional_replace_ids | template.overlay_faces)
conditions.steal_from_brush(
temp_data,
brush_group,
rem_replace_brush,
map(int, additional_replace_ids | template.overlay_faces),
conv_bool(conditions.resolve_value(inst, transfer_overlays), True),
)
template_brush.retexture_template(
temp_data,
origin,
inst.fixup,
replace_tex,
force_colour,
force_grid,
)
def res_import_template(inst: Entity, res: Property):
"""Import a template VMF file, retexturing it to match orientation.
It will be placed overlapping the given instance.
Options:
- `ID`: The ID of the template to be inserted. Add visgroups to additionally
add after a colon, comma-seperated (`temp_id:vis1,vis2`).
Either section, or the whole value can be a `$fixup`.
- `force`: a space-seperated list of overrides. If 'white' or 'black' is
present, the colour of tiles will be overridden. If `invert` is
added, white/black tiles will be swapped. If a tile size
(`2x2`, `4x4`, `wall`, `special`) is included, all tiles will
be switched to that size (if not a floor/ceiling). If 'world' or
'detail' is present, the brush will be forced to that type.
- `replace`: A block of template material -> replacement textures.
This is case insensitive - any texture here will not be altered
otherwise. If the material starts with a `#`, it is instead a
face ID.
- `replaceBrush`: The position of a brush to replace (`0 0 0`=the surface).
This brush will be removed, and overlays will be fixed to use
all faces with the same normal. Can alternately be a block:
- `Pos`: The position to replace.
- `additionalIDs`: Space-separated list of face IDs in the template
to also fix for overlays. The surface should have close to a
vertical normal, to prevent rescaling the overlay.
- `removeBrush`: If true, the original brush will not be removed.
- `transferOverlay`: Allow disabling transferring overlays to this
template. The IDs will be removed instead. (This can be a `$fixup`).
- `keys`/`localkeys`: If set, a brush entity will instead be generated with
these values. This overrides force world/detail.
Specially-handled keys:
- `"origin"`, offset automatically.
- `"movedir"` on func_movelinear - set a normal surrounded by `<>`,
this gets replaced with angles.
- `colorVar`: If this fixup var is set
to `white` or `black`, that colour will be forced.
If the value is `<editor>`, the colour will be chosen based on
the color of the surface for ItemButtonFloor, funnels or
entry/exit frames.
- `invertVar`: If this fixup value is true, tile colour will be
swapped to the opposite of the current force option. This applies
after colorVar.
- `visgroup`: Sets how visgrouped parts are handled. If `none` (default),
they are ignored. If `choose`, one is chosen. If a number, that
is the percentage chance for each visgroup to be added.
- `visgroup_force_var`: If set and True, visgroup is ignored and all groups
are added.
- `outputs`: Add outputs to the brush ent. Syntax is like VMFs, and all names
are local to the instance.
"""
(
orig_temp_id,
replace_tex,
force_colour,
force_grid,
force_type,
replace_brush_pos,
rem_replace_brush,
transfer_overlays,
additional_replace_ids,
invert_var,
color_var,
visgroup_func,
visgroup_force_var,
key_block,
outputs,
) = res.value
if ':' in orig_temp_id:
# Split, resolve each part, then recombine.
temp_id, visgroup = orig_temp_id.split(':', 1)
temp_id = (
conditions.resolve_value(inst, temp_id) + ':' +
conditions.resolve_value(inst, visgroup)
)
else:
temp_id = conditions.resolve_value(inst, orig_temp_id)
if srctools.conv_bool(conditions.resolve_value(inst, visgroup_force_var)):
def visgroup_func(group):
"""Use all the groups."""
yield from group
temp_name, visgroups = template_brush.parse_temp_name(temp_id)
try:
template = template_brush.get_template(temp_name)
except template_brush.InvalidTemplateName:
# If we did lookup, display both forms.
if temp_id != orig_temp_id:
LOGGER.warning(
'{} -> "{}" is not a valid template!',
orig_temp_id,
temp_name
)
else:
LOGGER.warning(
'"{}" is not a valid template!',
temp_name
)
# We don't want an error, just quit.
return
if color_var.casefold() == '<editor>':
# Check traits for the colour it should be.
traits = instance_traits.get(inst)
if 'white' in traits:
force_colour = template_brush.MAT_TYPES.white
elif 'black' in traits:
force_colour = template_brush.MAT_TYPES.black
else:
LOGGER.warning(
'"{}": Instance "{}" '
"isn't one with inherent color!",
temp_id,
inst['file'],
)
elif color_var:
color_val = conditions.resolve_value(inst, color_var).casefold()
if color_val == 'white':
force_colour = template_brush.MAT_TYPES.white
elif color_val == 'black':
force_colour = template_brush.MAT_TYPES.black
# else: no color var
if srctools.conv_bool(conditions.resolve_value(inst, invert_var)):
force_colour = template_brush.TEMP_COLOUR_INVERT[force_colour]
# else: False value, no invert.
origin = Vec.from_str(inst['origin'])
angles = Vec.from_str(inst['angles', '0 0 0'])
temp_data = template_brush.import_template(
template,
origin,
angles,
targetname=inst['targetname', ''],
force_type=force_type,
visgroup_choose=visgroup_func,
add_to_map=True,
additional_visgroups=visgroups,
)
if key_block is not None:
conditions.set_ent_keys(temp_data.detail, inst, key_block)
br_origin = Vec.from_str(key_block.find_key('keys')['origin'])
br_origin.localise(origin, angles)
temp_data.detail['origin'] = br_origin
move_dir = temp_data.detail['movedir', '']
if move_dir.startswith('<') and move_dir.endswith('>'):
move_dir = Vec.from_str(move_dir).rotate(*angles)
temp_data.detail['movedir'] = move_dir.to_angle()
for out in outputs: # type: Output
out = out.copy()
out.target = conditions.local_name(inst, out.target)
temp_data.detail.add_out(out)
# Add it to the list of ignored brushes, so vbsp.change_brush() doesn't
# modify it.
vbsp.IGNORED_BRUSH_ENTS.add(temp_data.detail)
try:
# This is the original brush the template is replacing. We fix overlay
# face IDs, so this brush is replaced by the faces in the template
# pointing
# the same way.
if replace_brush_pos is None:
raise KeyError # Not set, raise to jump out of the try block
pos = Vec(replace_brush_pos).rotate(angles.x, angles.y, angles.z)
pos += origin
brush_group = SOLIDS[pos.as_tuple()]
except KeyError:
# Not set or solid group doesn't exist, skip..
pass
else:
LOGGER.info('IDS: {}', additional_replace_ids | template.overlay_faces)
conditions.steal_from_brush(
temp_data,
brush_group,
rem_replace_brush,
map(int, additional_replace_ids | template.overlay_faces),
conv_bool(conditions.resolve_value(inst, transfer_overlays), True),
)
template_brush.retexture_template(
temp_data,
origin,
inst.fixup,
replace_tex,
force_colour,
force_grid,
# Don't allow clumping if using custom keyvalues - then it won't be edited.
no_clumping=key_block is not None,
)
def parse_map(vmf: VMF, voice_attrs: Dict[str, bool]) -> None:
"""Analyse fizzler instances to assign fizzler types.
Instance traits are required.
The model instances and brushes will be removed from the map.
Needs connections to be parsed.
"""
# Item ID and model skin -> fizzler type
fizz_types = {} # type: Dict[Tuple[str, int], FizzlerType]
for fizz_type in FIZZ_TYPES.values():
for item_id in fizz_type.item_ids:
if ':' in item_id:
item_id, barrier_type = item_id.split(':')
if barrier_type == 'laserfield':
barrier_skin = 2
elif barrier_type == 'fizzler':
barrier_skin = 0
else:
LOGGER.error('Invalid barrier type ({}) for "{}"!',
barrier_type, item_id)
fizz_types[item_id, 0] = fizz_type
fizz_types[item_id, 2] = fizz_type
continue
fizz_types[item_id, barrier_skin] = fizz_type
else:
fizz_types[item_id, 0] = fizz_type
fizz_types[item_id, 2] = fizz_type
fizz_bases = {} # type: Dict[str, Entity]
fizz_models = defaultdict(list) # type: Dict[str, List[Entity]]
# Position and normal -> name, for output relays.
fizz_pos = {
} # type: Dict[Tuple[Tuple[float, float, float], Tuple[float, float, float]], str]
# First use traits to gather up all the instances.
for inst in vmf.by_class['func_instance']:
traits = instance_traits.get(inst)
if 'fizzler' not in traits:
continue
name = inst['targetname']
if 'fizzler_model' in traits:
name = name.rsplit('_model', 1)[0]
fizz_models[name].append(inst)
inst.remove()
elif 'fizzler_base' in traits:
fizz_bases[name] = inst
else:
LOGGER.warning('Fizzler "{}" has non-base, non-model instance?',
name)
continue
origin = Vec.from_str(inst['origin'])
normal = Vec(z=1).rotate_by_str(inst['angles'])
fizz_pos[origin.as_tuple(), normal.as_tuple()] = name
for name, base_inst in fizz_bases.items():
models = fizz_models[name]
up_axis = Vec(y=1).rotate_by_str(base_inst['angles'])
# If upside-down, make it face upright.
if up_axis == (0, 0, -1):
up_axis = Vec(z=1)
base_inst.outputs.clear()
# Now match the pairs of models to each other.
# The length axis is the line between them.
# We don't care about the instances after this, so don't keep track.
length_axis = Vec(z=1).rotate_by_str(base_inst['angles']).axis()
emitters = [] # type: List[Tuple[Vec, Vec]]
model_pairs = {} # type: Dict[Tuple[float, float], Vec]
model_skin = models[0].fixup.int('$skin')
try:
item_id, item_subtype = instanceLocs.ITEM_FOR_FILE[
base_inst['file'].casefold()]
fizz_type = fizz_types[item_id, model_skin]
except KeyError:
LOGGER.warning('Fizzler types: {}', fizz_types.keys())
raise ValueError('No fizzler type for "{}"!'.format(
base_inst['file'], )) from None
for attr_name in fizz_type.voice_attrs:
voice_attrs[attr_name] = True
for model in models:
pos = Vec.from_str(model['origin'])
try:
other_pos = model_pairs.pop(pos.other_axes(length_axis))
except KeyError:
# No other position yet, we need to find that.
model_pairs[pos.other_axes(length_axis)] = pos
continue
min_pos, max_pos = Vec.bbox(pos, other_pos)
# Move positions to the wall surface.
min_pos[length_axis] -= 64
max_pos[length_axis] += 64
emitters.append((min_pos, max_pos))
FIZZLERS[name] = Fizzler(fizz_type, up_axis, base_inst, emitters)
# Delete all the old brushes associated with fizzlers
for brush in (vmf.by_class['trigger_portal_cleanser']
| vmf.by_class['trigger_hurt'] | vmf.by_class['func_brush']):
name = brush['targetname']
if not name:
continue
name = name.rsplit('_brush')[0]
if name in FIZZLERS:
brush.remove()
# Check for fizzler output relays.
relay_file = instanceLocs.resolve('<ITEM_BEE2_FIZZLER_OUT_RELAY>',
silent=True)
if not relay_file:
# No relay item - deactivated most likely.
return
for inst in vmf.by_class['func_instance']:
if inst['file'].casefold() not in relay_file:
continue
inst.remove()
relay_item = connections.ITEMS[inst['targetname']]
try:
fizz_name = fizz_pos[
Vec.from_str(inst['origin']).as_tuple(),
Vec(0, 0, 1).rotate_by_str(inst['angles']).as_tuple()]
fizz_item = connections.ITEMS[fizz_name]
except KeyError:
# Not placed on a fizzler, or a fizzler with no IO
# - ignore, and destroy.
for out in list(relay_item.outputs):
out.remove()
for out in list(relay_item.inputs):
out.remove()
del connections.ITEMS[relay_item.name]
continue
# Copy over fixup values
fizz_item.inst.fixup.update(inst.fixup)
# Copy over the timer delay set in the relay.
fizz_item.timer = relay_item.timer
# Transfer over antlines.
fizz_item.antlines |= relay_item.antlines
fizz_item.shape_signs += relay_item.shape_signs
fizz_item.ind_panels |= relay_item.ind_panels
# Remove the relay item so it doesn't get added to the map.
del connections.ITEMS[relay_item.name]
for conn in list(relay_item.outputs):
conn.from_item = fizz_item
def calc_connections(
vmf: VMF,
shape_frame_tex: List[str],
enable_shape_frame: bool,
):
"""Compute item connections from the map file.
This also fixes cases where items have incorrect checkmark/timer signs.
Instance Traits must have been calculated.
It also applies frames to shape signage to distinguish repeats.
"""
# First we want to match targetnames to item types.
toggles = {} # type: Dict[str, Entity]
overlays = defaultdict(set) # type: Dict[str, Set[Entity]]
# Accumulate all the signs into groups, so the list should be 2-long:
# sign_shapes[name, material][0/1]
sign_shape_overlays = defaultdict(list) # type: Dict[Tuple[str, str], List[Entity]]
panels = {} # type: Dict[str, Entity]
panel_timer = instanceLocs.resolve_one('[indPanTimer]', error=True)
panel_check = instanceLocs.resolve_one('[indPanCheck]', error=True)
tbeam_polarity = {
conditions.TBEAM_CONN_ACT,
conditions.TBEAM_CONN_DEACT,
}
tbeam_io = conditions.CONNECTIONS['item_tbeam']
tbeam_io = {tbeam_io.in_act, tbeam_io.in_deact}
for inst in vmf.by_class['func_instance']:
inst_name = inst['targetname']
if not inst_name:
continue
traits = instance_traits.get(inst)
if 'indicator_toggle' in traits:
toggles[inst['targetname']] = inst
elif 'indicator_panel' in traits:
panels[inst['targetname']] = inst
else:
ITEMS[inst_name] = Item(inst)
for over in vmf.by_class['info_overlay']:
name = over['targetname']
mat = over['material']
if mat in SIGN_ORDER_LOOKUP:
sign_shape_overlays[name, mat.casefold()].append(over)
else:
# Antlines
overlays[name].add(over)
# Name -> signs pairs
sign_shapes = defaultdict(list) # type: Dict[str, List[ShapeSignage]]
# By material index, for group frames.
sign_shape_by_index = defaultdict(list) # type: Dict[int, List[ShapeSignage]]
for (name, mat), sign_pair in sign_shape_overlays.items():
# It's possible - but rare - for more than 2 to be in a pair.
# We have to just treat them as all in their 'pair'.
# Shouldn't be an issue, it'll be both from one item...
shape = ShapeSignage(sign_pair)
sign_shapes[name].append(shape)
sign_shape_by_index[shape.index].append(shape)
# Now build the connections and items.
for item in ITEMS.values():
input_items = [] # Instances we trigger
inputs = defaultdict(list) # type: Dict[str, List[Output]]
for out in item.inst.outputs:
inputs[out.target].append(out)
# inst.outputs.clear()
for out_name in inputs:
# Fizzler base -> model/brush outputs, skip and readd.
if out_name.endswith(('_modelStart', '_modelEnd', '_brush')):
# item.inst.add_out(*inputs[out_name])
continue
if out_name in toggles:
inst_toggle = toggles[out_name]
item.antlines |= overlays[inst_toggle.fixup['indicator_name']]
elif out_name in panels:
pan = panels[out_name]
item.ind_panels.add(pan)
if pan.fixup.bool('$is_timer'):
item.timer = tim = pan.fixup.int('$timer_delay')
if not (1 <= tim <= 30):
# These would be infinite.
item.timer = None
else:
item.timer = None
else:
try:
input_items.append(ITEMS[out_name])
except KeyError:
raise ValueError('"{}" is not a known instance!'.format(out_name))
desired_panel_inst = panel_check if item.timer is None else panel_timer
# Check/cross instances sometimes don't match the kind of timer delay.
for pan in item.ind_panels:
pan['file'] = desired_panel_inst
pan.fixup['$is_timer'] = int(item.timer is not None)
for inp_item in input_items: # type: Item
# Default A/B type.
conn_type = ConnType.DEFAULT
in_outputs = inputs[inp_item.name]
if 'tbeam_emitter' in inp_item.traits:
# It's a funnel - we need to figure out if this is polarity,
# or normal on/off.
for out in in_outputs: # type: Output
input_tuple = (out.inst_in, out.input)
if input_tuple in tbeam_polarity:
conn_type = ConnType.TBEAM_DIR
break
elif input_tuple in tbeam_io:
conn_type = ConnType.TBEAM_IO
break
else:
raise ValueError(
'Excursion Funnel "{}" has inputs, '
'but no valid types!'.format(inp_item.name)
)
conn = Connection(
inp_item,
item,
conn_type,
in_outputs,
)
conn.add()
for item in ITEMS.values():
# Copying items can fail to update the connection counts.
# Make sure they're correct.
if '$connectioncount' in item.inst.fixup:
# Don't count the polarity outputs...
item.inst.fixup['$connectioncount'] = sum(
1 for conn
in item.inputs
if conn.type is not ConnType.TBEAM_DIR
)
if '$connectioncount_polarity' in item.inst.fixup:
# Only count the polarity outputs...
item.inst.fixup['$connectioncount_polarity'] = sum(
1 for conn
in item.inputs
if conn.type is ConnType.TBEAM_DIR
)
# Make signage frames
shape_frame_tex = [mat for mat in shape_frame_tex if mat]
if shape_frame_tex and enable_shape_frame:
for shape_mat in sign_shape_by_index.values():
# Sort by name, so which gets what frame is consistent
shape_mat.sort(key=lambda shape: shape.name)
for index, shape in enumerate(shape_mat):
shape.repeat_group = index
if index == 0:
continue # First, no frames..
frame_mat = shape_frame_tex[(index-1) % len(shape_frame_tex)]
for overlay in shape:
frame = overlay.copy()
shape.overlay_frames.append(frame)
vmf.add_ent(frame)
frame['material'] = frame_mat
frame['renderorder'] = 1 # On top
def traits(self):
"""Return the set of instance traits for the item."""
return instance_traits.get(self.inst)
def res_linked_cube_dropper(drp_inst: Entity, res: Property):
"""Link a cube and dropper together, to preplace the cube at a location."""
time = drp_inst.fixup.int('$timer_delay')
# Portal 2 bug - when loading existing maps, timers are set to 3...
if not (3 < time <= 30):
# Infinite or 3-second - this behaviour is disabled..
return
try:
cube_inst, resp_out_name, resp_out = LINKED_CUBES[time]
except KeyError:
raise Exception('Unknown cube "linkage" value ({}) in dropper!'.format(
time, ))
# Force the dropper to match the cube..
if '$cube_type' in cube_inst.fixup:
# Trust instvar if set (custom items for example)
drp_inst.fixup['$cube_type'] = cube_inst.fixup['$cube_type']
else:
cube_traits = instance_traits.get(cube_inst)
for ind, cube_type in enumerate(CUBE_TYPES):
if cube_type in cube_traits:
drp_inst.fixup['$cube_type'] = ind
break
else:
LOGGER.warning('Cube "{}" has no cube type traits!',
cube_inst['targetname'])
# Set auto-drop to False (so there isn't two cubes),
# and auto-respawn to True (so it actually functions).
drp_inst.fixup['$disable_autodrop'] = '1'
drp_inst.fixup['$disable_autorespawn'] = '0'
fizz_out_name, fizz_out = Output.parse_name(res['FizzleOut'])
# Output to destroy the cube when the dropper is triggered externally.
drp_inst.add_out(
Output(
inst_out=fizz_out_name,
out=fizz_out,
targ=local_name(cube_inst, 'cube'),
inp='Dissolve',
only_once=True,
))
# Cube items don't have proxies, so we need to use AddOutput
# after it's created (@relay_spawn_3's time).
try:
relay_spawn_3 = GLOBAL_INPUT_ENTS['@relay_spawn_3']
except KeyError:
relay_spawn_3 = GLOBAL_INPUT_ENTS[
'@relay_spawn_3'] = cube_inst.map.create_ent(
classname='logic_relay',
targetname='@relay_spawn_3',
origin=cube_inst['origin'],
)
respawn_inp = list(res.find_all('RespawnIn'))
# There's some voice-logic specific to companion cubes.
respawn_inp.extend(
res.find_all('RespawnCcube' if drp_inst.fixup['$cube_type'] ==
'1' else 'RespawnCube'))
for inp in respawn_inp:
resp_in_name, resp_in = inp.value.split(':', 1)
out = Output(
out='OnFizzled',
targ=drp_inst,
inst_in=resp_in_name,
inp=resp_in,
only_once=True,
)
relay_spawn_3.add_out(
Output(
out='OnTrigger',
targ=local_name(cube_inst, 'cube'),
inp='AddOutput',
param=out.gen_addoutput(),
only_once=True,
delay=0.01,
))
def res_import_template(inst: Entity, res: Property):
"""Import a template VMF file, retexturing it to match orientation.
It will be placed overlapping the given instance. If no block is used, only
ID can be specified.
Options:
- `ID`: The ID of the template to be inserted. Add visgroups to additionally
add after a colon, comma-seperated (`temp_id:vis1,vis2`).
Either section, or the whole value can be a `$fixup`.
- `force`: a space-seperated list of overrides. If 'white' or 'black' is
present, the colour of tiles will be overridden. If `invert` is
added, white/black tiles will be swapped. If a tile size
(`2x2`, `4x4`, `wall`, `special`) is included, all tiles will
be switched to that size (if not a floor/ceiling). If 'world' or
'detail' is present, the brush will be forced to that type.
- `replace`: A block of template material -> replacement textures.
This is case insensitive - any texture here will not be altered
otherwise. If the material starts with a `#`, it is instead a
list of face IDs separated by spaces. If the result evaluates
to "", no change occurs. Both can be $fixups (parsed first).
- `bindOverlay`: Bind overlays in this template to the given surface, and
bind overlays on a surface to surfaces in this template.
The value specifies the offset to the surface, where 0 0 0 is the
floor position. It can also be a block of multiple positions.
- `keys`/`localkeys`: If set, a brush entity will instead be generated with
these values. This overrides force world/detail.
Specially-handled keys:
- `"origin"`, offset automatically.
- `"movedir"` on func_movelinear - set a normal surrounded by `<>`,
this gets replaced with angles.
- `colorVar`: If this fixup var is set
to `white` or `black`, that colour will be forced.
If the value is `<editor>`, the colour will be chosen based on
the color of the surface for ItemButtonFloor, funnels or
entry/exit frames.
- `invertVar`: If this fixup value is true, tile colour will be
swapped to the opposite of the current force option. This applies
after colorVar.
- `visgroup`: Sets how visgrouped parts are handled. Several values are possible:
- A property block: Each name should match a visgroup, and the
value should be a block of flags that if true enables that group.
- 'none' (default): All extra groups are ignored.
- 'choose': One group is chosen randomly.
- a number: The percentage chance for each visgroup to be added.
- `visgroup_force_var`: If set and True, visgroup is ignored and all groups
are added.
- `pickerVars`:
If this is set, the results of colorpickers can be read
out of the template. The key is the name of the picker, the value
is the fixup name to write to. The output is either 'white',
'black' or ''.
- `outputs`: Add outputs to the brush ent. Syntax is like VMFs, and all names
are local to the instance.
- `senseOffset`: If set, colorpickers and tilesetters will be treated
as being offset by this amount.
"""
(
orig_temp_id,
replace_tex,
force_colour,
force_grid,
force_type,
surf_cat,
bind_tile_pos,
invert_var,
color_var,
visgroup_func,
visgroup_force_var,
visgroup_instvars,
key_block,
picker_vars,
outputs,
sense_offset,
) = res.value
if ':' in orig_temp_id:
# Split, resolve each part, then recombine.
temp_id, visgroup = orig_temp_id.split(':', 1)
temp_id = (
conditions.resolve_value(inst, temp_id) + ':' +
conditions.resolve_value(inst, visgroup)
)
else:
temp_id = conditions.resolve_value(inst, orig_temp_id)
if srctools.conv_bool(conditions.resolve_value(inst, visgroup_force_var)):
def visgroup_func(group):
"""Use all the groups."""
yield from group
# Special case - if blank, just do nothing silently.
if not temp_id:
return
temp_name, visgroups = template_brush.parse_temp_name(temp_id)
try:
template = template_brush.get_template(temp_name)
except template_brush.InvalidTemplateName:
# If we did lookup, display both forms.
if temp_id != orig_temp_id:
LOGGER.warning(
'{} -> "{}" is not a valid template!',
orig_temp_id,
temp_name
)
else:
LOGGER.warning(
'"{}" is not a valid template!',
temp_name
)
# We don't want an error, just quit.
return
for vis_flag_block in visgroup_instvars:
if all(conditions.check_flag(flag, inst) for flag in vis_flag_block):
visgroups.add(vis_flag_block.real_name)
if color_var.casefold() == '<editor>':
# Check traits for the colour it should be.
traits = instance_traits.get(inst)
if 'white' in traits:
force_colour = texturing.Portalable.white
elif 'black' in traits:
force_colour = texturing.Portalable.black
else:
LOGGER.warning(
'"{}": Instance "{}" '
"isn't one with inherent color!",
temp_id,
inst['file'],
)
elif color_var:
color_val = conditions.resolve_value(inst, color_var).casefold()
if color_val == 'white':
force_colour = texturing.Portalable.white
elif color_val == 'black':
force_colour = texturing.Portalable.black
# else: no color var
if srctools.conv_bool(conditions.resolve_value(inst, invert_var)):
force_colour = template_brush.TEMP_COLOUR_INVERT[force_colour]
# else: False value, no invert.
origin = Vec.from_str(inst['origin'])
angles = Vec.from_str(inst['angles', '0 0 0'])
temp_data = template_brush.import_template(
template,
origin,
angles,
targetname=inst['targetname', ''],
force_type=force_type,
visgroup_choose=visgroup_func,
add_to_map=True,
additional_visgroups=visgroups,
bind_tile_pos=bind_tile_pos,
)
if key_block is not None:
conditions.set_ent_keys(temp_data.detail, inst, key_block)
br_origin = Vec.from_str(key_block.find_key('keys')['origin'])
br_origin.localise(origin, angles)
temp_data.detail['origin'] = br_origin
move_dir = temp_data.detail['movedir', '']
if move_dir.startswith('<') and move_dir.endswith('>'):
move_dir = Vec.from_str(move_dir).rotate(*angles)
temp_data.detail['movedir'] = move_dir.to_angle()
for out in outputs: # type: Output
out = out.copy()
out.target = conditions.local_name(inst, out.target)
temp_data.detail.add_out(out)
template_brush.retexture_template(
temp_data,
origin,
inst.fixup,
replace_tex,
force_colour,
force_grid,
surf_cat,
sense_offset,
)
for picker_name, picker_var in picker_vars:
picker_val = temp_data.picker_results.get(
picker_name, None,
) # type: Optional[texturing.Portalable]
if picker_val is not None:
inst.fixup[picker_var] = picker_val.value
else:
inst.fixup[picker_var] = ''
def res_import_template(inst: Entity, res: Property):
"""Import a template VMF file, retexturing it to match orientation.
It will be placed overlapping the given instance.
Options:
- ID: The ID of the template to be inserted. Add visgroups to additionally
add after a colon, comma-seperated (temp_id:vis1,vis2)
- force: a space-seperated list of overrides. If 'white' or 'black' is
present, the colour of tiles will be overridden. If `invert` is
added, white/black tiles will be swapped. If a tile size
('2x2', '4x4', 'wall', 'special') is included, all tiles will
be switched to that size (if not a floor/ceiling). If 'world' or
'detail' is present, the brush will be forced to that type.
- replace: A block of template material -> replacement textures.
This is case insensitive - any texture here will not be altered
otherwise. If the material starts with a '#', it is instead a
face ID.
- replaceBrush: The position of a brush to replace (0 0 0=the surface).
This brush will be removed, and overlays will be fixed to use
all faces with the same normal. Can alternately be a block:
- Pos: The position to replace.
- additionalIDs: Space-separated list of face IDs in the template
to also fix for overlays. The surface should have close to a
vertical normal, to prevent rescaling the overlay.
- removeBrush: If true, the original brush will not be removed.
- transferOverlay: Allow disabling transferring overlays to this
template. The IDs will be removed instead. (This can be an instvar).
- keys/localkeys: If set, a brush entity will instead be generated with
these values. This overrides force world/detail.
Specially-handled keys:
- "origin", offset automatically.
- "movedir" on func_movelinear - set a normal surrounded by <>,
this gets replaced with angles.
- colorVar: If this fixup var is set
to `white` or `black`, that colour will be forced.
If the value is `<editor>`, the colour will be chosen based on
the color of the surface for ItemButtonFloor, funnels or
entry/exit frames.
- invertVar: If this fixup value is true, tile colour will be
swapped to the opposite of the current force option. This applies
after colorVar.
- visgroup: Sets how visgrouped parts are handled. If 'none' (default),
they are ignored. If 'choose', one is chosen. If a number, that
is the percentage chance for each visgroup to be added.
- visgroup_force_var: If set and True, visgroup is ignored and all groups
are added.
- outputs: Add outputs to the brush ent. Syntax is like VMFs, and all names
are local to the instance.
"""
(
orig_temp_id,
replace_tex,
force_colour,
force_grid,
force_type,
replace_brush_pos,
rem_replace_brush,
transfer_overlays,
additional_replace_ids,
invert_var,
color_var,
visgroup_func,
visgroup_force_var,
key_block,
outputs,
) = res.value
if ':' in orig_temp_id:
# Split, resolve each part, then recombine.
temp_id, visgroup = orig_temp_id.split(':', 1)
temp_id = (
conditions.resolve_value(inst, temp_id) + ':' +
conditions.resolve_value(inst, visgroup)
)
else:
temp_id = conditions.resolve_value(inst, orig_temp_id)
if srctools.conv_bool(conditions.resolve_value(inst, visgroup_force_var)):
def visgroup_func(group):
"""Use all the groups."""
yield from group
temp_name, visgroups = template_brush.parse_temp_name(temp_id)
try:
template = template_brush.get_template(temp_name)
except template_brush.InvalidTemplateName:
# If we did lookup, display both forms.
if temp_id != orig_temp_id:
LOGGER.warning(
'{} -> "{}" is not a valid template!',
orig_temp_id,
temp_name
)
else:
LOGGER.warning(
'"{}" is not a valid template!',
temp_name
)
# We don't want an error, just quit.
return
if color_var.casefold() == '<editor>':
# Check traits for the colour it should be.
traits = instance_traits.get(inst)
if 'white' in traits:
force_colour = template_brush.MAT_TYPES.white
elif 'black' in traits:
force_colour = template_brush.MAT_TYPES.black
else:
LOGGER.warning(
'"{}": Instance "{}" '
"isn't one with inherent color!",
temp_id,
inst['file'],
)
elif color_var:
color_val = conditions.resolve_value(inst, color_var).casefold()
if color_val == 'white':
force_colour = template_brush.MAT_TYPES.white
elif color_val == 'black':
force_colour = template_brush.MAT_TYPES.black
# else: no color var
if srctools.conv_bool(conditions.resolve_value(inst, invert_var)):
force_colour = template_brush.TEMP_COLOUR_INVERT[force_colour]
# else: False value, no invert.
origin = Vec.from_str(inst['origin'])
angles = Vec.from_str(inst['angles', '0 0 0'])
temp_data = template_brush.import_template(
template,
origin,
angles,
targetname=inst['targetname', ''],
force_type=force_type,
visgroup_choose=visgroup_func,
add_to_map=True,
additional_visgroups=visgroups,
)
if key_block is not None:
conditions.set_ent_keys(temp_data.detail, inst, key_block)
br_origin = Vec.from_str(key_block.find_key('keys')['origin'])
br_origin.localise(origin, angles)
temp_data.detail['origin'] = br_origin
move_dir = temp_data.detail['movedir', '']
if move_dir.startswith('<') and move_dir.endswith('>'):
move_dir = Vec.from_str(move_dir).rotate(*angles)
temp_data.detail['movedir'] = move_dir.to_angle()
for out in outputs: # type: Output
out = out.copy()
out.target = conditions.local_name(inst, out.target)
temp_data.detail.add_out(out)
# Add it to the list of ignored brushes, so vbsp.change_brush() doesn't
# modify it.
vbsp.IGNORED_BRUSH_ENTS.add(temp_data.detail)
try:
# This is the original brush the template is replacing. We fix overlay
# face IDs, so this brush is replaced by the faces in the template
# pointing
# the same way.
if replace_brush_pos is None:
raise KeyError # Not set, raise to jump out of the try block
pos = Vec(replace_brush_pos).rotate(angles.x, angles.y, angles.z)
pos += origin
brush_group = SOLIDS[pos.as_tuple()]
except KeyError:
# Not set or solid group doesn't exist, skip..
pass
else:
LOGGER.info('IDS: {}', additional_replace_ids | template.overlay_faces)
conditions.steal_from_brush(
temp_data,
brush_group,
rem_replace_brush,
map(int, additional_replace_ids | template.overlay_faces),
conv_bool(conditions.resolve_value(inst, transfer_overlays), True),
)
template_brush.retexture_template(
temp_data,
origin,
inst.fixup,
replace_tex,
force_colour,
force_grid,
# Don't allow clumping if using custom keyvalues - then it won't be edited.
no_clumping=key_block is not None,
)
def calc_connections(
vmf: VMF,
shape_frame_tex: List[str],
enable_shape_frame: bool,
antline_wall: antlines.AntType,
antline_floor: antlines.AntType,
):
"""Compute item connections from the map file.
This also fixes cases where items have incorrect checkmark/timer signs.
Instance Traits must have been calculated.
It also applies frames to shape signage to distinguish repeats.
"""
# First we want to match targetnames to item types.
toggles = {} # type: Dict[str, Entity]
overlays = defaultdict(set) # type: Dict[str, Set[Entity]]
# Accumulate all the signs into groups, so the list should be 2-long:
# sign_shapes[name, material][0/1]
sign_shape_overlays = defaultdict(
list) # type: Dict[Tuple[str, str], List[Entity]]
# Indicator panels
panels = {} # type: Dict[str, Entity]
# We only need to pay attention for TBeams, other items we can
# just detect any output.
tbeam_polarity = {OutNames.IN_SEC_ACT, OutNames.IN_SEC_DEACT}
# Also applies to other items, but not needed for this analysis.
tbeam_io = {OutNames.IN_ACT, OutNames.IN_DEACT}
for inst in vmf.by_class['func_instance']:
inst_name = inst['targetname']
# No connections, so nothing to worry about.
if not inst_name:
continue
traits = instance_traits.get(inst)
if 'indicator_toggle' in traits:
toggles[inst['targetname']] = inst
# We do not use toggle instances.
inst.remove()
elif 'indicator_panel' in traits:
panels[inst['targetname']] = inst
else:
# Normal item.
try:
item_type = ITEM_TYPES[instance_traits.get_item_id(
inst).casefold()]
except (KeyError, AttributeError):
# KeyError from no item type, AttributeError from None.casefold()
# These aren't made for non-io items. If it has outputs,
# that'll be a problem later.
pass
else:
# Pass in the defaults for antline styles.
ITEMS[inst_name] = Item(inst, item_type, antline_floor,
antline_wall)
for over in vmf.by_class['info_overlay']:
name = over['targetname']
mat = over['material']
if mat in SIGN_ORDER_LOOKUP:
sign_shape_overlays[name, mat.casefold()].append(over)
else:
# Antlines
overlays[name].add(over)
# Name -> signs pairs
sign_shapes = defaultdict(list) # type: Dict[str, List[ShapeSignage]]
# By material index, for group frames.
sign_shape_by_index = defaultdict(
list) # type: Dict[int, List[ShapeSignage]]
for (name, mat), sign_pair in sign_shape_overlays.items():
# It's possible - but rare - for more than 2 to be in a pair.
# We have to just treat them as all in their 'pair'.
# Shouldn't be an issue, it'll be both from one item...
shape = ShapeSignage(sign_pair)
sign_shapes[name].append(shape)
sign_shape_by_index[shape.index].append(shape)
# Now build the connections and items.
for item in ITEMS.values():
input_items = [] # Instances we trigger
inputs = defaultdict(list) # type: Dict[str, List[Output]]
if item.inst.outputs and item.item_type is None:
raise ValueError('No connections for item "{}", '
'but outputs in the map!'.format(
instance_traits.get_item_id(item.inst)))
for out in item.inst.outputs:
inputs[out.target].append(out)
# Remove the original outputs, we've consumed those already.
item.inst.outputs.clear()
# Pre-set the timer value, for items without antlines but with an output.
if const.FixupVars.TIM_DELAY in item.inst.fixup:
if item.item_type.output_act or item.item_type.output_deact:
item.timer = tim = item.inst.fixup.int(
const.FixupVars.TIM_DELAY)
if not (1 <= tim <= 30):
# These would be infinite.
item.timer = None
for out_name in inputs:
# Fizzler base -> model/brush outputs, ignore these (discard).
# fizzler.py will regenerate as needed.
if out_name.endswith(('_modelStart', '_modelEnd', '_brush')):
continue
if out_name in toggles:
inst_toggle = toggles[out_name]
item.antlines |= overlays[inst_toggle.fixup['indicator_name']]
elif out_name in panels:
pan = panels[out_name]
item.ind_panels.add(pan)
if pan.fixup.bool(const.FixupVars.TIM_ENABLED):
item.timer = tim = pan.fixup.int(const.FixupVars.TIM_DELAY)
if not (1 <= tim <= 30):
# These would be infinite.
item.timer = None
else:
item.timer = None
else:
try:
inp_item = ITEMS[out_name]
except KeyError:
raise ValueError(
'"{}" is not a known instance!'.format(out_name))
else:
input_items.append(inp_item)
if inp_item.item_type is None:
raise ValueError('No connections for item "{}", '
'but inputs in the map!'.format(
instance_traits.get_item_id(
inp_item.inst)))
for inp_item in input_items: # type: Item
# Default A/B type.
conn_type = ConnType.DEFAULT
in_outputs = inputs[inp_item.name]
if inp_item.item_type.id == 'ITEM_TBEAM':
# It's a funnel - we need to figure out if this is polarity,
# or normal on/off.
for out in in_outputs:
if out.input in tbeam_polarity:
conn_type = ConnType.TBEAM_DIR
break
elif out.input in tbeam_io:
conn_type = ConnType.TBEAM_IO
break
else:
raise ValueError('Excursion Funnel "{}" has inputs, '
'but no valid types!'.format(
inp_item.name))
conn = Connection(
inp_item,
item,
conn_type,
in_outputs,
)
conn.add()
# Make signage frames
shape_frame_tex = [mat for mat in shape_frame_tex if mat]
if shape_frame_tex and enable_shape_frame:
for shape_mat in sign_shape_by_index.values():
# Sort so which gets what frame is consistent.
shape_mat.sort()
for index, shape in enumerate(shape_mat):
shape.repeat_group = index
if index == 0:
continue # First, no frames..
frame_mat = shape_frame_tex[(index - 1) % len(shape_frame_tex)]
for overlay in shape:
frame = overlay.copy()
shape.overlay_frames.append(frame)
vmf.add_ent(frame)
frame['material'] = frame_mat
frame['renderorder'] = 1 # On top
def generate_fizzlers(vmf: VMF):
"""Generates fizzler models and the brushes according to their set types.
After this is done, fizzler-related conditions will not function correctly.
However the model instances are now available for modification.
"""
from vbsp import MAP_RAND_SEED
for fizz in FIZZLERS.values():
if fizz.base_inst not in vmf.entities:
continue # The fizzler was removed from the map.
fizz_name = fizz.base_inst['targetname']
fizz_type = fizz.fizz_type
# Static versions are only used for fizzlers which start on.
# Permanently-off fizzlers are kinda useless, so we don't need
# to bother optimising for it.
is_static = bool(
fizz.base_inst.fixup.int('$connectioncount', 0) == 0
and fizz.base_inst.fixup.bool('$start_enabled', 1)
)
pack_list = (
fizz.fizz_type.pack_lists_static
if is_static else
fizz.fizz_type.pack_lists
)
for pack in pack_list:
packing.pack_list(vmf, pack)
if fizz_type.inst[FizzInst.BASE, is_static]:
random.seed('{}_fizz_base_{}'.format(MAP_RAND_SEED, fizz_name))
fizz.base_inst['file'] = random.choice(fizz_type.inst[FizzInst.BASE, is_static])
if not fizz.emitters:
LOGGER.warning('No emitters for fizzler "{}"!', fizz_name)
continue
# Brush index -> entity for ones that need to merge.
# template_brush is used for the templated one.
single_brushes = {} # type: Dict[FizzlerBrush, Entity]
if fizz_type.temp_max or fizz_type.temp_min:
template_brush_ent = vmf.create_ent(
classname='func_brush',
origin=fizz.base_inst['origin'],
)
conditions.set_ent_keys(
template_brush_ent,
fizz.base_inst,
fizz_type.temp_brush_keys,
)
else:
template_brush_ent = None
up_dir = fizz.up_axis
forward = (fizz.emitters[0][1] - fizz.emitters[0][0]).norm()
min_angles = FIZZ_ANGLES[forward.as_tuple(), up_dir.as_tuple()]
max_angles = FIZZ_ANGLES[(-forward).as_tuple(), up_dir.as_tuple()]
model_min = (
fizz_type.inst[FizzInst.PAIR_MIN, is_static]
or fizz_type.inst[FizzInst.ALL, is_static]
)
model_max = (
fizz_type.inst[FizzInst.PAIR_MAX, is_static]
or fizz_type.inst[FizzInst.ALL, is_static]
)
if not model_min or not model_max:
raise ValueError(
'No model specified for one side of "{}"'
' fizzlers'.format(fizz_type.id),
)
# Define a function to do the model names.
model_index = 0
if fizz_type.model_naming is ModelName.SAME:
def get_model_name(ind):
"""Give every emitter the base's name."""
return fizz_name
elif fizz_type.model_naming is ModelName.LOCAL:
def get_model_name(ind):
"""Give every emitter a name local to the base."""
return fizz_name + '-' + fizz_type.model_name
elif fizz_type.model_naming is ModelName.PAIRED:
def get_model_name(ind):
"""Give each pair of emitters the same unique name."""
return '{}-{}{:02}'.format(
fizz_name,
fizz_type.model_name,
ind,
)
elif fizz_type.model_naming is ModelName.UNIQUE:
def get_model_name(ind):
"""Give every model a unique name."""
nonlocal model_index
model_index += 1
return '{}-{}{:02}'.format(
fizz_name,
fizz_type.model_name,
model_index,
)
else:
raise ValueError('Bad ModelName?')
# Generate env_beam pairs.
for beam in fizz_type.beams:
beam_template = Entity(vmf)
conditions.set_ent_keys(beam_template, fizz.base_inst, beam.keys)
beam_template['classname'] = 'env_beam'
del beam_template['LightningEnd'] # Don't allow users to set end pos.
name = beam_template['targetname'] + '_'
counter = 1
for seg_min, seg_max in fizz.emitters:
for offset in beam.offset: # type: Vec
min_off = offset.copy()
max_off = offset.copy()
min_off.localise(seg_min, min_angles)
max_off.localise(seg_max, max_angles)
beam_ent = beam_template.copy()
vmf.add_ent(beam_ent)
# Allow randomising speed and direction.
if 0 < beam.speed_min < beam.speed_max:
random.seed('{}{}{}'.format(MAP_RAND_SEED, min_off, max_off))
beam_ent['TextureScroll'] = random.randint(beam.speed_min, beam.speed_max)
if random.choice((False, True)):
# Flip to reverse direction.
min_off, max_off = max_off, min_off
beam_ent['origin'] = min_off
beam_ent['LightningStart'] = beam_ent['targetname'] = (
name + str(counter)
)
counter += 1
beam_ent['targetpoint'] = max_off
# Prepare to copy over instance traits for the emitters.
fizz_traits = instance_traits.get(fizz.base_inst).copy()
# Special case, mark emitters that have a custom position for Clean
# models.
if fizz.has_cust_position:
fizz_traits.add('cust_shape')
mat_mod_tex = {} # type: Dict[FizzlerBrush, Set[str]]
for brush_type in fizz_type.brushes:
if brush_type.mat_mod_var is not None:
mat_mod_tex[brush_type] = set()
# Record the data for trigger hurts so flinch triggers can match them.
trigger_hurt_name = ''
trigger_hurt_start_disabled = '0'
for seg_ind, (seg_min, seg_max) in enumerate(fizz.emitters, start=1):
length = (seg_max - seg_min).mag()
random.seed('{}_fizz_{}'.format(MAP_RAND_SEED, seg_min))
if length == 128 and fizz_type.inst[FizzInst.PAIR_SINGLE, is_static]:
min_inst = vmf.create_ent(
targetname=get_model_name(seg_ind),
classname='func_instance',
file=random.choice(fizz_type.inst[FizzInst.PAIR_SINGLE, is_static]),
origin=(seg_min + seg_max)/2,
angles=min_angles,
)
else:
# Both side models.
min_inst = vmf.create_ent(
targetname=get_model_name(seg_ind),
classname='func_instance',
file=random.choice(model_min),
origin=seg_min,
angles=min_angles,
)
random.seed('{}_fizz_{}'.format(MAP_RAND_SEED, seg_max))
max_inst = vmf.create_ent(
targetname=get_model_name(seg_ind),
classname='func_instance',
file=random.choice(model_max),
origin=seg_max,
angles=max_angles,
)
max_inst.fixup.update(fizz.base_inst.fixup)
instance_traits.get(max_inst).update(fizz_traits)
min_inst.fixup.update(fizz.base_inst.fixup)
instance_traits.get(min_inst).update(fizz_traits)
if fizz_type.inst[FizzInst.GRID, is_static]:
# Generate one instance for each position.
# Go 64 from each side, and always have at least 1 section
# A 128 gap will have length = 0
for ind, dist in enumerate(range(64, round(length) - 63, 128)):
mid_pos = seg_min + forward * dist
random.seed('{}_fizz_mid_{}'.format(MAP_RAND_SEED, mid_pos))
mid_inst = vmf.create_ent(
classname='func_instance',
targetname=fizz_name,
angles=min_angles,
file=random.choice(fizz_type.inst[FizzInst.GRID, is_static]),
origin=mid_pos,
)
mid_inst.fixup.update(fizz.base_inst.fixup)
instance_traits.get(mid_inst).update(fizz_traits)
if template_brush_ent is not None:
if length == 128 and fizz_type.temp_single:
temp = template_brush.import_template(
fizz_type.temp_single,
(seg_min + seg_max) / 2,
min_angles,
force_type=template_brush.TEMP_TYPES.world,
add_to_map=False,
)
template_brush_ent.solids.extend(temp.world)
else:
if fizz_type.temp_min:
temp = template_brush.import_template(
fizz_type.temp_min,
seg_min,
min_angles,
force_type=template_brush.TEMP_TYPES.world,
add_to_map=False,
)
template_brush_ent.solids.extend(temp.world)
if fizz_type.temp_max:
temp = template_brush.import_template(
fizz_type.temp_max,
seg_max,
max_angles,
force_type=template_brush.TEMP_TYPES.world,
add_to_map=False,
)
template_brush_ent.solids.extend(temp.world)
# Generate the brushes.
for brush_type in fizz_type.brushes:
brush_ent = None
# If singular, we reuse the same brush ent for all the segments.
if brush_type.singular:
brush_ent = single_brushes.get(brush_type, None)
# Non-singular or not generated yet - make the entity.
if brush_ent is None:
brush_ent = vmf.create_ent(classname='func_brush')
for key_name, key_value in brush_type.keys.items():
brush_ent[key_name] = conditions.resolve_value(fizz.base_inst, key_value)
for key_name, key_value in brush_type.local_keys.items():
brush_ent[key_name] = conditions.local_name(
fizz.base_inst, conditions.resolve_value(
fizz.base_inst, key_value,
)
)
brush_ent['targetname'] = conditions.local_name(
fizz.base_inst, brush_type.name,
)
# Set this to the center, to make sure it's not going to leak.
brush_ent['origin'] = (seg_min + seg_max)/2
# For fizzlers flat on the floor/ceiling, scanlines look
# useless. Turn them off.
if 'usescanline' in brush_ent and fizz.normal().z:
brush_ent['UseScanline'] = 0
if brush_ent['classname'] == 'trigger_hurt':
trigger_hurt_name = brush_ent['targetname']
trigger_hurt_start_disabled = brush_ent['startdisabled']
if brush_type.set_axis_var:
brush_ent['vscript_init_code'] = (
'axis <- `{}`;'.format(
fizz.normal().axis(),
)
)
for out in brush_type.outputs:
new_out = out.copy()
new_out.target = conditions.local_name(
fizz.base_inst,
new_out.target,
)
brush_ent.add_out(new_out)
if brush_type.singular:
# Record for the next iteration.
single_brushes[brush_type] = brush_ent
# If we have a material_modify_control to generate,
# we need to parent it to ourselves to restrict it to us
# only. We also need one for each material, so provide a
# function to the generator which adds to a set.
if brush_type.mat_mod_var is not None:
used_tex_func = mat_mod_tex[brush_type].add
else:
def used_tex_func(val):
"""If not, ignore those calls."""
return None
# Generate the brushes and texture them.
brush_ent.solids.extend(
brush_type.generate(
vmf,
fizz,
seg_min,
seg_max,
used_tex_func,
)
)
if trigger_hurt_name:
fizz.gen_flinch_trigs(
vmf,
trigger_hurt_name,
trigger_hurt_start_disabled,
)
# If we have the config, but no templates used anywhere...
if template_brush_ent is not None and not template_brush_ent.solids:
template_brush_ent.remove()
for brush_type, used_tex in mat_mod_tex.items():
brush_name = conditions.local_name(fizz.base_inst, brush_type.name)
mat_mod_name = conditions.local_name(fizz.base_inst, brush_type.mat_mod_name)
for off, tex in zip(MATMOD_OFFSETS, sorted(used_tex)):
pos = off.copy().rotate(*min_angles)
pos += Vec.from_str(fizz.base_inst['origin'])
vmf.create_ent(
classname='material_modify_control',
origin=pos,
targetname=mat_mod_name,
materialName='materials/' + tex + '.vmt',
materialVar=brush_type.mat_mod_var,
parentname=brush_name,
)
def parse_map(vmf: VMF, voice_attrs: Dict[str, bool]) -> None:
"""Analyse fizzler instances to assign fizzler types.
Instance traits are required.
The model instances and brushes will be removed from the map.
Needs connections to be parsed.
"""
# Item ID and model skin -> fizzler type
fizz_types = {} # type: Dict[Tuple[str, int], FizzlerType]
for fizz_type in FIZZ_TYPES.values():
for item_id in fizz_type.item_ids:
if ':' in item_id:
item_id, barrier_type = item_id.split(':')
if barrier_type == 'laserfield':
barrier_skin = 2
elif barrier_type == 'fizzler':
barrier_skin = 0
else:
LOGGER.error('Invalid barrier type ({}) for "{}"!', barrier_type, item_id)
fizz_types[item_id, 0] = fizz_type
fizz_types[item_id, 2] = fizz_type
continue
fizz_types[item_id, barrier_skin] = fizz_type
else:
fizz_types[item_id, 0] = fizz_type
fizz_types[item_id, 2] = fizz_type
fizz_bases = {} # type: Dict[str, Entity]
fizz_models = defaultdict(list) # type: Dict[str, List[Entity]]
# Position and normal -> name, for output relays.
fizz_pos = {} # type: Dict[Tuple[Tuple[float, float, float], Tuple[float, float, float]], str]
# First use traits to gather up all the instances.
for inst in vmf.by_class['func_instance']:
traits = instance_traits.get(inst)
if 'fizzler' not in traits:
continue
name = inst['targetname']
if 'fizzler_model' in traits:
name = name.rsplit('_model', 1)[0]
fizz_models[name].append(inst)
inst.remove()
elif 'fizzler_base' in traits:
fizz_bases[name] = inst
else:
LOGGER.warning('Fizzler "{}" has non-base, non-model instance?', name)
continue
origin = Vec.from_str(inst['origin'])
normal = Vec(z=1).rotate_by_str(inst['angles'])
fizz_pos[origin.as_tuple(), normal.as_tuple()] = name
for name, base_inst in fizz_bases.items():
models = fizz_models[name]
up_axis = Vec(y=1).rotate_by_str(base_inst['angles'])
# If upside-down, make it face upright.
if up_axis == (0, 0, -1):
up_axis = Vec(z=1)
base_inst.outputs.clear()
# Now match the pairs of models to each other.
# The length axis is the line between them.
# We don't care about the instances after this, so don't keep track.
length_axis = Vec(z=1).rotate_by_str(base_inst['angles']).axis()
emitters = [] # type: List[Tuple[Vec, Vec]]
model_pairs = {} # type: Dict[Tuple[float, float], Vec]
model_skin = models[0].fixup.int('$skin')
try:
item_id, item_subtype = instanceLocs.ITEM_FOR_FILE[base_inst['file'].casefold()]
fizz_type = fizz_types[item_id, model_skin]
except KeyError:
LOGGER.warning('Fizzler types: {}', fizz_types.keys())
raise ValueError('No fizzler type for "{}"!'.format(
base_inst['file'],
)) from None
for attr_name in fizz_type.voice_attrs:
voice_attrs[attr_name] = True
for model in models:
pos = Vec.from_str(model['origin'])
try:
other_pos = model_pairs.pop(pos.other_axes(length_axis))
except KeyError:
# No other position yet, we need to find that.
model_pairs[pos.other_axes(length_axis)] = pos
continue
min_pos, max_pos = Vec.bbox(pos, other_pos)
# Move positions to the wall surface.
min_pos[length_axis] -= 64
max_pos[length_axis] += 64
emitters.append((min_pos, max_pos))
FIZZLERS[name] = Fizzler(fizz_type, up_axis, base_inst, emitters)
# Delete all the old brushes associated with fizzlers
for brush in (
vmf.by_class['trigger_portal_cleanser'] |
vmf.by_class['trigger_hurt'] |
vmf.by_class['func_brush']
):
name = brush['targetname']
if not name:
continue
name = name.rsplit('_brush')[0]
if name in FIZZLERS:
brush.remove()
# Check for fizzler output relays.
relay_file = instanceLocs.resolve('<ITEM_BEE2_FIZZLER_OUT_RELAY>', silent=True)
if not relay_file:
# No relay item - deactivated most likely.
return
for inst in vmf.by_class['func_instance']:
if inst['file'].casefold() not in relay_file:
continue
inst.remove()
relay_item = connections.ITEMS[inst['targetname']]
try:
fizz_name = fizz_pos[
Vec.from_str(inst['origin']).as_tuple(),
Vec(0, 0, 1).rotate_by_str(inst['angles']).as_tuple()
]
fizz_item = connections.ITEMS[fizz_name]
except KeyError:
# Not placed on a fizzler, or a fizzler with no IO
# - ignore, and destroy.
for out in list(relay_item.outputs):
out.remove()
for out in list(relay_item.inputs):
out.remove()
del connections.ITEMS[relay_item.name]
continue
# Copy over fixup values
fizz_item.inst.fixup.update(inst.fixup)
# Copy over the timer delay set in the relay.
fizz_item.timer = relay_item.timer
# Transfer over antlines.
fizz_item.antlines |= relay_item.antlines
fizz_item.shape_signs += relay_item.shape_signs
fizz_item.ind_panels |= relay_item.ind_panels
# Remove the relay item so it doesn't get added to the map.
del connections.ITEMS[relay_item.name]
for conn in list(relay_item.outputs):
conn.from_item = fizz_item
