def res_match_item_config(inst: Entity, res: Property) -> bool:
"""Check if an Item Config Panel value matches another value.
* `ID` is the ID of the group.
* `Name` is the name of the widget.
* If `UseTimer` is true, it uses `$timer_delay` to choose the value to use.
* `Value` is the value to compare to.
"""
group_id = res['ID']
wid_name = res['Name'].casefold()
desired_value = res['Value']
if res.bool('UseTimer'):
timer_delay = inst.fixup.int('$timer_delay')
else:
timer_delay = None
conf = options.get_itemconf((group_id, wid_name), None, timer_delay)
if conf is None: # Doesn't exist
return False
return conf == desired_value
def get_itemconf(inst: Entity, res: Property) -> str | None:
"""Implement ItemConfig and GetItemConfig shared logic."""
timer_delay: int | None
group_id = res['ID']
wid_name = inst.fixup.substitute(res['Name']).casefold()
match = BRACE_RE.match(wid_name)
if match is not None: # Match name[timer], after $fixup substitution.
wid_name, timer_str = match.groups()
# Should not fail, we matched it above.
timer_delay = int(timer_str)
elif res.bool('UseTimer'):
LOGGER.warning(
'UseTimer is deprecated, use name = "{}[$timer_delay]".',
wid_name,
)
timer_delay = inst.fixup.int('$timer_delay')
else:
timer_delay = None
return options.get_itemconf((group_id, wid_name), None, timer_delay)
def res_item_config_to_fixup(inst: Entity, res: Property) -> None:
"""Load a config from the item config panel onto a fixup.
* `ID` is the ID of the group.
* `Name` is the name of the widget.
* `resultVar` is the location to store the value into.
* If `UseTimer` is true, it uses `$timer_delay` to choose the value to use.
* `Default` is the default value, if the config isn't found.
"""
group_id = res['ID']
wid_name = res['Name']
default = res['default']
if res.bool('UseTimer'):
timer_delay = inst.fixup.int('$timer_delay')
else:
timer_delay = None
inst.fixup[res['ResultVar']] = options.get_itemconf(
(group_id, wid_name),
default,
timer_delay,
)
def make_barriers(vmf: VMF):
"""Make barrier entities. get_tex is vbsp.get_tex."""
glass_temp = template_brush.get_scaling_template(
options.get(str, "glass_template"))
grate_temp = template_brush.get_scaling_template(
options.get(str, "grating_template"))
hole_temp_small: List[Solid]
hole_temp_lrg_diag: List[Solid]
hole_temp_lrg_cutout: List[Solid]
hole_temp_lrg_square: List[Solid]
# Avoid error without this package.
if HOLES:
# Grab the template solids we need.
hole_combined_temp = template_brush.get_template(
options.get(str, 'glass_hole_temp'))
hole_world, hole_detail, _ = hole_combined_temp.visgrouped({'small'})
hole_temp_small = hole_world + hole_detail
hole_world, hole_detail, _ = hole_combined_temp.visgrouped(
{'large_diagonal'})
hole_temp_lrg_diag = hole_world + hole_detail
hole_world, hole_detail, _ = hole_combined_temp.visgrouped(
{'large_cutout'})
hole_temp_lrg_cutout = hole_world + hole_detail
hole_world, hole_detail, _ = hole_combined_temp.visgrouped(
{'large_square'})
hole_temp_lrg_square = hole_world + hole_detail
else:
hole_temp_small = hole_temp_lrg_diag = hole_temp_lrg_cutout = hole_temp_lrg_square = []
floorbeam_temp = options.get(str, 'glass_floorbeam_temp')
if options.get_itemconf('BEE_PELLET:PelletGrating', False):
# Merge together these existing filters in global_pti_ents
vmf.create_ent(
origin=options.get(Vec, 'global_pti_ents_loc'),
targetname='@grating_filter',
classname='filter_multi',
filtertype=0,
negated=0,
filter01='@not_pellet',
filter02='@not_paint_bomb',
)
else:
# Just skip paint bombs.
vmf.create_ent(
origin=options.get(Vec, 'global_pti_ents_loc'),
targetname='@grating_filter',
classname='filter_activator_class',
negated=1,
filterclass='prop_paint_bomb',
)
# Group the positions by planes in each orientation.
# This makes them 2D grids which we can optimise.
# (normal_dist, positive_axis, type) -> [(x, y)]
slices: Dict[Tuple[Tuple[float, float, float], bool, BarrierType],
Dict[Tuple[int, int], False]] = defaultdict(dict)
# We have this on the 32-grid so we can cut squares for holes.
for (origin_tup, normal_tup), barr_type in BARRIERS.items():
origin = Vec(origin_tup)
normal = Vec(normal_tup)
norm_axis = normal.axis()
u, v = origin.other_axes(norm_axis)
norm_pos = Vec.with_axes(norm_axis, origin)
slice_plane = slices[
norm_pos.as_tuple(), # distance from origin to this plane.
normal[norm_axis] > 0, barr_type, ]
for u_off in [-48, -16, 16, 48]:
for v_off in [-48, -16, 16, 48]:
slice_plane[int((u + u_off) // 32),
int((v + v_off) // 32), ] = True
# Remove pane sections where the holes are. We then generate those with
# templates for slanted parts.
for (origin_tup, norm_tup), hole_type in HOLES.items():
barr_type = BARRIERS[origin_tup, norm_tup]
origin = Vec(origin_tup)
normal = Vec(norm_tup)
norm_axis = normal.axis()
u, v = origin.other_axes(norm_axis)
norm_pos = Vec.with_axes(norm_axis, origin)
slice_plane = slices[norm_pos.as_tuple(), normal[norm_axis] > 0,
barr_type, ]
if hole_type is HoleType.LARGE:
offsets = (-80, -48, -16, 16, 48, 80)
else:
offsets = (-16, 16)
for u_off in offsets:
for v_off in offsets:
# Remove these squares, but keep them in the dict
# so we can check if there was glass there.
uv = (
int((u + u_off) // 32),
int((v + v_off) // 32),
)
if uv in slice_plane:
slice_plane[uv] = False
# These have to be present, except for the corners
# on the large hole.
elif abs(u_off) != 80 or abs(v_off) != 80:
u_ax, v_ax = Vec.INV_AXIS[norm_axis]
LOGGER.warning(
'Hole tried to remove missing tile at ({})?',
Vec.with_axes(norm_axis, norm_pos, u_ax, u + u_off,
v_ax, v + v_off),
)
# Now generate the curved brushwork.
if barr_type is BarrierType.GLASS:
front_temp = glass_temp
elif barr_type is BarrierType.GRATING:
front_temp = grate_temp
else:
raise NotImplementedError
angles = normal.to_angle()
hole_temp: List[Tuple[List[Solid], Matrix]] = []
# This is a tricky bit. Two large templates would collide
# diagonally, and we allow the corner glass to not be present since
# the hole doesn't actually use that 32x32 segment.
# So we need to determine which of 3 templates to use.
corn_angles = angles.copy()
if hole_type is HoleType.LARGE:
for corn_angles.roll in (0, 90, 180, 270):
corn_mat = Matrix.from_angle(corn_angles)
corn_dir = Vec(y=1, z=1) @ corn_angles
hole_off = origin + 128 * corn_dir
diag_type = HOLES.get(
(hole_off.as_tuple(), normal.as_tuple()),
None,
)
corner_pos = origin + 80 * corn_dir
corn_u, corn_v = corner_pos.other_axes(norm_axis)
corn_u = int(corn_u // 32)
corn_v = int(corn_v // 32)
if diag_type is HoleType.LARGE:
# There's another large template to this direction.
# Just have 1 generate both combined, so the brushes can
# be more optimal. To pick, arbitrarily make the upper one
# be in charge.
if corn_v > v // 32:
hole_temp.append((hole_temp_lrg_diag, corn_mat))
continue
if (corn_u, corn_v) in slice_plane:
hole_temp.append((hole_temp_lrg_square, corn_mat))
else:
hole_temp.append((hole_temp_lrg_cutout, corn_mat))
else:
hole_temp.append((hole_temp_small, Matrix.from_angle(angles)))
def solid_pane_func(off1: float, off2: float, mat: str) -> List[Solid]:
"""Given the two thicknesses, produce the curved hole from the template."""
off_min = 64 - max(off1, off2)
off_max = 64 - min(off1, off2)
new_brushes = []
for brushes, matrix in hole_temp:
for orig_brush in brushes:
brush = orig_brush.copy(vmf_file=vmf)
new_brushes.append(brush)
for face in brush.sides:
face.mat = mat
for point in face.planes:
if point.x > 64:
point.x = off_max
else:
point.x = off_min
face.localise(origin, matrix)
# Increase precision, these are small detail brushes.
face.lightmap = 8
return new_brushes
make_glass_grating(
vmf,
origin,
normal,
barr_type,
front_temp,
solid_pane_func,
)
for (plane_pos, is_pos, barr_type), pos_slice in slices.items():
plane_pos = Vec(plane_pos)
norm_axis = plane_pos.axis()
normal = Vec.with_axes(norm_axis, 1 if is_pos else -1)
if barr_type is BarrierType.GLASS:
front_temp = glass_temp
elif barr_type is BarrierType.GRATING:
front_temp = grate_temp
else:
raise NotImplementedError
u_axis, v_axis = Vec.INV_AXIS[norm_axis]
for min_u, min_v, max_u, max_v in grid_optimise(pos_slice):
# These are two points in the origin plane, at the borders.
pos_min = Vec.with_axes(
norm_axis,
plane_pos,
u_axis,
min_u * 32,
v_axis,
min_v * 32,
)
pos_max = Vec.with_axes(
norm_axis,
plane_pos,
u_axis,
max_u * 32 + 32,
v_axis,
max_v * 32 + 32,
)
def solid_pane_func(pos1: float, pos2: float,
mat: str) -> List[Solid]:
"""Make the solid brush."""
return [
vmf.make_prism(
pos_min + normal * (64.0 - pos1),
pos_max + normal * (64.0 - pos2),
mat=mat,
).solid
]
make_glass_grating(
vmf,
(pos_min + pos_max) / 2 + 63 * normal,
normal,
barr_type,
front_temp,
solid_pane_func,
)
# Generate hint brushes, to ensure sorting is done correctly.
[hint] = solid_pane_func(0, 4.0, consts.Tools.SKIP)
for side in hint:
if abs(Vec.dot(side.normal(), normal)) > 0.99:
side.mat = consts.Tools.HINT
vmf.add_brush(hint)
if floorbeam_temp:
LOGGER.info('Adding Glass floor beams...')
add_glass_floorbeams(vmf, floorbeam_temp)
LOGGER.info('Done!')
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