def as_ent(self, vmf: VMF) -> Entity:
"""Convert back into an entity."""
# If a plane, then we have to produce a valid brush - subtract in the negative dir, put skip
# on all other sides.
norm = self.plane_normal
if norm is not None:
prism = vmf.make_prism(self.mins - norm, self.maxes, consts.Tools.SKIP)
if norm == (1, 0, 0):
prism.east.mat = consts.Tools.CLIP
elif norm == (0, 1, 0):
prism.north.mat = consts.Tools.CLIP
elif norm == (0, 0, 1):
prism.top.mat = consts.Tools.CLIP
else:
raise AssertionError(norm)
else:
prism = vmf.make_prism(self.mins, self.maxes, consts.Tools.CLIP)
ent = vmf.create_ent(
'bee2_collision_bbox',
tags=' '.join(sorted(self.tags)),
item_name=self.name,
)
for coll in CollideType:
if coll is not CollideType.EVERYTHING:
ent[f'coll_{coll.name.lower()}'] = (coll & self.contents) is not CollideType.NOTHING
ent.solids.append(prism.solid)
return ent
def test_bbox_parse_block() -> None:
"""Test parsing of a block-shaped bbox from a VMF."""
vmf = VMF()
ent = vmf.create_ent(
'bee2_collision_bbox',
coll_deco=1,
coll_physics=1,
coll_grating=0,
tags='standard excellent',
)
ent.solids.append(vmf.make_prism(Vec(80, 10, 40), Vec(150, 220, 70)).solid)
ent.solids.append(vmf.make_prism(Vec(-30, 45, 80), Vec(-20, 60, 120)).solid)
bb2, bb1 = BBox.from_ent(ent)
# Allow it to produce in either order.
if bb1.min_x == -30:
bb1, bb2 = bb2, bb1
assert_bbox(
bb1,
(80, 10, 40), (150, 220, 70),
CollideType.DECORATION | CollideType.PHYSICS,
{'standard', 'excellent'},
)
assert_bbox(
bb2,
(-30, 45, 80), (-20, 60, 120),
CollideType.DECORATION | CollideType.PHYSICS,
{'standard', 'excellent'},
)
def make_alpha_base(vmf: VMF, bbox_min: Vec, bbox_max: Vec,
noise: SimplexNoise):
"""Add the base to a CutoutTile, using displacements."""
# We want to limit the size of brushes to 512, so the vertexes don't
# get too far apart.
# This now contains each point from beginning to end inclusive.
x, y, z = bbox_min
dim_x = bbox_max.x - bbox_min.x
dim_y = bbox_max.y - bbox_min.y
widths = [x for x in range(0, int(dim_x), 512)] + [dim_x]
heights = [y for y in range(0, int(dim_y), 512)] + [dim_y]
# Loop over two offset copies, so we get a min and max each time.
for x1, x2 in zip(widths, widths[1:]):
for y1, y2 in zip(heights, heights[1:]):
# We place our displacement 1 unit above the surface, then offset
# the verts down.
brush = vmf.make_prism(
Vec(x + x1, y + y1, z - FLOOR_DEPTH),
Vec(x + x2, y + y2, z - FLOOR_DEPTH - 1),
)
brush.top.mat = random.choice(MATS['floorbase_disp'])
make_displacement(
brush.top,
offset=-1,
noise=noise,
)
vmf.add_brush(brush.solid)
def test_bbox_parse_plane(axis: str, mins: tuple3, maxes: tuple3) -> None:
"""Test parsing planar bboxes from a VMF.
With 5 skip sides, the brush is flattened into the remaining plane.
"""
vmf = VMF()
ent = vmf.create_ent('bee2_collision_bbox', coll_solid=1)
prism = vmf.make_prism(Vec(80, 10, 40), Vec(150, 220, 70), mat='tools/toolsskip')
getattr(prism, axis).mat = 'tools/toolsclip'
ent.solids.append(prism.solid)
[bbox] = BBox.from_ent(ent)
assert_bbox(bbox, mins, maxes, CollideType.SOLID, set())
def make_tile(vmf: VMF, p1: Vec, p2: Vec, top_mat, bottom_mat, beam_mat):
"""Generate a 2 or 1 unit thick squarebeams tile.
"""
prism = vmf.make_prism(p1, p2)
brush, t, b, n, s, e, w = prism
t.mat = top_mat
b.mat = bottom_mat
n.mat = beam_mat
s.mat = beam_mat
e.mat = beam_mat
w.mat = beam_mat
thickness = abs(p1.z - p2.z)
if thickness == 2:
# The z-axis texture offset needed
# The texture is 512 high, so wrap around
# 56 is the offset for the thin-line part of squarebeams
# Textures are at 0.25 size, so 4 per hammer unit
z_off = ((max(p1.z, p2.z) * 4) + 56) % 512
elif thickness == 1:
# Slightly different offset, so the line is still centered
z_off = ((max(p1.z, p2.z) * 4) + 54) % 512
else:
raise ValueError(
'Tile has incorrect thickness '
'(expected 1 or 2, got {})'.format(thickness)
)
n.uaxis = UVAxis(
0, 0, 1, offset=z_off)
n.vaxis = UVAxis(
1, 0, 0, offset=0)
s.uaxis = n.uaxis.copy()
s.vaxis = n.vaxis.copy()
e.uaxis = UVAxis(
0, 0, 1, offset=z_off)
e.vaxis = UVAxis(
0, 1, 0, offset=0)
w.uaxis = e.uaxis.copy()
w.vaxis = e.vaxis.copy()
# Ensure the squarebeams textures aren't replaced, as well as floor tex
vbsp.IGNORED_FACES.update(brush.sides)
return prism
def make_tile(vmf: VMF, p1: Vec, p2: Vec, top_mat, bottom_mat, beam_mat):
"""Generate a 2 or 1 unit thick squarebeams tile.
"""
prism = vmf.make_prism(p1, p2)
brush, t, b, n, s, e, w = prism
t.mat = top_mat
b.mat = bottom_mat
n.mat = beam_mat
s.mat = beam_mat
e.mat = beam_mat
w.mat = beam_mat
thickness = abs(p1.z - p2.z)
if thickness == 2:
# The z-axis texture offset needed
# The texture is 512 high, so wrap around
# 56 is the offset for the thin-line part of squarebeams
# Textures are at 0.25 size, so 4 per hammer unit
z_off = ((max(p1.z, p2.z) * 4) + 56) % 512
elif thickness == 1:
# Slightly different offset, so the line is still centered
z_off = ((max(p1.z, p2.z) * 4) + 54) % 512
else:
raise ValueError('Tile has incorrect thickness '
'(expected 1 or 2, got {})'.format(thickness))
n.uaxis = UVAxis(0, 0, 1, offset=z_off)
n.vaxis = UVAxis(1, 0, 0, offset=0)
s.uaxis = n.uaxis.copy()
s.vaxis = n.vaxis.copy()
e.uaxis = UVAxis(0, 0, 1, offset=z_off)
e.vaxis = UVAxis(0, 1, 0, offset=0)
w.uaxis = e.uaxis.copy()
w.vaxis = e.vaxis.copy()
# Ensure the squarebeams textures aren't replaced, as well as floor tex
vbsp.IGNORED_FACES.update(brush.sides)
return prism
def make_tile(vmf: VMF, p1: Vec, p2: Vec, top_mat, bottom_mat, beam_mat):
"""Generate a 2 or 1 unit thick squarebeams tile.
"""
prism = vmf.make_prism(p1, p2)
prism.top.mat = top_mat
prism.bottom.mat = bottom_mat
prism.north.mat = beam_mat
prism.south.mat = beam_mat
prism.east.mat = beam_mat
prism.west.mat = beam_mat
thickness = abs(p1.z - p2.z)
if thickness == 2:
# The z-axis texture offset needed
# The texture is 512 high, so wrap around
# 56 is the offset for the thin-line part of squarebeams
# Textures are at 0.25 size, so 4 per hammer unit
z_off = ((max(p1.z, p2.z) * 4) + 56) % 512
elif thickness == 1:
# Slightly different offset, so the line is still centered
z_off = ((max(p1.z, p2.z) * 4) + 54) % 512
else:
raise ValueError('Tile has incorrect thickness '
'(expected 1 or 2, got {})'.format(thickness))
prism.north.uaxis = UVAxis(0, 0, 1, offset=z_off)
prism.north.vaxis = UVAxis(1, 0, 0, offset=0)
prism.south.uaxis = prism.north.uaxis.copy()
prism.south.vaxis = prism.north.vaxis.copy()
prism.east.uaxis = UVAxis(0, 0, 1, offset=z_off)
prism.east.vaxis = UVAxis(0, 1, 0, offset=0)
prism.west.uaxis = prism.east.uaxis.copy()
prism.west.vaxis = prism.east.vaxis.copy()
return prism
def make_alpha_base(vmf: VMF, bbox_min: Vec, bbox_max: Vec, noise: SimplexNoise):
"""Add the base to a CutoutTile, using displacements."""
# We want to limit the size of brushes to 512, so the vertexes don't
# get too far apart.
# This now contains each point from beginning to end inclusive.
x, y, z = bbox_min
dim_x = bbox_max.x - bbox_min.x
dim_y = bbox_max.y - bbox_min.y
widths = [
x
for x in
range(0, int(dim_x), 512)
] + [dim_x]
heights = [
y
for y in
range(0, int(dim_y), 512)
] + [dim_y]
# Loop over two offset copies, so we get a min and max each time.
for x1, x2 in zip(widths, widths[1:]):
for y1, y2 in zip(heights, heights[1:]):
# We place our displacement 1 unit above the surface, then offset
# the verts down.
brush = vmf.make_prism(
Vec(x + x1, y + y1, z - FLOOR_DEPTH),
Vec(x + x2, y + y2, z - FLOOR_DEPTH - 1),
)
brush.top.mat = random.choice(MATS['floorbase_disp'])
make_displacement(
brush.top,
offset=-1,
noise=noise,
)
vmf.add_brush(brush.solid)
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_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_cutout_tile(vmf: srctools.VMF, res: Property):
"""Generate random quarter tiles, like in Destroyed or Retro maps.
- "MarkerItem" is the instance to look for.
- "TileSize" can be "2x2" or "4x4".
- rotateMax is the amount of degrees to rotate squarebeam models.
Materials:
- "squarebeams" is the squarebeams variant to use.
- "ceilingwalls" are the sides of the ceiling section.
- "floorbase" is the texture under floor sections.
- "tile_glue" is used on top of a thinner tile segment.
- "clip" is the player_clip texture used over floor segments.
(This allows customising the surfaceprop.)
- "Floor4x4Black", "Ceil2x2White" and other combinations can be used to
override the textures used.
"""
item = instanceLocs.resolve(res['markeritem'])
INST_LOCS = {} # Map targetnames -> surface loc
CEIL_IO = [] # Pairs of ceil inst corners to cut out.
FLOOR_IO = [] # Pairs of floor inst corners to cut out.
overlay_ids = {} # When we replace brushes, we need to fix any overlays
# on that surface.
MATS.clear()
floor_edges = [] # Values to pass to add_floor_sides() at the end
sign_loc = set(FORCE_LOCATIONS)
# If any signage is present in the map, we need to force tiles to
# appear at that location!
for over in vmf.by_class['info_overlay']:
if (over['material'].casefold() in FORCE_TILE_MATS and
# Only check floor/ceiling overlays
over['basisnormal'] in ('0 0 1', '0 0 -1')):
loc = Vec.from_str(over['origin'])
# Sometimes (light bridges etc) a sign will be halfway between
# tiles, so in that case we need to force 2 tiles.
loc_min = (loc - (15, 15, 0)) // 32 * 32 # type: Vec
loc_max = (loc + (15, 15, 0)) // 32 * 32 # type: Vec
loc_min += (16, 16, 0)
loc_max += (16, 16, 0)
FORCE_LOCATIONS.add(loc_min.as_tuple())
FORCE_LOCATIONS.add(loc_max.as_tuple())
SETTINGS = {
'floor_chance':
srctools.conv_int(res['floorChance', '100'], 100),
'ceil_chance':
srctools.conv_int(res['ceilingChance', '100'], 100),
'floor_glue_chance':
srctools.conv_int(res['floorGlueChance', '0']),
'ceil_glue_chance':
srctools.conv_int(res['ceilingGlueChance', '0']),
'rotate_beams':
int(srctools.conv_float(res['rotateMax', '0']) * BEAM_ROT_PRECISION),
'beam_skin':
res['squarebeamsSkin', '0'],
'base_is_disp':
srctools.conv_bool(res['dispBase', '0']),
'quad_floor':
res['FloorSize', '4x4'].casefold() == '2x2',
'quad_ceil':
res['CeilingSize', '4x4'].casefold() == '2x2',
}
random.seed(vbsp.MAP_RAND_SEED + '_CUTOUT_TILE_NOISE')
noise = SimplexNoise(period=4 * 40) # 4 tiles/block, 50 blocks max
# We want to know the number of neighbouring tile cutouts before
# placing tiles - blocks away from the sides generate fewer tiles.
floor_neighbours = defaultdict(dict) # all_floors[z][x,y] = count
for mat_prop in res.find_key('Materials', []):
MATS[mat_prop.name].append(mat_prop.value)
if SETTINGS['base_is_disp']:
# We want the normal brushes to become nodraw.
MATS['floorbase_disp'] = MATS['floorbase']
MATS['floorbase'] = ['tools/toolsnodraw']
# Since this uses random data for initialisation, the alpha and
# regular will use slightly different patterns.
alpha_noise = SimplexNoise(period=4 * 50)
else:
alpha_noise = None
for key, default in TEX_DEFAULT:
if key not in MATS:
MATS[key] = [default]
# Find our marker ents
for inst in vmf.by_class['func_instance']:
if inst['file'].casefold() not in item:
continue
targ = inst['targetname']
orient = Vec(0, 0, 1).rotate_by_str(inst['angles', '0 0 0'])
# Check the orientation of the marker to figure out what to generate
if orient == (0, 0, 1):
io_list = FLOOR_IO
else:
io_list = CEIL_IO
# Reuse orient to calculate where the solid face will be.
loc = (orient * -64) + Vec.from_str(inst['origin'])
INST_LOCS[targ] = loc
for out in inst.output_targets():
io_list.append((targ, out))
if not inst.outputs and inst.fixup['$connectioncount'] == '0':
# If the item doesn't have any connections, 'connect'
# it to itself so we'll generate a 128x128 tile segment.
io_list.append((targ, targ))
inst.remove() # Remove the instance itself from the map.
for start_floor, end_floor in FLOOR_IO:
if end_floor not in INST_LOCS:
# Not a marker - remove this and the antline.
for toggle in vmf.by_target[end_floor]:
conditions.remove_ant_toggle(toggle)
continue
box_min = Vec(INST_LOCS[start_floor])
box_min.min(INST_LOCS[end_floor])
box_max = Vec(INST_LOCS[start_floor])
box_max.max(INST_LOCS[end_floor])
if box_min.z != box_max.z:
continue # They're not in the same level!
z = box_min.z
if SETTINGS['rotate_beams']:
# We have to generate 1 model per 64x64 block to do rotation...
gen_rotated_squarebeams(
vmf,
box_min - (64, 64, 0),
box_max + (64, 64, -8),
skin=SETTINGS['beam_skin'],
max_rot=SETTINGS['rotate_beams'],
)
else:
# Make the squarebeams props, using big models if possible
gen_squarebeams(vmf,
box_min + (-64, -64, 0),
box_max + (64, 64, -8),
skin=SETTINGS['beam_skin'])
# Add a player_clip brush across the whole area
vmf.add_brush(
vmf.make_prism(
p1=box_min - (64, 64, FLOOR_DEPTH),
p2=box_max + (64, 64, 0),
mat=MATS['clip'][0],
).solid)
# Add a noportal_volume covering the surface, in case there's
# room for a portal.
noportal_solid = vmf.make_prism(
# Don't go all the way to the sides, so it doesn't affect wall
# brushes.
p1=box_min - (63, 63, 9),
p2=box_max + (63, 63, 0),
mat='tools/toolsinvisible',
).solid
noportal_ent = vmf.create_ent(
classname='func_noportal_volume',
origin=box_min.join(' '),
)
noportal_ent.solids.append(noportal_solid)
if SETTINGS['base_is_disp']:
# Use displacements for the base instead.
make_alpha_base(
vmf,
box_min + (-64, -64, 0),
box_max + (64, 64, 0),
noise=alpha_noise,
)
for x, y in utils.iter_grid(
min_x=int(box_min.x),
max_x=int(box_max.x) + 1,
min_y=int(box_min.y),
max_y=int(box_max.y) + 1,
stride=128,
):
# Build the set of all positions..
floor_neighbours[z][x, y] = -1
# Mark borders we need to fill in, and the angle (for func_instance)
# The wall is the face pointing inwards towards the bottom brush,
# and the ceil is the ceiling of the block above the bordering grid
# points.
for x in range(int(box_min.x), int(box_max.x) + 1, 128):
# North
floor_edges.append(
BorderPoints(
wall=Vec(x, box_max.y + 64, z - 64),
ceil=Vec_tuple(x, box_max.y + 128, z),
rot=270,
))
# South
floor_edges.append(
BorderPoints(
wall=Vec(x, box_min.y - 64, z - 64),
ceil=Vec_tuple(x, box_min.y - 128, z),
rot=90,
))
for y in range(int(box_min.y), int(box_max.y) + 1, 128):
# East
floor_edges.append(
BorderPoints(
wall=Vec(box_max.x + 64, y, z - 64),
ceil=Vec_tuple(box_max.x + 128, y, z),
rot=180,
))
# West
floor_edges.append(
BorderPoints(
wall=Vec(box_min.x - 64, y, z - 64),
ceil=Vec_tuple(box_min.x - 128, y, z),
rot=0,
))
# Now count boundries near tiles, then generate them.
# Do it seperately for each z-level:
for z, xy_dict in floor_neighbours.items(): # type: float, dict
for x, y in xy_dict: # type: float, float
# We want to count where there aren't any tiles
xy_dict[x, y] = (((x - 128, y - 128) not in xy_dict) +
((x - 128, y + 128) not in xy_dict) +
((x + 128, y - 128) not in xy_dict) +
((x + 128, y + 128) not in xy_dict) +
((x - 128, y) not in xy_dict) +
((x + 128, y) not in xy_dict) +
((x, y - 128) not in xy_dict) +
((x, y + 128) not in xy_dict))
max_x = max_y = 0
weights = {}
# Now the counts are all correct, compute the weight to apply
# for tiles.
# Adding the neighbouring counts will make a 5x5 area needed to set
# the center to 0.
for (x, y), cur_count in xy_dict.items():
max_x = max(x, max_x)
max_y = max(y, max_y)
# Orthrogonal is worth 0.2, diagonal is worth 0.1.
# Not-present tiles would be 8 - the maximum
tile_count = (0.8 * cur_count + 0.1 * xy_dict.get(
(x - 128, y - 128), 8) + 0.1 * xy_dict.get(
(x - 128, y + 128), 8) + 0.1 * xy_dict.get(
(x + 128, y - 128), 8) + 0.1 * xy_dict.get(
(x + 128, y + 128), 8) + 0.2 * xy_dict.get(
(x - 128, y), 8) + 0.2 * xy_dict.get(
(x, y - 128), 8) + 0.2 * xy_dict.get(
(x, y + 128), 8) + 0.2 * xy_dict.get(
(x + 128, y), 8))
# The number ranges from 0 (all tiles) to 12.8 (no tiles).
# All tiles should still have a small chance to generate tiles.
weights[x, y] = min((tile_count + 0.5) / 8, 1)
# Share the detail entity among same-height tiles..
detail_ent = vmf.create_ent(classname='func_detail', )
for x, y in xy_dict:
convert_floor(
vmf,
Vec(x, y, z),
overlay_ids,
MATS,
SETTINGS,
sign_loc,
detail_ent,
noise_weight=weights[x, y],
noise_func=noise,
)
add_floor_sides(vmf, floor_edges)
conditions.reallocate_overlays(overlay_ids)
return conditions.RES_EXHAUSTED
def generate(
self,
vmf: VMF,
fizz: Fizzler,
neg: Vec,
pos: Vec,
used_tex_func: Callable[[str], None],
) -> List[Solid]:
"""Generate the actual brush.
used_tex will be filled with the textures used.
"""
diff = neg - pos
# Size of fizzler
field_length = diff.mag()
# Direction it extends across.
field_axis = diff.norm()
# Out of the fizzler.
normal = fizz.normal()
origin = (pos + neg) / 2
# If either of these, we only need 1 brush.
trigger_tex = self.textures[TexGroup.TRIGGER]
fitted_tex = self.textures[TexGroup.FITTED]
# If we don't have this, we can't be a single brush.
short_tex = self.textures[TexGroup.SHORT]
if trigger_tex or fitted_tex:
tex_size = LASER_TEX_SIZE
else:
# Fizzlers are larger resolution..
tex_size = FIZZLER_TEX_SIZE
if (field_length == 128
and not short_tex) or trigger_tex or fitted_tex:
# We need only one brush.
brush = vmf.make_prism(
p1=(origin + (self.thickness / 2) * normal +
64 * fizz.up_axis + (field_length / 2) * field_axis),
p2=(origin - (self.thickness / 2) * normal -
64 * fizz.up_axis - (field_length / 2) * field_axis),
).solid # type: Solid
yield brush
if trigger_tex:
for side in brush.sides:
side.mat = trigger_tex
used_tex_func(trigger_tex)
else:
for side in brush.sides:
side_norm = side.normal()
if abs(side_norm) == abs(fizz.up_axis):
self._side_color(side, normal, neg, used_tex_func)
if abs(side_norm) != normal:
continue
side.mat = fitted_tex or self.textures[
TexGroup.TAG_ON_SHORT if
(fizz.tag_on_pos if normal.dot(side_norm) > 0 else fizz
.tag_on_neg) else TexGroup.SHORT]
used_tex_func(side.mat)
self._texture_fit(
side,
tex_size,
field_length,
fizz,
neg,
pos,
bool(fitted_tex),
)
if not self.stretch_center:
side.uaxis.scale = 0.25
else:
# Generate the three brushes for fizzlers.
if field_length <= 128:
side_len = field_length / 2
center_len = 0
else:
# Bugfix - the boundary texture wrapping causes
# artifacts to appear at the join, we need to avoid a small
# amount of that texture.
side_len = 63
center_len = field_length - 126
brush_left = vmf.make_prism(
p1=(origin - (self.thickness / 2) * normal -
64 * fizz.up_axis -
(side_len - field_length / 2) * field_axis),
p2=(origin + (self.thickness / 2) * normal +
64 * fizz.up_axis + (field_length / 2) * field_axis),
).solid # type: Solid
yield brush_left
brush_right = vmf.make_prism(
p1=(origin - (self.thickness / 2) * normal -
64 * fizz.up_axis - (field_length / 2) * field_axis),
p2=(origin + (self.thickness / 2) * normal +
64 * fizz.up_axis +
(side_len - field_length / 2) * field_axis),
).solid # type: Solid
yield brush_right
if center_len:
brush_center = vmf.make_prism(
p1=(origin - (self.thickness / 2) * normal -
64 * fizz.up_axis - (center_len / 2) * field_axis),
p2=(origin + (self.thickness / 2) * normal +
64 * fizz.up_axis + (center_len / 2) * field_axis),
).solid # type: Solid
yield brush_center
brushes = [
(brush_left, field_axis, 64),
(brush_center, None, center_len),
(brush_right, -field_axis, 64),
]
used_tex_func(self.textures[TexGroup.CENTER])
else:
brushes = [
(brush_left, field_axis, side_len),
(brush_right, -field_axis, side_len),
]
for brush, model_normal, brush_length in brushes:
for side in brush.sides: # type: Side
side_norm = side.normal()
if abs(side_norm) == abs(fizz.up_axis):
self._side_color(side, normal, neg, used_tex_func)
if abs(side_norm) != abs(normal):
continue
tag_enabled = (fizz.tag_on_pos if normal.dot(side_norm) > 0
else fizz.tag_on_neg)
self._texture_fit(
side,
FIZZLER_TEX_SIZE,
brush_length,
fizz,
neg,
pos,
)
if model_normal is None:
# Center textures.
side.mat = self.textures[
TexGroup.
TAG_ON_CENTER if tag_enabled else TexGroup.CENTER]
if not self.stretch_center:
side.uaxis.scale = 0.25
else:
# For left and right, we need to figure out what
# direction the texture should be in. The uaxis is
# in the direction of the surface.
if side.uaxis.vec() == model_normal:
side.mat = self.textures[TexGroup.TAG_ON_RIGHT if
tag_enabled else TexGroup.
RIGHT]
else:
side.mat = self.textures[
TexGroup.
TAG_ON_LEFT if tag_enabled else TexGroup.LEFT]
used_tex_func(side.mat)
def make_straight(
vmf: VMF,
origin: Vec,
normal: Vec,
dist: int,
config: Config,
is_start=False,
) -> None:
"""Make a straight line of instances from one point to another."""
# 32 added to the other directions, plus extended dist in the direction
# of the normal - 1
p1 = origin + (normal * ((dist // 128 * 128) - 96))
# The starting brush needs to
# stick out a bit further, to cover the
# point_push entity.
p2 = origin - (normal * (96 if is_start else 32))
# bbox before +- 32 to ensure the above doesn't wipe it out
p1, p2 = Vec.bbox(p1, p2)
solid = vmf.make_prism(
# Expand to 64x64 in the other two directions
p1 - 32,
p2 + 32,
mat='tools/toolstrigger',
).solid
motion_trigger(vmf, solid.copy())
push_trigger(vmf, origin, normal, [solid])
angles = normal.to_angle()
orient = Matrix.from_angle(angles)
for off in range(0, int(dist), 128):
position = origin + off * normal
vmf.create_ent(
classname='func_instance',
origin=position,
angles=orient.to_angle(),
file=config.inst_straight,
)
for supp_dir in [
orient.up(),
orient.left(), -orient.left(), -orient.up()
]:
try:
tile = tiling.TILES[(position - 128 * supp_dir).as_tuple(),
supp_dir.norm().as_tuple()]
except KeyError:
continue
# Check all 4 center tiles are present.
if all(tile[u, v].is_tile for u in (1, 2) for v in (1, 2)):
vmf.create_ent(
classname='func_instance',
origin=position,
angles=Matrix.from_basis(x=normal, z=supp_dir).to_angle(),
file=config.inst_support,
)
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_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_io_type,
inst_frame_double,
inst_frame_single,
blue_sign_on,
blue_sign_off,
oran_sign_on,
oran_sign_off,
) = res.value # type: int, ItemType, str, str, str, str, str, str
import vbsp
if vbsp_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 = 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.
fizzler_item.item_type = fizz_io_type
fizzler_item.enable_cmd = fizz_io_type.enable_cmd
fizzler_item.disable_cmd = fizz_io_type.disable_cmd
fizzler_item.sec_enable_cmd = fizz_io_type.sec_enable_cmd
fizzler_item.sec_disable_cmd = fizz_io_type.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'])
)
# 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.
# Grab the data saved earlier in res_find_potential_tag_fizzlers()
axis, side_min, side_max, normal = calc_fizzler_orient(fizzler)
# The Z-axis fizzler (horizontal) must be treated differently.
if axis == 'z':
# For z-axis, just compare to the center point.
# The values are really x, y, z, not what they're named.
sign_dir = sign_floor_loc - (side_min, side_max, normal)
else:
# For the other two, we compare to the line,
# or compare to the closest side (in line with the fizz)
other_axis = 'x' if axis == 'y' else 'y'
if abs(sign_floor_loc[other_axis] - normal) < 32:
# Compare to the closest side. Use ** to swap x/y arguments
# appropriately. The closest side is the one with the
# smallest magnitude.
sign_dir = min(
sign_floor_loc - Vec.with_axes(
axis,side_min,
other_axis, normal,
),
sign_floor_loc - Vec.with_axes(
axis, side_max,
other_axis, normal,
),
key=Vec.mag,
)
else:
# Align just based on whether we're in front or behind.
sign_dir = Vec()
sign_dir[other_axis] = sign_floor_loc[other_axis] - normal
sign_angle = 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_angle = (sign_angle + 45) // 90 * 90
# Rotate to fit the instances - south is down
sign_angle = int(sign_angle + 90) % 360
if inst_normal.z > 0:
sign_angle = '0 {} 0'.format(sign_angle)
elif inst_normal.z < 0:
# Flip upside-down for ceilings
sign_angle = '0 {} 180'.format(sign_angle)
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]
fizz_norm_axis = fizzler.normal().axis()
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 make_bottomless_pit(vmf: VMF, max_height):
"""Generate bottomless pits."""
tele_ref = SETTINGS['tele_ref']
tele_dest = SETTINGS['tele_dest']
use_skybox = bool(SETTINGS['skybox'])
if use_skybox:
tele_off = Vec(
x=SETTINGS['off_x'],
y=SETTINGS['off_y'],
)
else:
tele_off = Vec(0, 0, 0)
# Controlled by the style, not skybox!
blend_light = vbsp_options.get(str, 'pit_blend_light')
if use_skybox:
# Add in the actual skybox edges and triggers.
vmf.create_ent(
classname='func_instance',
file=SETTINGS['skybox'],
targetname='skybox',
angles='0 0 0',
origin=tele_off,
)
fog_opt = vbsp.settings['fog']
# Now generate the sky_camera, with appropriate values.
sky_camera = vmf.create_ent(
classname='sky_camera',
scale='1.0',
origin=tele_off,
angles=fog_opt['direction'],
fogdir=fog_opt['direction'],
fogcolor=fog_opt['primary'],
fogstart=fog_opt['start'],
fogend=fog_opt['end'],
fogenable='1',
heightFogStart=fog_opt['height_start'],
heightFogDensity=fog_opt['height_density'],
heightFogMaxDensity=fog_opt['height_max_density'],
)
if fog_opt['secondary']:
# Only enable fog blending if a secondary color is enabled
sky_camera['fogblend'] = '1'
sky_camera['fogcolor2'] = fog_opt['secondary']
sky_camera['use_angles'] = '1'
else:
sky_camera['fogblend'] = '0'
sky_camera['use_angles'] = '0'
if SETTINGS['skybox_ceil'] != '':
# We dynamically add the ceiling so it resizes to match the map,
# and lighting won't be too far away.
vmf.create_ent(
classname='func_instance',
file=SETTINGS['skybox_ceil'],
targetname='skybox',
angles='0 0 0',
origin=tele_off + (0, 0, max_height),
)
if SETTINGS['targ'] != '':
# Add in the teleport reference target.
vmf.create_ent(
classname='func_instance',
file=SETTINGS['targ'],
targetname='skybox',
angles='0 0 0',
origin='0 0 0',
)
# First, remove all of Valve's triggers inside pits.
for trig in vmf.by_class['trigger_multiple'] | vmf.by_class['trigger_hurt']:
if brushLoc.POS['world': Vec.from_str(trig['origin'])].is_pit:
trig.remove()
# Potential locations of bordering brushes..
wall_pos = set()
side_dirs = [
(0, -128, 0), # N
(0, +128, 0), # S
(-128, 0, 0), # E
(+128, 0, 0) # W
]
# Only use 1 entity for the teleport triggers. If multiple are used,
# cubes can contact two at once and get teleported odd places.
tele_trig = None
hurt_trig = None
for grid_pos, block_type in brushLoc.POS.items(): # type: Vec, brushLoc.Block
pos = brushLoc.grid_to_world(grid_pos)
if not block_type.is_pit:
continue
# Physics objects teleport when they hit the bottom of a pit.
if block_type.is_bottom and use_skybox:
if tele_trig is None:
tele_trig = vmf.create_ent(
classname='trigger_teleport',
spawnflags='4106', # Physics and npcs
landmark=tele_ref,
target=tele_dest,
origin=pos,
)
tele_trig.solids.append(
vmf.make_prism(
pos + (-64, -64, -64),
pos + (64, 64, -8),
mat='tools/toolstrigger',
).solid,
)
# Players, however get hurt as soon as they enter - that way it's
# harder to see that they don't teleport.
if block_type.is_top:
if hurt_trig is None:
hurt_trig = vmf.create_ent(
classname='trigger_hurt',
damagetype=32, # FALL
spawnflags=1, # CLients
damage=100000,
nodmgforce=1, # No physics force when hurt..
damagemodel=0, # Always apply full damage.
origin=pos, # We know this is not in the void..
)
hurt_trig.solids.append(
vmf.make_prism(
Vec(pos.x - 64, pos.y - 64, -128),
pos + (64, 64, 48 if use_skybox else 16),
mat='tools/toolstrigger',
).solid,
)
if not block_type.is_bottom:
continue
# Everything else is only added to the bottom-most position.
if use_skybox and blend_light:
# Generate dim lights at the skybox location,
# to blend the lighting together.
light_pos = pos + (0, 0, -60)
vmf.create_ent(
classname='light',
origin=light_pos,
_light=blend_light,
_fifty_percent_distance='256',
_zero_percent_distance='512',
)
vmf.create_ent(
classname='light',
origin=light_pos + tele_off,
_light=blend_light,
_fifty_percent_distance='256',
_zero_percent_distance='512',
)
wall_pos.update([
(pos + off).as_tuple()
for off in
side_dirs
])
if tele_trig is not None:
vbsp.IGNORED_BRUSH_ENTS.add(tele_trig)
if hurt_trig is not None:
vbsp.IGNORED_BRUSH_ENTS.add(hurt_trig)
hurt_trig.outputs.append(
Output(
'OnHurtPlayer',
'@goo_fade',
'Fade',
),
)
if not use_skybox:
make_pit_shell(vmf)
return
# Now determine the position of side instances.
# We use the utils.CONN_TYPES dict to determine instance positions
# based on where nearby walls are.
side_types = {
utils.CONN_TYPES.side: PIT_INST['side'], # o|
utils.CONN_TYPES.corner: PIT_INST['corner'], # _|
utils.CONN_TYPES.straight: PIT_INST['side'], # Add this twice for |o|
utils.CONN_TYPES.triple: PIT_INST['triple'], # U-shape
utils.CONN_TYPES.all: PIT_INST['pillar'], # [o]
}
LOGGER.info('Pit instances: {}', side_types)
for pos in wall_pos:
pos = Vec(pos)
if not brushLoc.POS['world': pos].is_solid:
# Not actually a wall here!
continue
# CONN_TYPES has n,s,e,w as keys - whether there's something in that direction.
nsew = tuple(
brushLoc.POS['world': pos + off].is_pit
for off in
side_dirs
)
LOGGER.info('Pos: {}, NSEW: {}, lookup: {}', pos, nsew, utils.CONN_LOOKUP[nsew])
inst_type, angle = utils.CONN_LOOKUP[nsew]
if inst_type is utils.CONN_TYPES.none:
# Middle of the pit...
continue
random.seed('pit_' + str(pos.x) + str(pos.y) + 'sides')
file = random.choice(side_types[inst_type])
if file != '':
vmf.create_ent(
classname='func_instance',
file=file,
targetname='goo_side',
origin=tele_off + pos,
angles=angle,
).make_unique()
# Straight uses two side-instances in parallel - "|o|"
if inst_type is utils.CONN_TYPES.straight:
file = random.choice(side_types[inst_type])
if file != '':
vmf.create_ent(
classname='func_instance',
file=file,
targetname='goo_side',
origin=tele_off + pos,
# Reverse direction
angles=Vec.from_str(angle) + (0, 180, 0),
).make_unique()
def generate(
self,
vmf: VMF,
fizz: Fizzler,
neg: Vec,
pos: Vec,
used_tex_func: Callable[[str], None],
) -> List[Solid]:
"""Generate the actual brush.
used_tex will be filled with the textures used.
"""
diff = neg - pos
# Size of fizzler
field_length = diff.mag()
# Direction it extends across.
field_axis = diff.norm()
# Out of the fizzler.
normal = fizz.normal()
origin = (pos + neg)/2
# If either of these, we only need 1 brush.
trigger_tex = self.textures[TexGroup.TRIGGER]
fitted_tex = self.textures[TexGroup.FITTED]
# If we don't have this, we can't be a single brush.
short_tex = self.textures[TexGroup.SHORT]
if trigger_tex or fitted_tex:
tex_size = LASER_TEX_SIZE
else:
# Fizzlers are larger resolution..
tex_size = FIZZLER_TEX_SIZE
if (field_length == 128 and not short_tex) or trigger_tex or fitted_tex:
# We need only one brush.
brush = vmf.make_prism(
p1=(origin
+ (self.thickness/2) * normal
+ 64 * fizz.up_axis
+ (field_length/2) * field_axis
),
p2=(origin
- (self.thickness / 2) * normal
- 64 * fizz.up_axis
- (field_length / 2) * field_axis
),
).solid # type: Solid
yield brush
if trigger_tex:
for side in brush.sides:
side.mat = trigger_tex
used_tex_func(trigger_tex)
else:
for side in brush.sides:
side_norm = side.normal()
if abs(side_norm) == abs(fizz.up_axis):
self._side_color(side, normal, neg, used_tex_func)
if abs(side_norm) != normal:
continue
side.mat = fitted_tex or self.textures[
TexGroup.TAG_ON_SHORT if (
fizz.tag_on_pos
if normal.dot(side_norm) > 0 else
fizz.tag_on_neg
) else TexGroup.SHORT
]
used_tex_func(side.mat)
self._texture_fit(
side,
tex_size,
field_length,
fizz,
neg,
pos,
bool(fitted_tex),
)
if not self.stretch_center:
side.uaxis.scale = 0.25
else:
# Generate the three brushes for fizzlers.
if field_length <= 128:
side_len = field_length / 2
center_len = 0
else:
# Bugfix - the boundary texture wrapping causes
# artifacts to appear at the join, we need to avoid a small
# amount of that texture.
side_len = 63
center_len = field_length - 126
brush_left = vmf.make_prism(
p1=(origin
- (self.thickness / 2) * normal
- 64 * fizz.up_axis
- (side_len - field_length/2) * field_axis
),
p2=(origin
+ (self.thickness / 2) * normal
+ 64 * fizz.up_axis
+ (field_length / 2) * field_axis
),
).solid # type: Solid
yield brush_left
brush_right = vmf.make_prism(
p1=(origin
- (self.thickness / 2) * normal
- 64 * fizz.up_axis
- (field_length / 2) * field_axis
),
p2=(origin
+ (self.thickness / 2) * normal
+ 64 * fizz.up_axis
+ (side_len - field_length/2) * field_axis
),
).solid # type: Solid
yield brush_right
if center_len:
brush_center = vmf.make_prism(
p1=(origin
- (self.thickness / 2) * normal
- 64 * fizz.up_axis
- (center_len / 2) * field_axis
),
p2=(origin
+ (self.thickness / 2) * normal
+ 64 * fizz.up_axis
+ (center_len/2) * field_axis
),
).solid # type: Solid
yield brush_center
brushes = [
(brush_left, field_axis, 64),
(brush_center, None, center_len),
(brush_right, -field_axis, 64),
]
used_tex_func(self.textures[TexGroup.CENTER])
else:
brushes = [
(brush_left, field_axis, side_len),
(brush_right, -field_axis, side_len),
]
for brush, model_normal, brush_length in brushes:
for side in brush.sides: # type: Side
side_norm = side.normal()
if abs(side_norm) == abs(fizz.up_axis):
self._side_color(side, normal, neg, used_tex_func)
if abs(side_norm) != abs(normal):
continue
tag_enabled = (
fizz.tag_on_pos
if normal.dot(side_norm) > 0 else
fizz.tag_on_neg
)
self._texture_fit(
side,
FIZZLER_TEX_SIZE,
brush_length,
fizz,
neg,
pos,
)
if model_normal is None:
# Center textures.
side.mat = self.textures[
TexGroup.TAG_ON_CENTER
if tag_enabled else
TexGroup.CENTER
]
if not self.stretch_center:
side.uaxis.scale = 0.25
else:
# For left and right, we need to figure out what
# direction the texture should be in. The uaxis is
# in the direction of the surface.
if side.uaxis.vec() == model_normal:
side.mat = self.textures[
TexGroup.TAG_ON_RIGHT
if tag_enabled else
TexGroup.RIGHT
]
else:
side.mat = self.textures[
TexGroup.TAG_ON_LEFT
if tag_enabled else
TexGroup.LEFT
]
used_tex_func(side.mat)
def gen_squarebeams(vmf: VMF, p1: Vec, p2: Vec, skin, gen_collision=True):
"""Generate squarebeams props to fill the space given.
The space should be in multiples of 64. The squarebeams brush will
be aligned to the lowest point in the space.
"""
z = min(p1.z, p2.z) + 8
min_x = min(p1.x, p2.x)
min_y = min(p1.y, p2.y)
max_x = max(p1.x, p2.x)
max_y = max(p1.y, p2.y)
dist_x = max_x - min_x
dist_y = max_y - min_y
# After this x or y dist, move to the next grid size.
cutoff_512_x = dist_x // 512 * 512
cutoff_256_x = dist_x // 256 * 256
cutoff_128_x = dist_x // 128 * 128
cutoff_512_y = dist_y // 512 * 512
cutoff_256_y = dist_y // 256 * 256
cutoff_128_y = dist_y // 128 * 128
for x, y in utils.iter_grid(
max_x=int(dist_x),
max_y=int(dist_y),
stride=64,
):
if x < cutoff_512_x and y < cutoff_512_y:
# Make 1 prop every 512 units, at the center
if x % 512 == 0 and y % 512 == 0:
_make_squarebeam(
vmf,
Vec(min_x + x + 256, min_y + y + 256, z),
skin, '_8x8',
)
elif x < cutoff_256_x and y < cutoff_256_y:
if x % 256 == 0 and y % 256 == 0:
_make_squarebeam(
vmf,
Vec(min_x + x + 128, min_y + y + 128, z),
skin, '_4x4',
)
elif x < cutoff_128_x and y < cutoff_128_y:
if x % 128 == 0 and y % 128 == 0:
_make_squarebeam(
vmf,
Vec(min_x + x + 64, min_y + y + 64, z),
skin, '_2x2',
)
else:
# Make squarebeams for every point!
_make_squarebeam(
vmf,
Vec(min_x + x + 32, min_y + y + 32, z),
skin,
)
if gen_collision:
collision = vmf.create_ent(
classname='func_brush',
disableshadows='1',
disableflashlight='1',
disablereceiveshadows='1',
shadowdepthnocache='1',
solidity='2', # Always Solid
solidbsp='1',
)
for x in range(int(min_x)+64, int(max_x), 64):
collision.solids.append(
vmf.make_prism(
p1=Vec(x-2, min_y+2, z-2),
p2=Vec(x+2, max_y-2, z-8),
mat='tools/toolsnodraw',
).solid
)
for y in range(int(min_y)+64, int(max_y), 64):
collision.solids.append(
vmf.make_prism(
p1=Vec(min_x+2, y-2, z-2),
p2=Vec(max_x-2, y+2, z-8),
mat='tools/toolsnodraw',
).solid
)
for x1, y1, x2, y2 in [
(min_x, min_y, max_x, min_y+2),
(min_x, max_y, max_x, max_y-2),
(min_x, min_y, min_x+2, max_y),
(max_x, min_y, max_x-2, max_y),
]:
collision.solids.append(
vmf.make_prism(
p1=Vec(x1, y1, z-2),
p2=Vec(x2, y2, z-8),
mat='tools/toolsnodraw',
).solid
)
def make_pit_shell(vmf: VMF):
"""If the pit is surrounded on all sides, we can just extend walls down.
That avoids needing to use skybox workarounds."""
LOGGER.info('Making pit shell...')
for x in range(-8, 20):
for y in range(-8, 20):
block_types = [
brushLoc.POS[x, y, z]
for z in
range(-15, 1)
]
lowest = max((
z for z in
range(-15, 1)
if block_types[z] is not brushLoc.Block.VOID
), default=None)
if lowest is None:
continue
# TODO: For opened areas (wheatley), generate a floor...
real_pos = brushLoc.grid_to_world(Vec(x, y, 0))
prism = vmf.make_prism(
real_pos + (64, 64, BOTTOMLESS_PIT_MIN + 8),
real_pos + (-64, -64, BOTTOMLESS_PIT_MIN),
mat='tools/toolsnodraw',
)
prism.bottom.mat = consts.Special.BACKPANELS_CHEAP
vmf.add_brush(prism.solid)
continue
if block_types[lowest].is_solid:
real_pos = brushLoc.grid_to_world(Vec(x, y, lowest))
for z in range(0, 10):
br_pos = real_pos - (0, 0, 512 * z)
vmf.add_brush(
vmf.make_prism(br_pos + 64, br_pos - (64, 64, 512-64), vbsp.BLACK_PAN[1]).solid
)
prism = vmf.make_prism(
Vec(-8 * 128, -8 * 128, -4864),
Vec(20 * 128, 20 * 128, -4896),
)
prism.top.mat = 'tools/toolsblack'
vmf.add_brush(prism.solid)
diss_trig = vmf.create_ent(
classname='trigger_multiple',
spawnflags=4104,
wait=0.1,
origin=vbsp_options.get(Vec, 'global_pti_ents_loc'),
)
diss_trig.solids = [vmf.make_prism(
Vec(-8 * 128, -8 * 128, -4182),
Vec(20 * 128, 20 * 128, -4864),
mat='tools/toolstrigger',
).solid]
diss_trig.add_out(
Output('OnStartTouch', '!activator', 'SilentDissolve'),
Output('OnStartTouch', '!activator', 'Break', delay=0.1),
Output('OnStartTouch', '!activator', 'Kill', delay=0.5),
)
# Since we can chuck gel down the pit, cover it in a noportal_volume
# to stop players from portalling past the hurt trigger.
diss_trig = vmf.create_ent(
classname='func_noportal_volume',
origin=vbsp_options.get(Vec, 'global_pti_ents_loc'),
)
diss_trig.solids = [vmf.make_prism(
Vec(-8 * 128, -8 * 128, -64),
Vec(20 * 128, 20 * 128, -4864),
mat='tools/toolstrigger',
).solid]
def make_bottomless_pit(vmf: VMF, max_height):
"""Generate bottomless pits."""
tele_ref = SETTINGS['tele_ref']
tele_dest = SETTINGS['tele_dest']
use_skybox = bool(SETTINGS['skybox'])
if use_skybox:
tele_off = Vec(
x=SETTINGS['off_x'],
y=SETTINGS['off_y'],
)
else:
tele_off = Vec(0, 0, 0)
# Controlled by the style, not skybox!
blend_light = vbsp_options.get(str, 'pit_blend_light')
if use_skybox:
# Add in the actual skybox edges and triggers.
vmf.create_ent(
classname='func_instance',
file=SETTINGS['skybox'],
targetname='skybox',
angles='0 0 0',
origin=tele_off,
)
fog_opt = vbsp.settings['fog']
# Now generate the sky_camera, with appropriate values.
sky_camera = vmf.create_ent(
classname='sky_camera',
scale='1.0',
origin=tele_off,
angles=fog_opt['direction'],
fogdir=fog_opt['direction'],
fogcolor=fog_opt['primary'],
fogstart=fog_opt['start'],
fogend=fog_opt['end'],
fogenable='1',
heightFogStart=fog_opt['height_start'],
heightFogDensity=fog_opt['height_density'],
heightFogMaxDensity=fog_opt['height_max_density'],
)
if fog_opt['secondary']:
# Only enable fog blending if a secondary color is enabled
sky_camera['fogblend'] = '1'
sky_camera['fogcolor2'] = fog_opt['secondary']
sky_camera['use_angles'] = '1'
else:
sky_camera['fogblend'] = '0'
sky_camera['use_angles'] = '0'
if SETTINGS['skybox_ceil'] != '':
# We dynamically add the ceiling so it resizes to match the map,
# and lighting won't be too far away.
vmf.create_ent(
classname='func_instance',
file=SETTINGS['skybox_ceil'],
targetname='skybox',
angles='0 0 0',
origin=tele_off + (0, 0, max_height),
)
if SETTINGS['targ'] != '':
# Add in the teleport reference target.
vmf.create_ent(
classname='func_instance',
file=SETTINGS['targ'],
targetname='skybox',
angles='0 0 0',
origin='0 0 0',
)
# First, remove all of Valve's triggers inside pits.
for trig in vmf.by_class['trigger_multiple'] | vmf.by_class['trigger_hurt']:
if brushLoc.POS['world': Vec.from_str(trig['origin'])].is_pit:
trig.remove()
# Potential locations of bordering brushes..
wall_pos = set()
side_dirs = [
(0, -128, 0), # N
(0, +128, 0), # S
(-128, 0, 0), # E
(+128, 0, 0) # W
]
# Only use 1 entity for the teleport triggers. If multiple are used,
# cubes can contact two at once and get teleported odd places.
tele_trig = None
hurt_trig = None
for grid_pos, block_type in brushLoc.POS.items(): # type: Vec, brushLoc.Block
pos = brushLoc.grid_to_world(grid_pos)
if not block_type.is_pit:
continue
# Physics objects teleport when they hit the bottom of a pit.
if block_type.is_bottom and use_skybox:
if tele_trig is None:
tele_trig = vmf.create_ent(
classname='trigger_teleport',
spawnflags='4106', # Physics and npcs
landmark=tele_ref,
target=tele_dest,
origin=pos,
)
tele_trig.solids.append(
vmf.make_prism(
pos + (-64, -64, -64),
pos + (64, 64, -8),
mat='tools/toolstrigger',
).solid,
)
# Players, however get hurt as soon as they enter - that way it's
# harder to see that they don't teleport.
if block_type.is_top:
if hurt_trig is None:
hurt_trig = vmf.create_ent(
classname='trigger_hurt',
damagetype=32, # FALL
spawnflags=1, # CLients
damage=100000,
nodmgforce=1, # No physics force when hurt..
damagemodel=0, # Always apply full damage.
origin=pos, # We know this is not in the void..
)
hurt_trig.solids.append(
vmf.make_prism(
Vec(pos.x - 64, pos.y - 64, -128),
pos + (64, 64, 48 if use_skybox else 16),
mat='tools/toolstrigger',
).solid,
)
if not block_type.is_bottom:
continue
# Everything else is only added to the bottom-most position.
if use_skybox and blend_light:
# Generate dim lights at the skybox location,
# to blend the lighting together.
light_pos = pos + (0, 0, -60)
vmf.create_ent(
classname='light',
origin=light_pos,
_light=blend_light,
_fifty_percent_distance='256',
_zero_percent_distance='512',
)
vmf.create_ent(
classname='light',
origin=light_pos + tele_off,
_light=blend_light,
_fifty_percent_distance='256',
_zero_percent_distance='512',
)
wall_pos.update([
(pos + off).as_tuple()
for off in
side_dirs
])
if tele_trig is not None:
vbsp.IGNORED_BRUSH_ENTS.add(tele_trig)
if hurt_trig is not None:
vbsp.IGNORED_BRUSH_ENTS.add(hurt_trig)
hurt_trig.outputs.append(
Output(
'OnHurtPlayer',
'@goo_fade',
'Fade',
),
)
if not use_skybox:
make_pit_shell(vmf)
return
# Now determine the position of side instances.
# We use the utils.CONN_TYPES dict to determine instance positions
# based on where nearby walls are.
side_types = {
utils.CONN_TYPES.side: PIT_INST['side'], # o|
utils.CONN_TYPES.corner: PIT_INST['corner'], # _|
utils.CONN_TYPES.straight: PIT_INST['side'], # Add this twice for |o|
utils.CONN_TYPES.triple: PIT_INST['triple'], # U-shape
utils.CONN_TYPES.all: PIT_INST['pillar'], # [o]
}
LOGGER.info('Pit instances: {}', side_types)
for pos in wall_pos:
pos = Vec(pos)
if not brushLoc.POS['world': pos].is_solid:
# Not actually a wall here!
continue
# CONN_TYPES has n,s,e,w as keys - whether there's something in that direction.
nsew = tuple(
brushLoc.POS['world': pos + off].is_pit
for off in
side_dirs
)
LOGGER.info('Pos: {}, NSEW: {}, lookup: {}', pos, nsew, utils.CONN_LOOKUP[nsew])
inst_type, angle = utils.CONN_LOOKUP[nsew]
if inst_type is utils.CONN_TYPES.none:
# Middle of the pit...
continue
random.seed('pit_' + str(pos.x) + str(pos.y) + 'sides')
file = random.choice(side_types[inst_type])
if file != '':
vmf.create_ent(
classname='func_instance',
file=file,
targetname='goo_side',
origin=tele_off + pos,
angles=angle,
).make_unique()
# Straight uses two side-instances in parallel - "|o|"
if inst_type is utils.CONN_TYPES.straight:
file = random.choice(side_types[inst_type])
if file != '':
vmf.create_ent(
classname='func_instance',
file=file,
targetname='goo_side',
origin=tele_off + pos,
# Reverse direction
angles=Vec.from_str(angle) + (0, 180, 0),
).make_unique()
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.
MUST be priority -100 so it runs before fizzlers!
"""
import vbsp
if vbsp_options.get(str, 'game_id') != utils.STEAM_IDS['TAG']:
# Abort - TAG fizzlers shouldn't appear in any other game!
inst.remove()
return
fizz_base = fizz_name = None
# Look for the fizzler instance we want to replace
for targetname in inst.output_targets():
if targetname in tag_fizzlers:
fizz_name = targetname
fizz_base = tag_fizzlers[targetname]
del tag_fizzlers[targetname] # Don't let other signs mod this one!
continue
else:
# It's an indicator toggle, remove it and the antline to clean up.
LOGGER.warning('Toggle: {}', targetname)
for ent in vmf.by_target[targetname]:
remove_ant_toggle(ent)
inst.outputs.clear() # Remove the outptuts now, they're not valid anyway.
if fizz_base is None:
# No fizzler - remove this sign
inst.remove()
return
# The distance from origin the double signs are seperated by.
sign_offset = res.int('signoffset', 16)
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']))
# 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'] = res['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'] = res['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.
# Grab the data saved earlier in res_find_potential_tag_fizzlers()
axis, side_min, side_max, normal = tag_fizzler_locs[fizz_name]
# The Z-axis fizzler (horizontal) must be treated differently.
if axis == 'z':
# For z-axis, just compare to the center point.
# The values are really x, y, z, not what they're named.
sign_dir = sign_floor_loc - (side_min, side_max, normal)
else:
# For the other two, we compare to the line,
# or compare to the closest side (in line with the fizz)
other_axis = 'x' if axis == 'y' else 'y'
if abs(sign_floor_loc[other_axis] - normal) < 32:
# Compare to the closest side. Use ** to swap x/y arguments
# appropriately. The closest side is the one with the
# smallest magnitude.
vmf.create_ent(
classname='info_null',
targetname=inst['targetname'] + '_min',
origin=sign_floor_loc - Vec(**{
axis: side_min,
other_axis: normal,
}),
)
vmf.create_ent(
classname='info_null',
targetname=inst['targetname'] + '_max',
origin=sign_floor_loc - Vec(**{
axis: side_max,
other_axis: normal,
}),
)
sign_dir = min(
sign_floor_loc - Vec(**{
axis: side_min,
other_axis: normal,
}),
sign_floor_loc - Vec(**{
axis: side_max,
other_axis: normal,
}),
key=Vec.mag,
)
else:
# Align just based on whether we're in front or behind.
sign_dir = Vec()
sign_dir[other_axis] = sign_floor_loc[other_axis] - normal
sign_angle = 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_angle = (sign_angle + 45) // 90 * 90
# Rotate to fit the instances - south is down
sign_angle = int(sign_angle + 90) % 360
if inst_normal.z > 0:
sign_angle = '0 {} 0'.format(sign_angle)
elif inst_normal.z < 0:
# Flip upside-down for ceilings
sign_angle = '0 {} 180'.format(sign_angle)
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' if blue_enabled else 'blue_off_sign' if disable_other else None
oran_sign = 'oran_sign' if oran_enabled else 'oran_off_sign' if disable_other else None
if blue_sign:
vmf.create_ent(
classname='func_instance',
file=res[blue_sign, ''],
targetname=inst['targetname'],
angles=sign_angle,
origin=blue_loc.join(' '),
)
if oran_sign:
vmf.create_ent(
classname='func_instance',
file=res[oran_sign, ''],
targetname=inst['targetname'],
angles=sign_angle,
origin=oran_loc.join(' '),
)
# Now modify the fizzler...
fizz_brushes = list(vmf.by_class['trigger_portal_cleanser']
& vmf.by_target[fizz_name + '_brush'])
if 'base_inst' in res:
fizz_base['file'] = instanceLocs.resolve_one(res['base_inst'],
error=True)
fizz_base.outputs.clear() # Remove outputs, otherwise they break
# branch_toggle entities
# Subtract the sign from the list of connections, but don't go below
# zero
fizz_base.fixup['$connectioncount'] = str(
max(0,
srctools.conv_int(fizz_base.fixup['$connectioncount', ''], 0) - 1))
if 'model_inst' in res:
model_inst = instanceLocs.resolve_one(res['model_inst'], error=True)
for mdl_inst in vmf.by_class['func_instance']:
if mdl_inst['targetname', ''].startswith(fizz_name + '_model'):
mdl_inst['file'] = model_inst
# Find the direction the fizzler front/back points - z=floor fizz
# Signs will associate with the given side!
bbox_min, bbox_max = fizz_brushes[0].get_bbox()
for axis, val in zip('xyz', bbox_max - bbox_min):
if val == 2:
fizz_axis = axis
sign_center = (bbox_min[axis] + bbox_max[axis]) / 2
break
else:
# A fizzler that's not 128*x*2?
raise Exception('Invalid fizzler brush ({})!'.format(fizz_name))
# 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_axis] < sign_center:
pos_blue = blue_enabled
pos_oran = oran_enabled
else:
neg_blue = blue_enabled
neg_oran = oran_enabled
fizz_off_tex = {
'left': res['off_left'],
'center': res['off_center'],
'right': res['off_right'],
'short': res['off_short'],
}
fizz_on_tex = {
'left': res['on_left'],
'center': res['on_center'],
'right': res['on_right'],
'short': res['on_short'],
}
# If it activates the paint gun, use different textures
if pos_blue or pos_oran:
pos_tex = fizz_on_tex
else:
pos_tex = fizz_off_tex
if neg_blue or neg_oran:
neg_tex = fizz_on_tex
else:
neg_tex = fizz_off_tex
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'] = fizz_base['origin']
pos_trig['spawnflags'] = neg_trig['spawnflags'] = '1' # Clients Only
pos_trig['targetname'] = fizz_name + '-trig_pos'
neg_trig['targetname'] = fizz_name + '-trig_neg'
pos_trig.outputs = [
Output(
output,
fizz_name + '-trig_neg',
'Enable',
),
Output(
output,
fizz_name + '-trig_pos',
'Disable',
),
]
neg_trig.outputs = [
Output(
output,
fizz_name + '-trig_pos',
'Enable',
),
Output(
output,
fizz_name + '-trig_neg',
'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'] = fizz_name + '-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'))
for fizz_brush in fizz_brushes: # portal_cleanser ent, not solid!
# Modify fizzler textures
bbox_min, bbox_max = fizz_brush.get_bbox()
for side in fizz_brush.sides():
norm = side.normal()
if norm[fizz_axis] == 0:
# Not the front/back: force nodraw
# Otherwise the top/bottom will have the odd stripes
# which won't match the sides
side.mat = 'tools/toolsnodraw'
continue
if norm[fizz_axis] == 1:
side.mat = pos_tex[vbsp.TEX_FIZZLER[side.mat.casefold()]]
else:
side.mat = neg_tex[vbsp.TEX_FIZZLER[side.mat.casefold()]]
# The fizzler shouldn't kill cubes
fizz_brush['spawnflags'] = '1'
fizz_brush.outputs.append(
Output(
'OnStartTouch',
'@shake_global',
'StartShake',
))
fizz_brush.outputs.append(
Output(
'OnStartTouch',
'@shake_global_sound',
'PlaySound',
))
# The triggers are 8 units thick, 24 from the center
# (-1 because fizzlers are 2 thick on each side).
neg_min, neg_max = Vec(bbox_min), Vec(bbox_max)
neg_min[fizz_axis] -= 23
neg_max[fizz_axis] -= 17
pos_min, pos_max = Vec(bbox_min), Vec(bbox_max)
pos_min[fizz_axis] += 17
pos_max[fizz_axis] += 23
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_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.
MUST be priority -100 so it runs before fizzlers!
"""
import vbsp
if vbsp_options.get(str, 'game_id') != utils.STEAM_IDS['TAG']:
# Abort - TAG fizzlers shouldn't appear in any other game!
inst.remove()
return
fizzler = None
# Look for the fizzler instance we want to replace
for targetname in inst.output_targets():
try:
fizzler = FIZZLERS[targetname]
except KeyError:
# Not a fizzler.
# It's an indicator toggle, remove it and the antline to clean up.
for ent in vmf.by_target[targetname]:
remove_ant_toggle(ent)
inst.outputs.clear() # Remove the outputs now, they're not valid anyway.
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]
# The distance from origin the double signs are seperated by.
sign_offset = res.int('signoffset', 16)
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'])
)
# 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'] = res['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'] = res['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.
# Grab the data saved earlier in res_find_potential_tag_fizzlers()
axis, side_min, side_max, normal = calc_fizzler_orient(fizzler)
# The Z-axis fizzler (horizontal) must be treated differently.
if axis == 'z':
# For z-axis, just compare to the center point.
# The values are really x, y, z, not what they're named.
sign_dir = sign_floor_loc - (side_min, side_max, normal)
else:
# For the other two, we compare to the line,
# or compare to the closest side (in line with the fizz)
other_axis = 'x' if axis == 'y' else 'y'
if abs(sign_floor_loc[other_axis] - normal) < 32:
# Compare to the closest side. Use ** to swap x/y arguments
# appropriately. The closest side is the one with the
# smallest magnitude.
sign_dir = min(
sign_floor_loc - Vec.with_axes(
axis,side_min,
other_axis, normal,
),
sign_floor_loc - Vec.with_axes(
axis, side_max,
other_axis, normal,
),
key=Vec.mag,
)
else:
# Align just based on whether we're in front or behind.
sign_dir = Vec()
sign_dir[other_axis] = sign_floor_loc[other_axis] - normal
sign_angle = 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_angle = (sign_angle + 45) // 90 * 90
# Rotate to fit the instances - south is down
sign_angle = int(sign_angle + 90) % 360
if inst_normal.z > 0:
sign_angle = '0 {} 0'.format(sign_angle)
elif inst_normal.z < 0:
# Flip upside-down for ceilings
sign_angle = '0 {} 180'.format(sign_angle)
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' if blue_enabled else 'blue_off_sign' if disable_other else None
oran_sign = 'oran_sign' if oran_enabled else 'oran_off_sign' if disable_other else None
if blue_sign:
vmf.create_ent(
classname='func_instance',
file=res[blue_sign, ''],
targetname=inst['targetname'],
angles=sign_angle,
origin=blue_loc.join(' '),
)
if oran_sign:
vmf.create_ent(
classname='func_instance',
file=res[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', ''], 0) - 1
))
# Find the direction the fizzler normal is.
# Signs will associate with the given side!
bbox_min, bbox_max = fizzler.emitters[0]
fizz_field_axis = (bbox_max-bbox_min).norm()
fizz_norm_axis = fizzler.normal().axis()
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.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_add_brush(vmf: VMF, inst: Entity, res: Property) -> None:
"""Spawn in a brush at the indicated points.
- `point1` and `point2` are locations local to the instance, with `0 0 0`
as the floor-position.
- `type` is either `black` or `white`.
- detail should be set to `1/0`. If true the brush will be a
func_detail instead of a world brush.
The sides will be textured with 1x1, 2x2 or 4x4 wall, ceiling and floor
textures as needed.
"""
origin = Vec.from_str(inst['origin'])
angles = Angle.from_str(inst['angles'])
point1 = Vec.from_str(res['point1'])
point2 = Vec.from_str(res['point2'])
point1.z -= 64 # Offset to the location of the floor
point2.z -= 64
# Rotate to match the instance
point1 = point1 @ angles + origin
point2 = point2 @ angles + origin
try:
tex_type = texturing.Portalable(res['type', 'black'])
except ValueError:
LOGGER.warning(
'AddBrush: "{}" is not a valid brush '
'color! (white or black)',
res['type'],
)
tex_type = texturing.Portalable.BLACK
dim = round(point2 - point1, 6)
dim.max(-dim)
# Figure out what grid size and scale is needed
# Check the dimensions in two axes to figure out the largest
# tile size that can fit in it.
tile_grids = {
'x': tiling.TileSize.TILE_4x4,
'y': tiling.TileSize.TILE_4x4,
'z': tiling.TileSize.TILE_4x4,
}
for axis in 'xyz':
u, v = Vec.INV_AXIS[axis]
max_size = min(dim[u], dim[v])
if max_size % 128 == 0:
tile_grids[axis] = tiling.TileSize.TILE_1x1
elif dim[u] % 64 == 0 and dim[v] % 128 == 0:
tile_grids[axis] = tiling.TileSize.TILE_2x1
elif max_size % 64 == 0:
tile_grids[axis] = tiling.TileSize.TILE_2x2
else:
tile_grids[axis] = tiling.TileSize.TILE_4x4
solids = vmf.make_prism(point1, point2)
solids.north.mat = texturing.gen(
texturing.GenCat.NORMAL,
Vec(Vec.N),
tex_type,
).get(solids.north.get_origin(), tile_grids['y'])
solids.south.mat = texturing.gen(
texturing.GenCat.NORMAL,
Vec(Vec.S),
tex_type,
).get(solids.north.get_origin(), tile_grids['y'])
solids.east.mat = texturing.gen(
texturing.GenCat.NORMAL,
Vec(Vec.E),
tex_type,
).get(solids.north.get_origin(), tile_grids['x'])
solids.west.mat = texturing.gen(
texturing.GenCat.NORMAL,
Vec(Vec.W),
tex_type,
).get(solids.north.get_origin(), tile_grids['x'])
solids.top.mat = texturing.gen(
texturing.GenCat.NORMAL,
Vec(Vec.T),
tex_type,
).get(solids.north.get_origin(), tile_grids['z'])
solids.bottom.mat = texturing.gen(
texturing.GenCat.NORMAL,
Vec(Vec.B),
tex_type,
).get(solids.north.get_origin(), tile_grids['z'])
if res.bool('detail'):
# Add the brush to a func_detail entity
vmf.create_ent(classname='func_detail').solids = [solids.solid]
else:
# Add to the world
vmf.add_brush(solids.solid)
def make_pit_shell(vmf: VMF):
"""If the pit is surrounded on all sides, we can just extend walls down.
That avoids needing to use skybox workarounds."""
LOGGER.info('Making pit shell...')
for x in range(-8, 20):
for y in range(-8, 20):
block_types = [
brushLoc.POS[x, y, z]
for z in
range(-15, 1)
]
lowest = max((
z for z in
range(-15, 1)
if block_types[z] is not brushLoc.Block.VOID
), default=None)
if lowest is None:
continue
# TODO: For opened areas (wheatley), generate a floor...
real_pos = brushLoc.grid_to_world(Vec(x, y, 0))
prism = vmf.make_prism(
real_pos + (64, 64, BOTTOMLESS_PIT_MIN + 8),
real_pos + (-64, -64, BOTTOMLESS_PIT_MIN),
mat='tools/toolsnodraw',
)
prism.bottom.mat = consts.Special.BACKPANELS_CHEAP
vmf.add_brush(prism.solid)
continue
if block_types[lowest].is_solid:
real_pos = brushLoc.grid_to_world(Vec(x, y, lowest))
for z in range(0, 10):
br_pos = real_pos - (0, 0, 512 * z)
vmf.add_brush(
vmf.make_prism(br_pos + 64, br_pos - (64, 64, 512-64), vbsp.BLACK_PAN[1]).solid
)
prism = vmf.make_prism(
Vec(-8 * 128, -8 * 128, -4864),
Vec(20 * 128, 20 * 128, -4896),
)
prism.top.mat = 'tools/toolsblack'
vmf.add_brush(prism.solid)
diss_trig = vmf.create_ent(
classname='trigger_multiple',
spawnflags=4104,
wait=0.1,
origin=vbsp_options.get(Vec, 'global_pti_ents_loc'),
)
diss_trig.solids = [vmf.make_prism(
Vec(-8 * 128, -8 * 128, -4182),
Vec(20 * 128, 20 * 128, -4864),
mat='tools/toolstrigger',
).solid]
diss_trig.add_out(
Output('OnStartTouch', '!activator', 'SilentDissolve'),
Output('OnStartTouch', '!activator', 'Break', delay=0.1),
Output('OnStartTouch', '!activator', 'Kill', delay=0.5),
)
# Since we can chuck gel down the pit, cover it in a noportal_volume
# to stop players from portalling past the hurt trigger.
diss_trig = vmf.create_ent(
classname='func_noportal_volume',
origin=vbsp_options.get(Vec, 'global_pti_ents_loc'),
)
diss_trig.solids = [vmf.make_prism(
Vec(-8 * 128, -8 * 128, -64),
Vec(20 * 128, 20 * 128, -4864),
mat='tools/toolstrigger',
).solid]
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 gen_flinch_trigs(self, vmf: VMF, name: str,
start_disabled: str) -> None:
"""For deadly fizzlers optionally make them safer.
This adds logic to force players
back instead when walking into the field.
Only applies to vertical triggers.
"""
normal = abs(self.normal()) # type: Vec
# Horizontal fizzlers would just have you fall through.
if normal.z:
return
# Disabled.
if not vbsp_options.get_itemconf(
('VALVE_FIZZLER', 'FlinchBack'), False):
return
# Make global entities if not present.
if '_fizz_flinch_hurt' not in vmf.by_target:
glob_ent_loc = vbsp_options.get(Vec, 'global_ents_loc')
vmf.create_ent(
classname='point_hurt',
targetname='_fizz_flinch_hurt',
Damage=10, # Just for visuals and sounds.
# BURN | ENERGYBEAM | PREVENT_PHYSICS_FORCE
DamageType=8 | 1024 | 2048,
DamageTarget='!activator', # Hurt the triggering player.
DamageRadius=1, # Target makes this unused.
origin=glob_ent_loc,
)
# We need two catapults - one for each side.
neg_brush = vmf.create_ent(
targetname=name,
classname='trigger_catapult',
spawnflags=1, # Players only.
origin=self.base_inst['origin'],
physicsSpeed=0,
playerSpeed=96,
launchDirection=(-normal).to_angle(),
startDisabled=start_disabled,
)
neg_brush.add_out(Output('OnCatapulted', '_fizz_flinch_hurt', 'Hurt'))
pos_brush = neg_brush.copy()
pos_brush['launchDirection'] = normal.to_angle()
vmf.add_ent(pos_brush)
for seg_min, seg_max in self.emitters:
neg_brush.solids.append(
vmf.make_prism(
p1=(seg_min - 4 * normal - 64 * self.up_axis),
p2=seg_max + 64 * self.up_axis,
mat=const.Tools.TRIGGER,
).solid)
pos_brush.solids.append(
vmf.make_prism(
p1=seg_min - 64 * self.up_axis,
p2=(seg_max + 4 * normal + 64 * self.up_axis),
mat=const.Tools.TRIGGER,
).solid)
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.
MUST be priority -100 so it runs before fizzlers!
"""
import vbsp
if vbsp_options.get(str, 'game_id') != utils.STEAM_IDS['TAG']:
# Abort - TAG fizzlers shouldn't appear in any other game!
inst.remove()
return
fizz_base = fizz_name = None
# Look for the fizzler instance we want to replace
for targetname in inst.output_targets():
if targetname in tag_fizzlers:
fizz_name = targetname
fizz_base = tag_fizzlers[targetname]
del tag_fizzlers[targetname] # Don't let other signs mod this one!
continue
else:
# It's an indicator toggle, remove it and the antline to clean up.
LOGGER.warning('Toggle: {}', targetname)
for ent in vmf.by_target[targetname]:
remove_ant_toggle(ent)
inst.outputs.clear() # Remove the outptuts now, they're not valid anyway.
if fizz_base is None:
# No fizzler - remove this sign
inst.remove()
return
# The distance from origin the double signs are seperated by.
sign_offset = res.int('signoffset', 16)
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'])
)
# 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'] = res['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'] = res['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.
# Grab the data saved earlier in res_find_potential_tag_fizzlers()
axis, side_min, side_max, normal = tag_fizzler_locs[fizz_name]
# The Z-axis fizzler (horizontal) must be treated differently.
if axis == 'z':
# For z-axis, just compare to the center point.
# The values are really x, y, z, not what they're named.
sign_dir = sign_floor_loc - (side_min, side_max, normal)
else:
# For the other two, we compare to the line,
# or compare to the closest side (in line with the fizz)
other_axis = 'x' if axis == 'y' else 'y'
if abs(sign_floor_loc[other_axis] - normal) < 32:
# Compare to the closest side. Use ** to swap x/y arguments
# appropriately. The closest side is the one with the
# smallest magnitude.
vmf.create_ent(
classname='info_null',
targetname=inst['targetname'] + '_min',
origin=sign_floor_loc - Vec(**{
axis: side_min,
other_axis: normal,
}),
)
vmf.create_ent(
classname='info_null',
targetname=inst['targetname'] + '_max',
origin=sign_floor_loc - Vec(**{
axis: side_max,
other_axis: normal,
}),
)
sign_dir = min(
sign_floor_loc - Vec(**{
axis: side_min,
other_axis: normal,
}),
sign_floor_loc - Vec(**{
axis: side_max,
other_axis: normal,
}),
key=Vec.mag,
)
else:
# Align just based on whether we're in front or behind.
sign_dir = Vec()
sign_dir[other_axis] = sign_floor_loc[other_axis] - normal
sign_angle = 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_angle = (sign_angle + 45) // 90 * 90
# Rotate to fit the instances - south is down
sign_angle = int(sign_angle + 90) % 360
if inst_normal.z > 0:
sign_angle = '0 {} 0'.format(sign_angle)
elif inst_normal.z < 0:
# Flip upside-down for ceilings
sign_angle = '0 {} 180'.format(sign_angle)
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' if blue_enabled else 'blue_off_sign' if disable_other else None
oran_sign = 'oran_sign' if oran_enabled else 'oran_off_sign' if disable_other else None
if blue_sign:
vmf.create_ent(
classname='func_instance',
file=res[blue_sign, ''],
targetname=inst['targetname'],
angles=sign_angle,
origin=blue_loc.join(' '),
)
if oran_sign:
vmf.create_ent(
classname='func_instance',
file=res[oran_sign, ''],
targetname=inst['targetname'],
angles=sign_angle,
origin=oran_loc.join(' '),
)
# Now modify the fizzler...
fizz_brushes = list(
vmf.by_class['trigger_portal_cleanser'] &
vmf.by_target[fizz_name + '_brush']
)
if 'base_inst' in res:
fizz_base['file'] = resolve_inst(res['base_inst'])[0]
fizz_base.outputs.clear() # Remove outputs, otherwise they break
# branch_toggle entities
# Subtract the sign from the list of connections, but don't go below
# zero
fizz_base.fixup['$connectioncount'] = str(max(
0,
srctools.conv_int(fizz_base.fixup['$connectioncount', ''], 0) - 1
))
if 'model_inst' in res:
model_inst = resolve_inst(res['model_inst'])[0]
for mdl_inst in vmf.by_class['func_instance']:
if mdl_inst['targetname', ''].startswith(fizz_name + '_model'):
mdl_inst['file'] = model_inst
# Find the direction the fizzler front/back points - z=floor fizz
# Signs will associate with the given side!
bbox_min, bbox_max = fizz_brushes[0].get_bbox()
for axis, val in zip('xyz', bbox_max-bbox_min):
if val == 2:
fizz_axis = axis
sign_center = (bbox_min[axis] + bbox_max[axis]) / 2
break
else:
# A fizzler that's not 128*x*2?
raise Exception('Invalid fizzler brush ({})!'.format(fizz_name))
# 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_axis] < sign_center:
pos_blue = blue_enabled
pos_oran = oran_enabled
else:
neg_blue = blue_enabled
neg_oran = oran_enabled
fizz_off_tex = {
'left': res['off_left'],
'center': res['off_center'],
'right': res['off_right'],
'short': res['off_short'],
}
fizz_on_tex = {
'left': res['on_left'],
'center': res['on_center'],
'right': res['on_right'],
'short': res['on_short'],
}
# If it activates the paint gun, use different textures
if pos_blue or pos_oran:
pos_tex = fizz_on_tex
else:
pos_tex = fizz_off_tex
if neg_blue or neg_oran:
neg_tex = fizz_on_tex
else:
neg_tex = fizz_off_tex
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'] = fizz_base['origin']
pos_trig['spawnflags'] = neg_trig['spawnflags'] = '1' # Clients Only
pos_trig['targetname'] = fizz_name + '-trig_pos'
neg_trig['targetname'] = fizz_name + '-trig_neg'
pos_trig.outputs = [
Output(
output,
fizz_name + '-trig_neg',
'Enable',
),
Output(
output,
fizz_name + '-trig_pos',
'Disable',
),
]
neg_trig.outputs = [
Output(
output,
fizz_name + '-trig_pos',
'Enable',
),
Output(
output,
fizz_name + '-trig_neg',
'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'] = fizz_name + '-trig'
neg_trig.outputs.clear()
neg_trig.add_out(Output(
output,
'@BlueIsEnabled',
'SetValue',
param='0'
))
neg_trig.add_out(Output(
output,
'@OrangeIsEnabled',
'SetValue',
param='0'
))
for fizz_brush in fizz_brushes: # portal_cleanser ent, not solid!
# Modify fizzler textures
bbox_min, bbox_max = fizz_brush.get_bbox()
for side in fizz_brush.sides():
norm = side.normal()
if norm[fizz_axis] == 0:
# Not the front/back: force nodraw
# Otherwise the top/bottom will have the odd stripes
# which won't match the sides
side.mat = 'tools/toolsnodraw'
continue
if norm[fizz_axis] == 1:
side.mat = pos_tex[
vbsp.TEX_FIZZLER[
side.mat.casefold()
]
]
else:
side.mat = neg_tex[
vbsp.TEX_FIZZLER[
side.mat.casefold()
]
]
# The fizzler shouldn't kill cubes
fizz_brush['spawnflags'] = '1'
fizz_brush.outputs.append(Output(
'OnStartTouch',
'@shake_global',
'StartShake',
))
fizz_brush.outputs.append(Output(
'OnStartTouch',
'@shake_global_sound',
'PlaySound',
))
# The triggers are 8 units thick, 24 from the center
# (-1 because fizzlers are 2 thick on each side).
neg_min, neg_max = Vec(bbox_min), Vec(bbox_max)
neg_min[fizz_axis] -= 23
neg_max[fizz_axis] -= 17
pos_min, pos_max = Vec(bbox_min), Vec(bbox_max)
pos_min[fizz_axis] += 17
pos_max[fizz_axis] += 23
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 make_barriers(vmf: VMF, coll: collisions.Collisions) -> None:
"""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"))
barr_type: BarrierType | None
# 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'))
else:
hole_combined_temp = None
hole_temp_small = template_solids_and_coll(hole_combined_temp, 'small')
hole_temp_lrg_diag = template_solids_and_coll(hole_combined_temp,
'large_diagonal')
hole_temp_lrg_cutout = template_solids_and_coll(hole_combined_temp,
'large_cutout')
hole_temp_lrg_square = template_solids_and_coll(hole_combined_temp,
'large_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) -> Plane(type)
slices: dict[tuple[tuple[float, float, float], bool],
Plane[BarrierType | None]] = defaultdict(Plane)
# We have this on the 32-grid to allow us to 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, ]
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), ] = barr_type
# Compute contiguous sections of any barrier type, then place hint brushes to ensure sorting
# is done correctly.
for (plane_pos_tup, is_pos), pos_slice in slices.items():
plane_pos = Vec(plane_pos_tup)
norm_axis = plane_pos.axis()
normal = Vec.with_axes(norm_axis, 1 if is_pos else -1)
u_axis, v_axis = Vec.INV_AXIS[norm_axis]
is_present: Plane[object] = pos_slice.copy()
for pos in is_present:
is_present[pos] = True
for min_u, min_v, max_u, max_v, _ in grid_optimise(is_present):
# 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,
)
hint = vmf.make_prism(
pos_min + normal * 64,
pos_max + normal * 60,
mat=consts.Tools.SKIP,
).solid
for side in hint:
if abs(Vec.dot(side.normal(), normal)) > 0.99:
side.mat = consts.Tools.HINT
vmf.add_brush(hint)
# 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, ]
offsets: tuple[int, ...]
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 Plane,
# 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] = None
# 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:
contents = collisions.CollideType.GLASS
front_temp = glass_temp
elif barr_type is BarrierType.GRATING:
contents = collisions.CollideType.GRATING
front_temp = grate_temp
else:
raise NotImplementedError
angles = normal.to_angle()
hole_temp: list[tuple[list[Solid], list[collisions.BBox], 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
# This bit of the glass is present, so include it in our brush, then clear.
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), ))
for _, bbox_list, matrix in hole_temp:
# Place the collisions.
for bbox in bbox_list:
bbox = bbox @ matrix + origin
coll.add(
bbox.with_attrs(name=barr_type.name, contents=contents))
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_tup, is_pos), pos_slice in slices.items():
plane_pos = Vec(plane_pos_tup)
norm_axis = plane_pos.axis()
normal = Vec.with_axes(norm_axis, 1 if is_pos else -1)
u_axis, v_axis = Vec.INV_AXIS[norm_axis]
for min_u, min_v, max_u, max_v, barr_type in grid_optimise(pos_slice):
if barr_type is None: # Hole placed here and overwrote the glass/grating.
continue
elif barr_type is BarrierType.GLASS:
contents = collisions.CollideType.GLASS
front_temp = glass_temp
elif barr_type is BarrierType.GRATING:
contents = collisions.CollideType.GRATING
front_temp = grate_temp
else:
raise NotImplementedError(barr_type)
# 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,
)
coll.add(
collisions.BBox(
pos_min + normal * 64.0,
pos_max + normal * 60.0,
name=barr_type.name,
contents=contents,
))
def solid_pane_func(off1: float, off2: float,
mat: str) -> list[Solid]:
"""Make the solid brush."""
return [
vmf.make_prism(
pos_min + normal * (64.0 - off1),
pos_max + normal * (64.0 - off2),
mat=mat,
).solid
]
make_glass_grating(
vmf,
(pos_min + pos_max) / 2 + 63 * normal,
normal,
barr_type,
front_temp,
solid_pane_func,
)
if floorbeam_temp:
LOGGER.info('Adding Glass floor beams...')
add_glass_floorbeams(vmf, floorbeam_temp)
LOGGER.info('Done!')
def gen_squarebeams(vmf: VMF, p1: Vec, p2: Vec, skin, gen_collision=True):
"""Generate squarebeams props to fill the space given.
The space should be in multiples of 64. The squarebeams brush will
be aligned to the lowest point in the space.
"""
z = min(p1.z, p2.z) + 8
min_x = min(p1.x, p2.x)
min_y = min(p1.y, p2.y)
max_x = max(p1.x, p2.x)
max_y = max(p1.y, p2.y)
dist_x = max_x - min_x
dist_y = max_y - min_y
# After this x or y dist, move to the next grid size.
cutoff_512_x = dist_x // 512 * 512
cutoff_256_x = dist_x // 256 * 256
cutoff_128_x = dist_x // 128 * 128
cutoff_512_y = dist_y // 512 * 512
cutoff_256_y = dist_y // 256 * 256
cutoff_128_y = dist_y // 128 * 128
for x, y in utils.iter_grid(
max_x=int(dist_x),
max_y=int(dist_y),
stride=64,
):
if x < cutoff_512_x and y < cutoff_512_y:
# Make 1 prop every 512 units, at the center
if x % 512 == 0 and y % 512 == 0:
_make_squarebeam(
vmf,
Vec(min_x + x + 256, min_y + y + 256, z),
skin,
'_8x8',
)
elif x < cutoff_256_x and y < cutoff_256_y:
if x % 256 == 0 and y % 256 == 0:
_make_squarebeam(
vmf,
Vec(min_x + x + 128, min_y + y + 128, z),
skin,
'_4x4',
)
elif x < cutoff_128_x and y < cutoff_128_y:
if x % 128 == 0 and y % 128 == 0:
_make_squarebeam(
vmf,
Vec(min_x + x + 64, min_y + y + 64, z),
skin,
'_2x2',
)
else:
# Make squarebeams for every point!
_make_squarebeam(
vmf,
Vec(min_x + x + 32, min_y + y + 32, z),
skin,
)
if gen_collision:
collision = vmf.create_ent(
classname='func_brush',
disableshadows='1',
disableflashlight='1',
disablereceiveshadows='1',
shadowdepthnocache='1',
solidity='2', # Always Solid
solidbsp='1',
)
for x in range(int(min_x) + 64, int(max_x), 64):
collision.solids.append(
vmf.make_prism(
p1=Vec(x - 2, min_y + 2, z - 2),
p2=Vec(x + 2, max_y - 2, z - 8),
mat='tools/toolsnodraw',
).solid)
for y in range(int(min_y) + 64, int(max_y), 64):
collision.solids.append(
vmf.make_prism(
p1=Vec(min_x + 2, y - 2, z - 2),
p2=Vec(max_x - 2, y + 2, z - 8),
mat='tools/toolsnodraw',
).solid)
for x1, y1, x2, y2 in [
(min_x, min_y, max_x, min_y + 2),
(min_x, max_y, max_x, max_y - 2),
(min_x, min_y, min_x + 2, max_y),
(max_x, min_y, max_x - 2, max_y),
]:
collision.solids.append(
vmf.make_prism(
p1=Vec(x1, y1, z - 2),
p2=Vec(x2, y2, z - 8),
mat='tools/toolsnodraw',
).solid)
def make_straight(
vmf: VMF,
origin: Vec,
normal: Vec,
dist: int,
config: Config,
is_start=False,
) -> None:
"""Make a straight line of instances from one point to another."""
angles = round(normal, 6).to_angle()
orient = Matrix.from_angle(angles)
# The starting brush needs to stick out a bit further, to cover the
# point_push entity.
start_off = -96 if is_start else -64
p1, p2 = Vec.bbox(
origin + Vec(start_off, -config.trig_radius, -config.trig_radius) @ orient,
origin + Vec(dist - 64, config.trig_radius, config.trig_radius) @ orient,
)
solid = vmf.make_prism(p1, p2, mat='tools/toolstrigger').solid
motion_trigger(vmf, solid.copy())
push_trigger(vmf, origin, normal, [solid])
off = 0
for seg_dist in utils.fit(dist, config.inst_straight_sizes):
vmf.create_ent(
classname='func_instance',
origin=origin + off * orient.forward(),
angles=angles,
file=config.inst_straight[seg_dist],
)
off += seg_dist
# Supports.
if config.inst_support:
for off in range(0, int(dist), 128):
position = origin + off * normal
placed_support = False
for supp_dir in [
orient.up(), orient.left(),
-orient.left(), -orient.up()
]:
try:
tile = tiling.TILES[
(position - 128 * supp_dir).as_tuple(),
supp_dir.norm().as_tuple()
]
except KeyError:
continue
# Check all 4 center tiles are present.
if all(tile[u, v].is_tile for u in (1, 2) for v in (1, 2)):
vmf.create_ent(
classname='func_instance',
origin=position,
angles=Matrix.from_basis(x=normal, z=supp_dir).to_angle(),
file=config.inst_support,
)
placed_support = True
if placed_support and config.inst_support_ring:
vmf.create_ent(
classname='func_instance',
origin=position,
angles=angles,
file=config.inst_support_ring,
)
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 gen_flinch_trigs(self, vmf: VMF, name: str, start_disabled: str) -> None:
"""For deadly fizzlers optionally make them safer.
This adds logic to force players
back instead when walking into the field.
Only applies to vertical triggers.
"""
normal = abs(self.normal()) # type: Vec
# Horizontal fizzlers would just have you fall through.
if normal.z:
return
# Disabled.
if not vbsp_options.get_itemconf(('VALVE_FIZZLER', 'FlinchBack'), False):
return
# Make global entities if not present.
if '_fizz_flinch_hurt' not in vmf.by_target:
glob_ent_loc = vbsp_options.get(Vec, 'global_ents_loc')
vmf.create_ent(
classname='point_hurt',
targetname='_fizz_flinch_hurt',
Damage=10, # Just for visuals and sounds.
# BURN | ENERGYBEAM | PREVENT_PHYSICS_FORCE
DamageType=8 | 1024 | 2048,
DamageTarget='!activator', # Hurt the triggering player.
DamageRadius=1, # Target makes this unused.
origin=glob_ent_loc,
)
# We need two catapults - one for each side.
neg_brush = vmf.create_ent(
targetname=name,
classname='trigger_catapult',
spawnflags=1, # Players only.
origin=self.base_inst['origin'],
physicsSpeed=0,
playerSpeed=96,
launchDirection=(-normal).to_angle(),
startDisabled=start_disabled,
)
neg_brush.add_out(Output('OnCatapulted', '_fizz_flinch_hurt', 'Hurt'))
pos_brush = neg_brush.copy()
pos_brush['launchDirection'] = normal.to_angle()
vmf.add_ent(pos_brush)
for seg_min, seg_max in self.emitters:
neg_brush.solids.append(vmf.make_prism(
p1=(seg_min
- 4 * normal
- 64 * self.up_axis
),
p2=seg_max + 64 * self.up_axis,
mat=const.Tools.TRIGGER,
).solid)
pos_brush.solids.append(vmf.make_prism(
p1=seg_min - 64 * self.up_axis,
p2=(seg_max
+ 4 * normal
+ 64 * self.up_axis
),
mat=const.Tools.TRIGGER,
).solid)
