def __init__(self, bone: Bone, position: Vec, rotation: Angle):
self.bone = bone
self.position = position
if isinstance(rotation, Vec):
warnings.warn("Use Angle, not Vec.", DeprecationWarning)
self.rotation = Angle(rotation)
else:
self.rotation = rotation
def res_add_placement_helper(inst: Entity, res: Property):
"""Add a placement helper to a specific tile.
`Offset` and `normal` specify the position and direction out of the surface
the helper should be added to. If `upDir` is specified, this is the
direction of the top of the portal.
"""
orient = Matrix.from_angle(Angle.from_str(inst['angles']))
pos = conditions.resolve_offset(inst, res['offset', '0 0 0'], zoff=-64)
normal = res.vec('normal', 0, 0, 1) @ orient
up_dir: Vec | None
try:
up_dir = Vec.from_str(res['upDir']) @ orient
except LookupError:
up_dir = None
try:
tile = tiling.TILES[(pos - 64 * normal).as_tuple(), normal.as_tuple()]
except KeyError:
LOGGER.warning('No tile at {} @ {}', pos, normal)
return
tile.add_portal_helper(up_dir)
def blank(root_name: str) -> 'Mesh':
"""Create an empty mesh, with a single root bone."""
root_bone = Bone(root_name, None)
return Mesh(
{root_name: root_bone},
{0: [BoneFrame(root_bone, Vec(), Angle())]},
[],
)
def res_antigel(inst: Entity) -> None:
"""Implement the Antigel marker."""
inst.remove()
origin = Vec.from_str(inst['origin'])
orient = Matrix.from_angle(Angle.from_str(inst['angles']))
pos = round(origin - 128 * orient.up(), 6)
norm = round(orient.up(), 6)
try:
tiling.TILES[pos.as_tuple(), norm.as_tuple()].is_antigel = True
except KeyError:
LOGGER.warning('No tile to set antigel at {}, {}', pos, norm)
texturing.ANTIGEL_LOCS.add((origin // 128).as_tuple())
def _fill_norm_rotations() -> dict[tuple[tuple[float, float, float], tuple[
float, float, float]], Matrix, ]:
"""Given a norm->norm rotation, return the angles producing that."""
rotations = {}
for norm_ax in 'xyz':
for norm_mag in [-1, +1]:
norm = Vec.with_axes(norm_ax, norm_mag)
for angle_ax in ('pitch', 'yaw', 'roll'):
for angle_mag in (-90, 90):
angle = Matrix.from_angle(
Angle.with_axes(angle_ax, angle_mag))
new_norm = norm @ angle
if new_norm != norm:
rotations[norm.as_tuple(), new_norm.as_tuple()] = angle
# Assign a null rotation as well.
rotations[norm.as_tuple(), norm.as_tuple()] = Matrix()
rotations[norm.as_tuple(), (-norm).as_tuple()] = Matrix()
return rotations
def res_transfer_bullseye(inst: Entity, props: Property):
"""Transfer catapult targets and placement helpers from one tile to another."""
start_pos = conditions.resolve_offset(inst, props['start_pos', ''])
end_pos = conditions.resolve_offset(inst, props['end_pos', ''])
angles = Angle.from_str(inst['angles'])
start_norm = props.vec('start_norm', 0, 0, 1) @ angles
end_norm = props.vec('end_norm', 0, 0, 1) @ angles
try:
start_tile = tiling.TILES[(start_pos - 64 * start_norm).as_tuple(),
start_norm.as_tuple()]
except KeyError:
LOGGER.warning(
'"{}": Cannot find tile to transfer from at {}, {}!'.format(
inst['targetname'], start_pos, start_norm))
return
end_tile = tiling.TileDef.ensure(
end_pos - 64 * end_norm,
end_norm,
)
# Now transfer the stuff.
if start_tile.has_oriented_portal_helper:
# We need to rotate this.
orient = start_tile.portal_helper_orient.copy()
# If it's directly opposite, just mirror - we have no clue what the
# intent is.
if Vec.dot(start_norm, end_norm) != -1.0:
# Use the dict to compute the rotation to apply.
orient @= NORM_ROTATIONS[start_norm.as_tuple(),
end_norm.as_tuple()]
end_tile.add_portal_helper(orient)
elif start_tile.has_portal_helper:
# Non-oriented, don't orient.
end_tile.add_portal_helper()
start_tile.remove_portal_helper(all=True)
if start_tile.bullseye_count:
end_tile.bullseye_count = start_tile.bullseye_count
start_tile.bullseye_count = 0
# Then transfer the targets across.
for plate in faithplate.PLATES.values():
if getattr(plate, 'target', None) is start_tile:
plate.target = end_tile
class BoneFrame:
"""Represents a single frame of bone animation."""
__slots__ = ('bone', 'position', 'rotation')
def __init__(self, bone: Bone, position: Vec, rotation: Angle):
self.bone = bone
self.position = position
if isinstance(rotation, Vec):
warnings.warn("Use Angle, not Vec.", DeprecationWarning)
self.rotation = Angle(rotation)
else:
self.rotation = rotation
def __copy__(self) -> 'BoneFrame':
return BoneFrame(self.bone, self.position, self.rotation)
def __deepcopy__(self, memodict: dict = None) -> 'BoneFrame':
return BoneFrame(
deepcopy(self.bone, memodict),
self.position.copy(),
self.rotation.copy(),
)
def _parse_smd_anim(file_iter: Iterator[Tuple[int, bytes]],
bones: Dict[int, Bone]):
"""Parse the 'skeleton' section of SMDs."""
frames = {}
time: Optional[int] = None
for line_num, line in file_iter:
if line.startswith((b'//', b'#', b';')):
continue
if line.startswith(b'time'):
try:
time = int(line[4:])
except ValueError:
raise ParseError(line_num, 'Invalid time value!') from None
if time in frames:
raise ParseError(line_num, f'Duplicate frame time {time}!')
frames[time] = []
elif line == b'end':
return frames
else: # Bone.
if time is None:
raise ParseError(line_num, 'No time specification!')
try:
byt_ind, byt_x, byt_y, byt_z, byt_pit, byt_yaw, byt_rol = line.split(
)
pos = Vec(float(byt_x), float(byt_y), float(byt_z))
rot = Angle(math.degrees(float(byt_pit)),
math.degrees(float(byt_yaw)),
math.degrees(float(byt_rol)))
except ValueError:
raise ParseError(line_num, 'Invalid line!') from None
try:
bone = bones[int(byt_ind)]
except KeyError:
raise ParseError(line_num, 'Unknown bone index {}!',
int(byt_ind))
frames[time].append(BoneFrame(bone, pos, rot))
raise ParseError('end', 'No end to skeleton section!')
def res_set_tile(inst: Entity, res: Property) -> None:
"""Set 4x4 parts of a tile to the given values.
`Offset` defines the position of the upper-left tile in the grid.
Each `Tile` section defines a row of the positions to edit like so:
"Tile" "bbbb"
"Tile" "b..b"
"Tile" "b..b"
"Tile" "bbbb"
If `Force` is true, the specified tiles will override any existing ones
and create the tile if necessary.
Otherwise they will be merged in - white/black tiles will not replace
tiles set to nodraw or void for example.
`chance`, if specified allows producing irregular tiles by randomly not
changing the tile.
If you need less regular placement (other orientation, precise positions)
use a bee2_template_tilesetter in a template.
Allowed tile characters:
- `W`: White tile.
- `w`: White 4x4 only tile.
- `B`: Black tile.
- `b`: Black 4x4 only tile.
- `g`: The side/bottom of goo pits.
- `n`: Nodraw surface.
- `i`: Invert the tile surface, if black/white.
- `1`: Convert to a 1x1 only tile, if a black/white tile.
- `4`: Convert to a 4x4 only tile, if a black/white tile.
- `.`: Void (remove the tile in this position).
- `_` or ` `: Placeholder (don't modify this space).
- `x`: Cutout Tile (Broken)
- `o`: Cutout Tile (Partial)
"""
origin = Vec.from_str(inst['origin'])
orient = Matrix.from_angle(Angle.from_str(inst['angles']))
offset = (res.vec('offset', -48, 48) - (0, 0, 64)) @ orient + origin
norm = round(orient.up(), 6)
force_tile = res.bool('force')
tiles: list[str] = [
row.value for row in res if row.name in ('tile', 'tiles')
]
if not tiles:
raise ValueError('No "tile" parameters in SetTile!')
chance = srctools.conv_float(res['chance', '100'].rstrip('%'), 100.0)
if chance < 100.0:
rng = rand.seed(b'tile', inst, res['seed', ''])
else:
rng = None
for y, row in enumerate(tiles):
for x, val in enumerate(row):
if val in '_ ':
continue
if rng is not None and rng.uniform(0, 100) > chance:
continue
pos = Vec(32 * x, -32 * y, 0) @ orient + offset
if val == '4':
size = tiling.TileSize.TILE_4x4
elif val == '1':
size = tiling.TileSize.TILE_1x1
elif val == 'i':
size = None
else:
try:
new_tile = tiling.TILETYPE_FROM_CHAR[val]
except KeyError:
LOGGER.warning('Unknown tiletype "{}"!', val)
else:
tiling.edit_quarter_tile(pos, norm, new_tile, force_tile)
continue
# Edit the existing tile.
try:
tile, u, v = tiling.find_tile(pos, norm, force_tile)
except KeyError:
LOGGER.warning(
'Expected tile, but none found: {}, {}',
pos,
norm,
)
continue
if size is None:
# Invert the tile.
tile[u, v] = tile[u, v].inverted
continue
# Unless forcing is enabled don't alter the size of GOO_SIDE.
if tile[u, v].is_tile and tile[u,
v] is not tiling.TileType.GOO_SIDE:
tile[u, v] = tiling.TileType.with_color_and_size(
size, tile[u, v].color)
elif force_tile:
# If forcing, make it black. Otherwise no need to change.
tile[u, v] = tiling.TileType.with_color_and_size(
size, tiling.Portalable.BLACK)
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 place_template(inst: Entity) -> None:
"""Place a template."""
temp_id = inst.fixup.substitute(orig_temp_id)
# Special case - if blank, just do nothing silently.
if not temp_id:
return
temp_name, visgroups = template_brush.parse_temp_name(temp_id)
try:
template = template_brush.get_template(temp_name)
except template_brush.InvalidTemplateName:
# If we did lookup, display both forms.
if temp_id != orig_temp_id:
LOGGER.warning('{} -> "{}" is not a valid template!',
orig_temp_id, temp_name)
else:
LOGGER.warning('"{}" is not a valid template!', temp_name)
# We don't want an error, just quit.
return
for vis_flag_block in visgroup_instvars:
if all(
conditions.check_flag(flag, coll, inst)
for flag in vis_flag_block):
visgroups.add(vis_flag_block.real_name)
force_colour = conf_force_colour
if color_var == '<editor>':
# Check traits for the colour it should be.
traits = instance_traits.get(inst)
if 'white' in traits:
force_colour = texturing.Portalable.white
elif 'black' in traits:
force_colour = texturing.Portalable.black
else:
LOGGER.warning(
'"{}": Instance "{}" '
"isn't one with inherent color!",
temp_id,
inst['file'],
)
elif color_var:
color_val = conditions.resolve_value(inst, color_var).casefold()
if color_val == 'white':
force_colour = texturing.Portalable.white
elif color_val == 'black':
force_colour = texturing.Portalable.black
# else: no color var
if srctools.conv_bool(conditions.resolve_value(inst, invert_var)):
force_colour = template_brush.TEMP_COLOUR_INVERT[conf_force_colour]
# else: False value, no invert.
if ang_override is not None:
orient = ang_override
else:
orient = rotation @ Angle.from_str(inst['angles', '0 0 0'])
origin = conditions.resolve_offset(inst, offset)
# If this var is set, it forces all to be included.
if srctools.conv_bool(
conditions.resolve_value(inst, visgroup_force_var)):
visgroups.update(template.visgroups)
elif visgroup_func is not None:
visgroups.update(
visgroup_func(
rand.seed(b'temp', template.id, origin, orient),
list(template.visgroups),
))
LOGGER.debug('Placing template "{}" at {} with visgroups {}',
template.id, origin, visgroups)
temp_data = template_brush.import_template(
vmf,
template,
origin,
orient,
targetname=inst['targetname'],
force_type=force_type,
add_to_map=True,
coll=coll,
additional_visgroups=visgroups,
bind_tile_pos=bind_tile_pos,
align_bind=align_bind_overlay,
)
if key_block is not None:
conditions.set_ent_keys(temp_data.detail, inst, key_block)
br_origin = Vec.from_str(key_block.find_key('keys')['origin'])
br_origin.localise(origin, orient)
temp_data.detail['origin'] = br_origin
move_dir = temp_data.detail['movedir', '']
if move_dir.startswith('<') and move_dir.endswith('>'):
move_dir = Vec.from_str(move_dir) @ orient
temp_data.detail['movedir'] = move_dir.to_angle()
for out in outputs:
out = out.copy()
out.target = conditions.local_name(inst, out.target)
temp_data.detail.add_out(out)
template_brush.retexture_template(
temp_data,
origin,
inst.fixup,
replace_tex,
force_colour,
force_grid,
surf_cat,
sense_offset,
)
for picker_name, picker_var in picker_vars:
picker_val = temp_data.picker_results.get(picker_name, None)
if picker_val is not None:
inst.fixup[picker_var] = picker_val.value
else:
inst.fixup[picker_var] = ''
def res_import_template(vmf: VMF, coll: Collisions, res: Property):
"""Import a template VMF file, retexturing it to match orientation.
It will be placed overlapping the given instance. If no block is used, only
ID can be specified.
Options:
- `ID`: The ID of the template to be inserted. Add visgroups to additionally
add after a colon, comma-seperated (`temp_id:vis1,vis2`).
Either section, or the whole value can be a `$fixup`.
- `angles`: Override the instance rotation, so it is always rotated this much.
- `rotation`: Apply the specified rotation before the instance's rotation.
- `offset`: Offset the template from the instance's position.
- `force`: a space-seperated list of overrides. If 'white' or 'black' is
present, the colour of tiles will be overridden. If `invert` is
added, white/black tiles will be swapped. If a tile size
(`2x2`, `4x4`, `wall`, `special`) is included, all tiles will
be switched to that size (if not a floor/ceiling). If 'world' or
'detail' is present, the brush will be forced to that type.
- `replace`: A block of template material -> replacement textures.
This is case insensitive - any texture here will not be altered
otherwise. If the material starts with a `#`, it is instead a
list of face IDs separated by spaces. If the result evaluates
to "", no change occurs. Both can be $fixups (parsed first).
- `bindOverlay`: Bind overlays in this template to the given surface, and
bind overlays on a surface to surfaces in this template.
The value specifies the offset to the surface, where 0 0 0 is the
floor position. It can also be a block of multiple positions.
- `alignBindOverlay`: If set, align the bindOverlay offsets to the grid.
- `keys`/`localkeys`: If set, a brush entity will instead be generated with
these values. This overrides force world/detail.
Specially-handled keys:
- `"origin"`, offset automatically.
- `"movedir"` on func_movelinear - set a normal surrounded by `<>`,
this gets replaced with angles.
- `colorVar`: If this fixup var is set
to `white` or `black`, that colour will be forced.
If the value is `<editor>`, the colour will be chosen based on
the color of the surface for ItemButtonFloor, funnels or
entry/exit frames.
- `invertVar`: If this fixup value is true, tile colour will be
swapped to the opposite of the current force option. This applies
after colorVar.
- `visgroup`: Sets how visgrouped parts are handled. Several values are possible:
- A property block: Each name should match a visgroup, and the
value should be a block of flags that if true enables that group.
- 'none' (default): All extra groups are ignored.
- 'choose': One group is chosen randomly.
- a number: The percentage chance for each visgroup to be added.
- `visgroup_force_var`: If set and True, visgroup is ignored and all groups
are added.
- `pickerVars`:
If this is set, the results of colorpickers can be read
out of the template. The key is the name of the picker, the value
is the fixup name to write to. The output is either 'white',
'black' or ''.
- `outputs`: Add outputs to the brush ent. Syntax is like VMFs, and all names
are local to the instance.
- `senseOffset`: If set, colorpickers and tilesetters will be treated
as being offset by this amount.
"""
if res.has_children():
orig_temp_id = res['id']
else:
orig_temp_id = res.value
res = Property('TemplateBrush', [])
force = res['force', ''].casefold().split()
if 'white' in force:
conf_force_colour = texturing.Portalable.white
elif 'black' in force:
conf_force_colour = texturing.Portalable.black
elif 'invert' in force:
conf_force_colour = 'INVERT'
else:
conf_force_colour = None
if 'world' in force:
force_type = template_brush.TEMP_TYPES.world
elif 'detail' in force:
force_type = template_brush.TEMP_TYPES.detail
else:
force_type = template_brush.TEMP_TYPES.default
force_grid: texturing.TileSize | None
size: texturing.TileSize
for size in texturing.TileSize:
if size in force:
force_grid = size
break
else:
force_grid = None
if 'bullseye' in force:
surf_cat = texturing.GenCat.BULLSEYE
elif 'special' in force or 'panel' in force:
surf_cat = texturing.GenCat.PANEL
else:
surf_cat = texturing.GenCat.NORMAL
replace_tex: dict[str, list[str]] = {}
for prop in res.find_block('replace', or_blank=True):
replace_tex.setdefault(prop.name, []).append(prop.value)
if 'replaceBrush' in res:
LOGGER.warning(
'replaceBrush command used for template "{}", which is no '
'longer used.',
orig_temp_id,
)
bind_tile_pos = [
# So it's the floor block location.
Vec.from_str(value) - (0, 0, 128)
for value in res.find_key('BindOverlay', or_blank=True).as_array()
]
align_bind_overlay = res.bool('alignBindOverlay')
key_values = res.find_block("Keys", or_blank=True)
if key_values:
key_block = Property("", [
key_values,
res.find_block("LocalKeys", or_blank=True),
])
# Ensure we have a 'origin' keyvalue - we automatically offset that.
if 'origin' not in key_values:
key_values['origin'] = '0 0 0'
# Spawn everything as detail, so they get put into a brush
# entity.
force_type = template_brush.TEMP_TYPES.detail
outputs = [Output.parse(prop) for prop in res.find_children('Outputs')]
else:
key_block = None
outputs = []
# None = don't add any more.
visgroup_func: Callable[[Random, list[str]], Iterable[str]] | None = None
try: # allow both spellings.
visgroup_prop = res.find_key('visgroups')
except NoKeyError:
visgroup_prop = res.find_key('visgroup', 'none')
if visgroup_prop.has_children():
visgroup_instvars = list(visgroup_prop)
else:
visgroup_instvars = []
visgroup_mode = res['visgroup', 'none'].casefold()
# Generate the function which picks which visgroups to add to the map.
if visgroup_mode == 'none':
pass
elif visgroup_mode == 'choose':
def visgroup_func(rng: Random, groups: list[str]) -> Iterable[str]:
"""choose = add one random group."""
return [rng.choice(groups)]
else:
percent = srctools.conv_float(visgroup_mode.rstrip('%'), 0.00)
if percent > 0.0:
def visgroup_func(rng: Random,
groups: list[str]) -> Iterable[str]:
"""Number = percent chance for each to be added"""
for group in sorted(groups):
if rng.uniform(0, 100) <= percent:
yield group
picker_vars = [(prop.real_name, prop.value)
for prop in res.find_children('pickerVars')]
try:
ang_override = to_matrix(Angle.from_str(res['angles']))
except LookupError:
ang_override = None
try:
rotation = to_matrix(Angle.from_str(res['rotation']))
except LookupError:
rotation = Matrix()
offset = res['offset', '0 0 0']
invert_var = res['invertVar', '']
color_var = res['colorVar', '']
if color_var.casefold() == '<editor>':
color_var = '<editor>'
# If true, force visgroups to all be used.
visgroup_force_var = res['forceVisVar', '']
sense_offset = res.vec('senseOffset')
def place_template(inst: Entity) -> None:
"""Place a template."""
temp_id = inst.fixup.substitute(orig_temp_id)
# Special case - if blank, just do nothing silently.
if not temp_id:
return
temp_name, visgroups = template_brush.parse_temp_name(temp_id)
try:
template = template_brush.get_template(temp_name)
except template_brush.InvalidTemplateName:
# If we did lookup, display both forms.
if temp_id != orig_temp_id:
LOGGER.warning('{} -> "{}" is not a valid template!',
orig_temp_id, temp_name)
else:
LOGGER.warning('"{}" is not a valid template!', temp_name)
# We don't want an error, just quit.
return
for vis_flag_block in visgroup_instvars:
if all(
conditions.check_flag(flag, coll, inst)
for flag in vis_flag_block):
visgroups.add(vis_flag_block.real_name)
force_colour = conf_force_colour
if color_var == '<editor>':
# Check traits for the colour it should be.
traits = instance_traits.get(inst)
if 'white' in traits:
force_colour = texturing.Portalable.white
elif 'black' in traits:
force_colour = texturing.Portalable.black
else:
LOGGER.warning(
'"{}": Instance "{}" '
"isn't one with inherent color!",
temp_id,
inst['file'],
)
elif color_var:
color_val = conditions.resolve_value(inst, color_var).casefold()
if color_val == 'white':
force_colour = texturing.Portalable.white
elif color_val == 'black':
force_colour = texturing.Portalable.black
# else: no color var
if srctools.conv_bool(conditions.resolve_value(inst, invert_var)):
force_colour = template_brush.TEMP_COLOUR_INVERT[conf_force_colour]
# else: False value, no invert.
if ang_override is not None:
orient = ang_override
else:
orient = rotation @ Angle.from_str(inst['angles', '0 0 0'])
origin = conditions.resolve_offset(inst, offset)
# If this var is set, it forces all to be included.
if srctools.conv_bool(
conditions.resolve_value(inst, visgroup_force_var)):
visgroups.update(template.visgroups)
elif visgroup_func is not None:
visgroups.update(
visgroup_func(
rand.seed(b'temp', template.id, origin, orient),
list(template.visgroups),
))
LOGGER.debug('Placing template "{}" at {} with visgroups {}',
template.id, origin, visgroups)
temp_data = template_brush.import_template(
vmf,
template,
origin,
orient,
targetname=inst['targetname'],
force_type=force_type,
add_to_map=True,
coll=coll,
additional_visgroups=visgroups,
bind_tile_pos=bind_tile_pos,
align_bind=align_bind_overlay,
)
if key_block is not None:
conditions.set_ent_keys(temp_data.detail, inst, key_block)
br_origin = Vec.from_str(key_block.find_key('keys')['origin'])
br_origin.localise(origin, orient)
temp_data.detail['origin'] = br_origin
move_dir = temp_data.detail['movedir', '']
if move_dir.startswith('<') and move_dir.endswith('>'):
move_dir = Vec.from_str(move_dir) @ orient
temp_data.detail['movedir'] = move_dir.to_angle()
for out in outputs:
out = out.copy()
out.target = conditions.local_name(inst, out.target)
temp_data.detail.add_out(out)
template_brush.retexture_template(
temp_data,
origin,
inst.fixup,
replace_tex,
force_colour,
force_grid,
surf_cat,
sense_offset,
)
for picker_name, picker_var in picker_vars:
picker_val = temp_data.picker_results.get(picker_name, None)
if picker_val is not None:
inst.fixup[picker_var] = picker_val.value
else:
inst.fixup[picker_var] = ''
return place_template
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 res_set_texture(inst: Entity, res: Property):
"""Set the tile at a particular place to use a specific texture.
This can only be set for an entire voxel side at once.
`pos` is the position, relative to the instance (0 0 0 is the floor-surface).
`dir` is the normal of the texture (pointing out)
If `gridPos` is true, the position will be snapped so it aligns with
the 128 brushes (Useful with fizzler/light strip items).
`tex` is the texture to use.
If `template` is set, the template should be an axis aligned cube. This
will be rotated by the instance angles, and then the face with the same
orientation will be applied to the face (with the rotation and texture).
"""
angles = Angle.from_str(inst['angles'])
origin = Vec.from_str(inst['origin'])
pos = Vec.from_str(res['pos', '0 0 0'])
pos.z -= 64 # Subtract so origin is the floor-position
pos.localise(origin, angles)
norm = round(Vec.from_str(res['dir', '0 0 1']) @ angles, 6)
if srctools.conv_bool(res['gridpos', '0']):
for axis in 'xyz':
# Don't realign things in the normal's axis -
# those are already fine.
if not norm[axis]:
pos[axis] //= 128
pos[axis] *= 128
pos[axis] += 64
try:
# The user expects the tile to be at it's surface pos, not the
# position of the voxel.
tile = tiling.TILES[(pos - 64 * norm).as_tuple(), norm.as_tuple()]
except KeyError:
LOGGER.warning(
'"{}": Could not find tile at {} with orient {}!',
inst['targetname'],
pos,
norm,
)
return
temp_id = inst.fixup.substitute(res['template', ''])
if temp_id:
temp = template_brush.get_scaling_template(temp_id).rotate(
angles, origin)
else:
temp = template_brush.ScalingTemplate.world()
tex = inst.fixup.substitute(res['tex', ''])
if tex.startswith('<') and tex.endswith('>'):
LOGGER.warning(
'Special <lookups> for AlterTexture are '
'no longer usable! ("{}")', tex)
elif tex.startswith('[') and tex.endswith(']'):
gen, name = texturing.parse_name(tex[1:-1])
tex = gen.get(pos - 64 * norm, name)
tile.override = (tex, temp)
def edit_panel(vmf: VMF, inst: Entity, props: Property, create: bool) -> None:
"""Implements SetPanelOptions and CreatePanel."""
orient = Matrix.from_angle(Angle.from_str(inst['angles']))
normal: Vec = round(props.vec('normal', 0, 0, 1) @ orient, 6)
origin = Vec.from_str(inst['origin'])
uaxis, vaxis = Vec.INV_AXIS[normal.axis()]
points: set[tuple[float, float, float]] = set()
if 'point' in props:
for prop in props.find_all('point'):
points.add(
conditions.resolve_offset(inst, prop.value,
zoff=-64).as_tuple())
elif 'pos1' in props and 'pos2' in props:
pos1, pos2 = Vec.bbox(
conditions.resolve_offset(inst,
props['pos1', '-48 -48 0'],
zoff=-64),
conditions.resolve_offset(inst, props['pos2', '48 48 0'],
zoff=-64),
)
points.update(map(Vec.as_tuple, Vec.iter_grid(pos1, pos2, 32)))
else:
# Default to the full tile.
points.update({(Vec(u, v, -64.0) @ orient + origin).as_tuple()
for u in [-48.0, -16.0, 16.0, 48.0]
for v in [-48.0, -16.0, 16.0, 48.0]})
tiles_to_uv: dict[tiling.TileDef, set[tuple[int, int]]] = defaultdict(set)
for pos in points:
try:
tile, u, v = tiling.find_tile(Vec(pos), normal, force=create)
except KeyError:
continue
tiles_to_uv[tile].add((u, v))
if not tiles_to_uv:
LOGGER.warning('"{}": No tiles found for panels!', inst['targetname'])
return
# If bevels is provided, parse out the overall world positions.
bevel_world: set[tuple[int, int]] | None
try:
bevel_prop = props.find_key('bevel')
except NoKeyError:
bevel_world = None
else:
bevel_world = set()
if bevel_prop.has_children():
# Individually specifying offsets.
for bevel_str in bevel_prop.as_array():
bevel_point = Vec.from_str(bevel_str) @ orient + origin
bevel_world.add(
(int(bevel_point[uaxis]), int(bevel_point[vaxis])))
elif srctools.conv_bool(bevel_prop.value):
# Fill the bounding box.
bbox_min, bbox_max = Vec.bbox(map(Vec, points))
off = Vec.with_axes(uaxis, 32, vaxis, 32)
bbox_min -= off
bbox_max += off
for pos in Vec.iter_grid(bbox_min, bbox_max, 32):
if pos.as_tuple() not in points:
bevel_world.add((pos[uaxis], pos[vaxis]))
# else: No bevels.
panels: list[tiling.Panel] = []
for tile, uvs in tiles_to_uv.items():
if create:
panel = tiling.Panel(
None,
inst,
tiling.PanelType.NORMAL,
thickness=4,
bevels=(),
)
panel.points = uvs
tile.panels.append(panel)
else:
for panel in tile.panels:
if panel.same_item(inst) and panel.points == uvs:
break
else:
LOGGER.warning('No panel to modify found for "{}"!',
inst['targetname'])
continue
panels.append(panel)
pan_type = '<nothing?>'
try:
pan_type = conditions.resolve_value(inst, props['type'])
panel.pan_type = tiling.PanelType(pan_type.lower())
except LookupError:
pass
except ValueError:
raise ValueError('Unknown panel type "{}"!'.format(pan_type))
if 'thickness' in props:
panel.thickness = srctools.conv_int(
conditions.resolve_value(inst, props['thickness']))
if panel.thickness not in (2, 4, 8):
raise ValueError(
'"{}": Invalid panel thickess {}!\n'
'Must be 2, 4 or 8.',
inst['targetname'],
panel.thickness,
)
if bevel_world is not None:
panel.bevels.clear()
for u, v in bevel_world:
# Convert from world points to UV positions.
u = (u - tile.pos[uaxis] + 48) // 32
v = (v - tile.pos[vaxis] + 48) // 32
# Cull outside here, we wont't use them.
if -1 <= u <= 4 and -1 <= v <= 4:
panel.bevels.add((u, v))
if 'offset' in props:
panel.offset = conditions.resolve_offset(inst, props['offset'])
panel.offset -= Vec.from_str(inst['origin'])
if 'template' in props:
# We only want the template inserted once. So remove it from all but one.
if len(panels) == 1:
panel.template = inst.fixup.substitute(props['template'])
else:
panel.template = ''
if 'nodraw' in props:
panel.nodraw = srctools.conv_bool(
inst.fixup.substitute(props['nodraw'], allow_invert=True))
if 'seal' in props:
panel.seal = srctools.conv_bool(
inst.fixup.substitute(props['seal'], allow_invert=True))
if 'move_bullseye' in props:
panel.steals_bullseye = srctools.conv_bool(
inst.fixup.substitute(props['move_bullseye'],
allow_invert=True))
if 'keys' in props or 'localkeys' in props:
# First grab the existing ent, so we can edit it.
# These should all have the same value, unless they were independently
# edited with mismatching point sets. In that case destroy all those existing ones.
existing_ents: set[Entity
| None] = {panel.brush_ent
for panel in panels}
try:
[brush_ent] = existing_ents
except ValueError:
LOGGER.warning(
'Multiple independent panels for "{}" were made, then the '
'brush entity was edited as a group! Discarding '
'individual ents...', inst['targetname'])
for brush_ent in existing_ents:
if brush_ent is not None and brush_ent in vmf.entities:
brush_ent.remove()
brush_ent = None
if brush_ent is None:
brush_ent = vmf.create_ent('')
old_pos = brush_ent.keys.pop('origin', None)
conditions.set_ent_keys(brush_ent, inst, props)
if not brush_ent['classname']:
if create: # This doesn't make sense, you could just omit the prop.
LOGGER.warning(
'No classname provided for panel "{}"!',
inst['targetname'],
)
# Make it a world brush.
brush_ent.remove()
brush_ent = None
else:
# We want to do some post-processing.
# Localise any origin value.
if 'origin' in brush_ent.keys:
pos = Vec.from_str(brush_ent['origin'])
pos.localise(
Vec.from_str(inst['origin']),
Angle.from_str(inst['angles']),
)
brush_ent['origin'] = pos
elif old_pos is not None:
brush_ent['origin'] = old_pos
# If it's func_detail, clear out all the keys.
# Particularly `origin`, but the others are useless too.
if brush_ent['classname'] == 'func_detail':
brush_ent.clear_keys()
brush_ent['classname'] = 'func_detail'
for panel in panels:
panel.brush_ent = brush_ent
def _parse_template(loc: UnparsedTemplate) -> Template:
"""Parse a template VMF."""
filesys: FileSystem
if os.path.isdir(loc.pak_path):
filesys = RawFileSystem(loc.pak_path)
else:
ext = os.path.splitext(loc.pak_path)[1].casefold()
if ext in ('.bee_pack', '.zip'):
filesys = ZipFileSystem(loc.pak_path)
elif ext == '.vpk':
filesys = VPKFileSystem(loc.pak_path)
else:
raise ValueError(f'Unknown filesystem type for "{loc.pak_path}"!')
with filesys[loc.path].open_str() as f:
props = Property.parse(f, f'{loc.pak_path}:{loc.path}')
vmf = srctools.VMF.parse(props, preserve_ids=True)
del props, filesys, f # Discard all this data.
# visgroup -> list of brushes/overlays
detail_ents: dict[str, list[Solid]] = defaultdict(list)
world_ents: dict[str, list[Solid]] = defaultdict(list)
overlay_ents: dict[str, list[Entity]] = defaultdict(list)
color_pickers: list[ColorPicker] = []
tile_setters: list[TileSetter] = []
voxel_setters: list[VoxelSetter] = []
conf_ents = vmf.by_class['bee2_template_conf']
if len(conf_ents) > 1:
raise ValueError(
f'Multiple configuration entities in template "{loc.id}"!')
elif not conf_ents:
raise ValueError(f'No configration entity for template "{loc.id}"!')
else:
[conf] = conf_ents
if conf['template_id'].upper() != loc.id:
raise ValueError(
f'Mismatch in template IDs for {conf["template_id"]} and {loc.id}')
def yield_world_detail() -> Iterator[tuple[list[Solid], bool, set[str]]]:
"""Yield all world/detail solids in the map.
This also indicates if it's a func_detail, and the visgroup IDs.
(Those are stored in the ent for detail, and the solid for world.)
"""
for brush in vmf.brushes:
yield [brush], False, brush.visgroup_ids
for detail in vmf.by_class['func_detail']:
yield detail.solids, True, detail.visgroup_ids
force = conf['temp_type']
force_is_detail: Optional[bool]
if force.casefold() == 'detail':
force_is_detail = True
elif force.casefold() == 'world':
force_is_detail = False
else:
force_is_detail = None
visgroup_names = {vis.id: vis.name.casefold() for vis in vmf.vis_tree}
conf_auto_visgroup = 1 if srctools.conv_bool(
conf['detail_auto_visgroup']) else 0
if not srctools.conv_bool(conf['discard_brushes']):
for brushes, is_detail, vis_ids in yield_world_detail():
visgroups = list(map(visgroup_names.__getitem__, vis_ids))
if len(visgroups) > 1:
raise ValueError('Template "{}" has brush with two '
'visgroups! ({})'.format(
loc.id, ', '.join(visgroups)))
# No visgroup = ''
visgroup = visgroups[0] if visgroups else ''
# Auto-visgroup puts func_detail ents in unique visgroups.
if is_detail and not visgroup and conf_auto_visgroup:
visgroup = '__auto_group_{}__'.format(conf_auto_visgroup)
# Reuse as the unique index, >0 are True too..
conf_auto_visgroup += 1
# Check this after auto-visgroup, so world/detail can be used to
# opt into the grouping, then overridden to be the same.
if force_is_detail is not None:
is_detail = force_is_detail
if is_detail:
detail_ents[visgroup].extend(brushes)
else:
world_ents[visgroup].extend(brushes)
for ent in vmf.by_class['info_overlay']:
visgroups = list(map(visgroup_names.__getitem__, ent.visgroup_ids))
if len(visgroups) > 1:
raise ValueError('Template "{}" has overlay with two '
'visgroups! ({})'.format(loc.id,
', '.join(visgroups)))
# No visgroup = ''
overlay_ents[visgroups[0] if visgroups else ''].append(ent)
for ent in vmf.by_class['bee2_template_colorpicker']:
# Parse the colorpicker data.
try:
priority = Decimal(ent['priority'])
except ArithmeticError:
LOGGER.warning(
'Bad priority for colorpicker in "{}" template!',
loc.id,
)
priority = Decimal(0)
try:
remove_after = AfterPickMode(ent['remove_brush', '0'])
except ValueError:
LOGGER.warning(
'Bad remove-brush mode for colorpicker in "{}" template!',
loc.id,
)
remove_after = AfterPickMode.NONE
color_pickers.append(
ColorPicker(
priority=priority,
name=ent['targetname'],
visgroups=set(map(visgroup_names.__getitem__,
ent.visgroup_ids)),
offset=Vec.from_str(ent['origin']),
normal=Vec(x=1) @ Angle.from_str(ent['angles']),
sides=ent['faces'].split(' '),
grid_snap=srctools.conv_bool(ent['grid_snap']),
after=remove_after,
use_pattern=srctools.conv_bool(ent['use_pattern']),
force_tex_white=ent['tex_white'],
force_tex_black=ent['tex_black'],
))
for ent in vmf.by_class['bee2_template_voxelsetter']:
tile_type = TILE_SETTER_SKINS[srctools.conv_int(ent['skin'])]
voxel_setters.append(
VoxelSetter(
offset=Vec.from_str(ent['origin']),
normal=Vec(z=1) @ Angle.from_str(ent['angles']),
visgroups=set(map(visgroup_names.__getitem__,
ent.visgroup_ids)),
tile_type=tile_type,
force=srctools.conv_bool(ent['force']),
))
for ent in vmf.by_class['bee2_template_tilesetter']:
tile_type = TILE_SETTER_SKINS[srctools.conv_int(ent['skin'])]
color = ent['color']
if color == 'tile':
try:
color = tile_type.color
except ValueError:
# Non-tile types.
color = None
elif color == 'invert':
color = 'INVERT'
elif color == 'match':
color = None
elif color != 'copy':
raise ValueError('Invalid TileSetter color '
'"{}" for "{}"'.format(color, loc.id))
tile_setters.append(
TileSetter(
offset=Vec.from_str(ent['origin']),
normal=Vec(z=1) @ Angle.from_str(ent['angles']),
visgroups=set(map(visgroup_names.__getitem__,
ent.visgroup_ids)),
color=color,
tile_type=tile_type,
picker_name=ent['color_picker'],
force=srctools.conv_bool(ent['force']),
))
coll: list[CollisionDef] = []
for ent in vmf.by_class['bee2_collision_bbox']:
visgroups = set(map(visgroup_names.__getitem__, ent.visgroup_ids))
for bbox in collisions.BBox.from_ent(ent):
coll.append(CollisionDef(bbox, visgroups))
return Template(
loc.id,
set(visgroup_names.values()),
world_ents,
detail_ents,
overlay_ents,
conf['skip_faces'].split(),
conf['realign_faces'].split(),
conf['overlay_faces'].split(),
conf['vertical_faces'].split(),
color_pickers,
tile_setters,
voxel_setters,
coll,
)
def load_templates() -> None:
"""Load in the template file, used for import_template()."""
with open(TEMPLATE_LOCATION) as file:
props = Property.parse(file, TEMPLATE_LOCATION)
vmf = srctools.VMF.parse(props, preserve_ids=True)
def make_subdict() -> Dict[str, list]:
return defaultdict(list)
# detail_ents[temp_id][visgroup]
detail_ents = defaultdict(
make_subdict) # type: Dict[str, Dict[str, List[Solid]]]
world_ents = defaultdict(
make_subdict) # type: Dict[str, Dict[str, List[Solid]]]
overlay_ents = defaultdict(
make_subdict) # type: Dict[str, Dict[str, List[Entity]]]
conf_ents = {}
color_pickers = defaultdict(list) # type: Dict[str, List[ColorPicker]]
tile_setters = defaultdict(list) # type: Dict[str, List[TileSetter]]
for ent in vmf.by_class['bee2_template_world']:
world_ents[ent['template_id'].casefold()][
ent['visgroup'].casefold()].extend(ent.solids)
for ent in vmf.by_class['bee2_template_detail']:
detail_ents[ent['template_id'].casefold()][
ent['visgroup'].casefold()].extend(ent.solids)
for ent in vmf.by_class['bee2_template_overlay']:
overlay_ents[ent['template_id'].casefold()][
ent['visgroup'].casefold()].append(ent)
for ent in vmf.by_class['bee2_template_conf']:
conf_ents[ent['template_id'].casefold()] = ent
for ent in vmf.by_class['bee2_template_scaling']:
temp = ScalingTemplate.parse(ent)
_TEMPLATES[temp.id.casefold()] = temp
for ent in vmf.by_class['bee2_template_colorpicker']:
# Parse the colorpicker data.
temp_id = ent['template_id'].casefold()
try:
priority = Decimal(ent['priority'])
except ValueError:
LOGGER.warning(
'Bad priority for colorpicker in "{}" template!',
temp_id.upper(),
)
priority = Decimal(0)
try:
remove_after = AfterPickMode(ent['remove_brush', '0'])
except ValueError:
LOGGER.warning(
'Bad remove-brush mode for colorpicker in "{}" template!',
temp_id.upper(),
)
remove_after = AfterPickMode.NONE
color_pickers[temp_id].append(
ColorPicker(
priority,
name=ent['targetname'],
visgroups=set(ent['visgroups'].split(' ')) - {''},
offset=Vec.from_str(ent['origin']),
normal=Vec(x=1) @ Angle.from_str(ent['angles']),
sides=ent['faces'].split(' '),
grid_snap=srctools.conv_bool(ent['grid_snap']),
after=remove_after,
use_pattern=srctools.conv_bool(ent['use_pattern']),
force_tex_white=ent['tex_white'],
force_tex_black=ent['tex_black'],
))
for ent in vmf.by_class['bee2_template_tilesetter']:
# Parse the tile setter data.
temp_id = ent['template_id'].casefold()
tile_type = TILE_SETTER_SKINS[srctools.conv_int(ent['skin'])]
color = ent['color']
if color == 'tile':
try:
color = tile_type.color
except ValueError:
# Non-tile types.
color = None
elif color == 'invert':
color = 'INVERT'
elif color == 'match':
color = None
elif color != 'copy':
raise ValueError('Invalid TileSetter color '
'"{}" for "{}"'.format(color, temp_id))
tile_setters[temp_id].append(
TileSetter(
offset=Vec.from_str(ent['origin']),
normal=Vec(z=1) @ Angle.from_str(ent['angles']),
visgroups=set(ent['visgroups'].split(' ')) - {''},
color=color,
tile_type=tile_type,
picker_name=ent['color_picker'],
force=srctools.conv_bool(ent['force']),
))
temp_ids = set(conf_ents).union(
detail_ents,
world_ents,
overlay_ents,
color_pickers,
tile_setters,
)
for temp_id in temp_ids:
try:
conf = conf_ents[temp_id]
except KeyError:
overlay_faces = [] # type: List[str]
skip_faces = [] # type: List[str]
vertical_faces = [] # type: List[str]
realign_faces = [] # type: List[str]
else:
vertical_faces = conf['vertical_faces'].split()
realign_faces = conf['realign_faces'].split()
overlay_faces = conf['overlay_faces'].split()
skip_faces = conf['skip_faces'].split()
_TEMPLATES[temp_id.casefold()] = Template(
temp_id,
world_ents[temp_id],
detail_ents[temp_id],
overlay_ents[temp_id],
skip_faces,
realign_faces,
overlay_faces,
vertical_faces,
color_pickers[temp_id],
tile_setters[temp_id],
)
