def write_sound(
file: StringIO,
snds: Property,
pack_list: PackList,
snd_prefix: str='*',
) -> None:
"""Write either a single sound, or multiple rndsound.
snd_prefix is the prefix for each filename - *, #, @, etc.
"""
if snds.has_children():
file.write('"rndwave"\n\t{\n')
for snd in snds:
file.write(
'\t"wave" "{sndchar}{file}"\n'.format(
file=snd.value.lstrip(SOUND_CHARS),
sndchar=snd_prefix,
)
)
pack_list.pack_file('sound/' + snd.value.casefold())
file.write('\t}\n')
else:
file.write(
'"wave" "{sndchar}{file}"\n'.format(
file=snds.value.lstrip(SOUND_CHARS),
sndchar=snd_prefix,
)
)
pack_list.pack_file('sound/' + snds.value.casefold())
def parse(prop: Property):
"""Parse from property values.
The value can be in four forms:
"prop" "material"
"prop" "<scale>|material"
"prop" "<scale>|material|static"
"prop"
{
"tex" "<mat>"
"scale" "<scale>"
"static" "<is_static>"
}
"""
if prop.has_children():
tex = prop['tex']
scale = prop.float('scale', 0.25)
static = prop.bool('static')
else:
vals = prop.value.split('|')
opts = ()
scale_str = '0.25'
if len(vals) == 2:
scale_str, tex = vals
elif len(vals) > 2:
scale_str, tex, *opts = vals
else:
# Unpack to ensure it only has 1 section
[tex] = vals
scale = conv_float(scale_str, 0.25)
static = 'static' in opts
return AntTex(tex, scale, static)
def get_config(
prop_block: Property,
folder: str,
pak_id: str,
prop_name: str = 'config',
extension: str = '.cfg',
source: str = '',
) -> lazy_conf.LazyConf:
"""Lazily extract a config file referred to by the given property block.
Looks for the prop_name key in the given prop_block.
If the keyvalue has a value of "", an empty tree is returned.
If it has children, a copy of them will be returned.
Otherwise the value is a filename in the zip which will be parsed.
If source is supplied, set_cond_source() will be run.
"""
prop_block = prop_block.find_key(prop_name, "")
if prop_block.has_children():
prop = prop_block.copy()
prop.name = ""
return lazy_conf.raw_prop(prop, source=source)
if prop_block.value == '':
return lazy_conf.BLANK
# Zips must use '/' for the separator, even on Windows!
path = f'{folder}/{prop_block.value}'
if len(path) < 3 or path[-4] != '.':
# Add extension
path += extension
return lazy_conf.from_file(utils.PackagePath(pak_id, path), source=source)
def parse(prop: Property):
"""Parse from property values.
The value can be in four forms:
"prop" "material"
"prop" "<scale>|material"
"prop" "<scale>|material|static"
"prop"
{
"tex" "<mat>"
"scale" "<scale>"
"static" "<is_static>"
}
"""
if prop.has_children():
tex = prop['tex']
scale = prop.float('scale', 0.25)
static = prop.bool('static')
else:
vals = prop.value.split('|')
opts = ()
scale_str = '0.25'
if len(vals) == 2:
scale_str, tex = vals
elif len(vals) > 2:
scale_str, tex, *opts = vals
else:
# Unpack to ensure it only has 1 section
[tex] = vals
scale = conv_float(scale_str, 0.25)
static = 'static' in opts
return AntTex(tex, scale, static)
def make_static_pist_setup(res: Property):
instances = (
'bottom_0', 'bottom_1', 'bottom_2', 'bottom_3',
'logic_0', 'logic_1', 'logic_2', 'logic_3',
'static_0', 'static_1', 'static_2', 'static_3', 'static_4',
'grate_low', 'grate_high',
)
if res.has_children():
# Pull from config
return {
name: instanceLocs.resolve_one(
res[name, ''],
error=False,
) for name in instances
}
else:
# Pull from editoritems
if ':' in res.value:
from_item, prefix = res.value.split(':', 1)
else:
from_item = res.value
prefix = ''
return {
name: instanceLocs.resolve_one(
'<{}:bee2_{}{}>'.format(from_item, prefix, name),
error=False,
) for name in instances
}
def make_static_pist_setup(res: Property):
instances = (
'bottom_0', 'bottom_1', 'bottom_2', 'bottom_3',
'logic_0', 'logic_1', 'logic_2', 'logic_3',
'static_0', 'static_1', 'static_2', 'static_3', 'static_4',
'grate_low', 'grate_high',
)
if res.has_children():
# Pull from config
return {
name: instanceLocs.resolve_one(
res[name, ''],
error=False,
) for name in instances
}
else:
# Pull from editoritems
if ':' in res.value:
from_item, prefix = res.value.split(':', 1)
else:
from_item = res.value
prefix = ''
return {
name: instanceLocs.resolve_one(
'<{}:bee2_{}{}>'.format(from_item, prefix, name),
error=False,
) for name in instances
}
def write_sound(
file: StringIO,
snds: Property,
pack_list: PackList,
snd_prefix: str = '*',
) -> None:
"""Write either a single sound, or multiple rndsound.
snd_prefix is the prefix for each filename - *, #, @, etc.
"""
if snds.has_children():
file.write('"rndwave"\n\t{\n')
for snd in snds:
file.write('\t"wave" "{sndchar}{file}"\n'.format(
file=snd.value.lstrip(SOUND_CHARS),
sndchar=snd_prefix,
))
pack_list.pack_file('sound/' + snd.value.casefold())
file.write('\t}\n')
else:
file.write('"wave" "{sndchar}{file}"\n'.format(
file=snds.value.lstrip(SOUND_CHARS),
sndchar=snd_prefix,
))
pack_list.pack_file('sound/' + snds.value.casefold())
def flag_blockpos_type(inst: Entity, flag: Property):
"""Determine the type of a grid position.
If the value is single value, that should be the type.
Otherwise, the value should be a block with 'offset' and 'type' values.
The offset is in block increments, with 0 0 0 equal to the mounting surface.
If 'offset2' is also provided, all positions in the bounding box will
be checked.
The type should be a space-seperated list of locations:
* `VOID` (Outside the map)
* `SOLID` (Full wall cube)
* `EMBED` (Hollow wall cube)
* `AIR` (Inside the map, may be occupied by items)
* `OCCUPIED` (Known to be occupied by items)
* `PIT` (Bottomless pits, any)
* `PIT_SINGLE` (one-high)
* `PIT_TOP`
* `PIT_MID`
* `PIT_BOTTOM`
* `GOO`
* `GOO_SINGLE` (one-deep goo)
* `GOO_TOP` (goo surface)
* `GOO_MID`
* `GOO_BOTTOM` (floor)
"""
pos2 = None
if flag.has_children():
pos1 = resolve_offset(inst,
flag['offset', '0 0 0'],
scale=128,
zoff=-128)
types = flag['type'].split()
if 'offset2' in flag:
pos2 = resolve_offset(inst, flag.value, scale=128, zoff=-128)
else:
types = flag.value.split()
pos1 = Vec()
if pos2 is not None:
bbox = Vec.iter_grid(*Vec.bbox(pos1, pos2), stride=128)
else:
bbox = [pos1]
for pos in bbox:
block = brushLoc.POS['world':pos]
for block_type in types:
try:
allowed = brushLoc.BLOCK_LOOKUP[block_type.casefold()]
except KeyError:
raise ValueError(
'"{}" is not a valid block type!'.format(block_type))
if block in allowed:
break # To next position
else:
return False # Didn't match any in this list.
return True # Matched all positions.
def flag_blockpos_type(inst: Entity, flag: Property):
"""Determine the type of a grid position.
If the value is single value, that should be the type.
Otherwise, the value should be a block with 'offset' and 'type' values.
The offset is in block increments, with 0 0 0 equal to the mounting surface.
If 'offset2' is also provided, all positions in the bounding box will
be checked.
The type should be a space-seperated list of locations:
* `VOID` (Outside the map)
* `SOLID` (Full wall cube)
* `EMBED` (Hollow wall cube)
* `AIR` (Inside the map, may be occupied by items)
* `OCCUPIED` (Known to be occupied by items)
* `PIT` (Bottomless pits, any)
* `PIT_SINGLE` (one-high)
* `PIT_TOP`
* `PIT_MID`
* `PIT_BOTTOM`
* `GOO`
* `GOO_SINGLE` (one-deep goo)
* `GOO_TOP` (goo surface)
* `GOO_MID`
* `GOO_BOTTOM` (floor)
"""
pos2 = None
if flag.has_children():
pos1 = resolve_offset(inst, flag['offset', '0 0 0'], scale=128, zoff=-128)
types = flag['type'].split()
if 'offset2' in flag:
pos2 = resolve_offset(inst, flag.value, scale=128, zoff=-128)
else:
types = flag.value.split()
pos1 = Vec()
if pos2 is not None:
bbox = Vec.iter_grid(*Vec.bbox(pos1, pos2), stride=128)
else:
bbox = [pos1]
for pos in bbox:
block = brushLoc.POS['world': pos]
for block_type in types:
try:
allowed = brushLoc.BLOCK_LOOKUP[block_type.casefold()]
except KeyError:
raise ValueError('"{}" is not a valid block type!'.format(block_type))
if block in allowed:
break # To next position
else:
return False # Didn't match any in this list.
return True # Matched all positions.
def res_set_voice_attr(res: Property):
"""Sets a number of Voice Attributes.
Each child property will be set. The value is ignored, but must
be present for syntax reasons.
"""
if res.has_children():
for opt in res.value:
vbsp.settings['has_attr'][opt.name] = True
else:
vbsp.settings['has_attr'][res.value.casefold()] = True
return RES_EXHAUSTED
def res_pre_cache_model(vmf: VMF, res: Property) -> None:
"""Precache the given model for switching.
This places it as a `prop_dynamic_override`.
"""
if res.has_children():
model = res['model']
skins = [int(skin) for skin in res['skinset', ''].split()]
else:
model = res.value
skins = []
precache_model(vmf, model, skins)
def res_set_voice_attr(res: Property):
"""Sets a number of Voice Attributes.
Each child property will be set. The value is ignored, but must
be present for syntax reasons.
"""
if res.has_children():
for opt in res.value:
vbsp.settings['has_attr'][opt.name] = True
else:
vbsp.settings['has_attr'][res.value.casefold()] = 1
return RES_EXHAUSTED
def flag_random(inst: Entity, res: Property) -> bool:
"""Randomly is either true or false."""
if res.has_children():
chance = res['chance', '100']
seed = 'a' + res['seed', '']
else:
chance = res.value
seed = 'a'
# Allow ending with '%' sign
chance = srctools.conv_int(chance.rstrip('%'), 100)
set_random_seed(inst, seed)
return random.randrange(100) < chance
def flag_random(inst: Entity, res: Property) -> bool:
"""Randomly is either true or false."""
if res.has_children():
chance = res['chance', '100']
seed = 'a' + res['seed', '']
else:
chance = res.value
seed = 'a'
# Allow ending with '%' sign
chance = srctools.conv_int(chance.rstrip('%'), 100)
set_random_seed(inst, seed)
return random.randrange(100) < chance
def debug_flag(inst: Entity, props: Property):
"""Displays text when executed, for debugging conditions.
If the text ends with an '=', the instance will also be displayed.
As a flag, this always evaluates as true.
"""
# Mark as a warning so it's more easily seen.
if props.has_children():
LOGGER.warning('Debug:\n{!s}\n{!s}', props, inst)
else:
LOGGER.warning('Debug: {props}{inst!s}'.format(
inst=inst,
props=props.value,
))
return True # The flag is always true
def res_add_variant_setup(res: Property):
if res.has_children():
count = srctools.conv_int(res['Number', ''], None)
if count:
return conditions.weighted_random(
count,
res['weights', ''],
)
else:
return None
else:
count = srctools.conv_int(res.value, None)
if count:
return list(range(count))
else:
return None
def res_global_input_setup(res: Property):
if res.has_children():
name = res['name', '']
inp_name, inp_command = Output.parse_name(res['input'])
return name, Output(
out=res['output', 'OnTrigger'],
targ=res['target', ''],
inp=inp_command,
inst_in=inp_name,
delay=srctools.conv_float(res['delay', '']),
param=res['param', ''],
)
else:
out = Output.parse(res)
out.output = '' # Don't need to store GlobalInput...
return '', out
def res_add_inst_var(inst: Entity, res: Property):
"""Append the value of an instance variable to the filename.
Pass either the variable name, or a set of value->suffix pairs for a
lookup.
"""
if res.has_children():
val = inst.fixup[res['variable', '']]
for rep in res: # lookup the number to determine the appending value
if rep.name == 'variable':
continue # this isn't a lookup command!
if rep.name == val:
conditions.add_suffix(inst, '_' + rep.value)
break
else: # append the value
conditions.add_suffix(inst, '_' + inst.fixup[res.value, ''])
def res_add_variant_setup(res: Property) -> object:
if res.has_children():
count = srctools.conv_int(res['Number', ''], None)
if count:
return conditions.weighted_random(
count,
res['weights', ''],
)
else:
return None
else:
count = srctools.conv_int(res.value, None)
if count:
return list(range(count))
else:
return None
def res_global_input_setup(res: Property):
if res.has_children():
name = res['name', '']
inp_name, inp_command = Output.parse_name(res['input'])
return name, Output(
out=res['output', 'OnTrigger'],
targ=res['target', ''],
inp=inp_command,
inst_in=inp_name,
delay=srctools.conv_float(res['delay', '']),
param=res['param', ''],
)
else:
out = Output.parse(res)
out.output = '' # Don't need to store GlobalInput...
return '', out
def res_add_inst_var(inst: Entity, res: Property):
"""Append the value of an instance variable to the filename.
Pass either the variable name, or a set of value->suffix pairs for a
lookup.
"""
if res.has_children():
val = inst.fixup[res['variable', '']]
for rep in res: # lookup the number to determine the appending value
if rep.name == 'variable':
continue # this isn't a lookup command!
if rep.name == val:
conditions.add_suffix(inst, '_' + rep.value)
break
else: # append the value
conditions.add_suffix(inst, '_' + inst.fixup[res.value, ''])
def flag_random(res: Property) -> Callable[[Entity], bool]:
"""Randomly is either true or false."""
if res.has_children():
chance = res['chance', '100']
seed = res['seed', '']
else:
chance = res.value
seed = ''
# Allow ending with '%' sign
chance = srctools.conv_int(chance.rstrip('%'), 100)
def rand_func(inst: Entity) -> bool:
"""Apply the random chance."""
return rand.seed(b'rand_flag', inst, seed).randrange(100) < chance
return rand_func
def res_calc_opposite_wall_dist(inst: Entity, res: Property):
"""Calculate the distance between this item and the opposing wall.
The value is stored in the `$var` specified by the property value.
Alternately it is set by `ResultVar`, and `offset` adds or subtracts to the value.
`GooCollide` means that it will stop when goo is found, otherwise it is
ignored.
`GooAdjust` means additionally if the space is goo, the distance will
be modified so that it specifies the surface of the goo.
"""
if res.has_children():
result_var = res['ResultVar']
dist_off = res.float('offset')
collide_goo = res.bool('GooCollide')
adjust_goo = res.bool('GooAdjust')
else:
result_var = res.value
dist_off = 0
collide_goo = adjust_goo = False
origin = Vec.from_str(inst['origin'])
normal = Vec(z=1).rotate_by_str(inst['angles'])
mask = [
brushLoc.Block.SOLID,
brushLoc.Block.EMBED,
brushLoc.Block.PIT_BOTTOM,
brushLoc.Block.PIT_SINGLE,
]
# Only if actually downward.
if normal == (0, 0, -1) and collide_goo:
mask.append(brushLoc.Block.GOO_TOP)
mask.append(brushLoc.Block.GOO_SINGLE)
opposing_pos = brushLoc.POS.raycast_world(
origin,
normal,
mask,
)
if adjust_goo and brushLoc.POS['world':opposing_pos + 128 * normal].is_goo:
# If the top is goo, adjust so the 64 below is the top of the goo.
dist_off += 32
inst.fixup[result_var] = (origin - opposing_pos).mag() + dist_off
def res_calc_opposite_wall_dist(inst: Entity, res: Property):
"""Calculate the distance between this item and the opposing wall.
The value is stored in the `$var` specified by the property value.
Alternately it is set by `ResultVar`, and `offset` adds or subtracts to the value.
`GooCollide` means that it will stop when goo is found, otherwise it is
ignored.
`GooAdjust` means additionally if the space is goo, the distance will
be modified so that it specifies the surface of the goo.
"""
if res.has_children():
result_var = res['ResultVar']
dist_off = res.float('offset')
collide_goo = res.bool('GooCollide')
adjust_goo = res.bool('GooAdjust')
else:
result_var = res.value
dist_off = 0
collide_goo = adjust_goo = False
origin = Vec.from_str(inst['origin'])
normal = Vec(z=1).rotate_by_str(inst['angles'])
mask = [
brushLoc.Block.SOLID,
brushLoc.Block.EMBED,
brushLoc.Block.PIT_BOTTOM,
brushLoc.Block.PIT_SINGLE,
]
# Only if actually downward.
if normal == (0, 0, -1) and collide_goo:
mask.append(brushLoc.Block.GOO_TOP)
mask.append(brushLoc.Block.GOO_SINGLE)
opposing_pos = brushLoc.POS.raycast_world(
origin,
normal,
mask,
)
if adjust_goo and brushLoc.POS['world': opposing_pos + 128*normal].is_goo:
# If the top is goo, adjust so the 64 below is the top of the goo.
dist_off += 32
inst.fixup[result_var] = (origin - opposing_pos).mag() + dist_off
def flag_blockpos_type(inst: Entity, flag: Property):
"""Determine the type of a grid position.
If the value is single value, that should be the type.
Otherwise, the value should be a block with 'offset' and 'type' values.
The offset is in block increments, with 0 0 0 equal to the mounting surface.
The type should be a space-seperated list of locations:
* VOID (Outside the map)
* SOLID (Full wall cube)
* EMBED (Hollow wall cube)
* AIR (Inside the map, may be occupied by items)
* OCCUPIED (Known to be occupied by items)
* PIT (Bottomless pits, any)
* PIT_SINGLE (one-high)
* PIT_TOP
* PIT_MID
* PIT_BOTTOM
* GOO
* GOO_SINGLE (one-deep goo)
* GOO_TOP (goo surface)
* GOO_MID
* GOO_BOTTOM (floor)
"""
if flag.has_children():
pos = flag.vec('offset') * 128
types = flag['type'].split()
else:
types = flag.value.split()
pos = Vec()
pos.z -= 128
pos.localise(
Vec.from_str(inst['origin']),
Vec.from_str(inst['angles']),
)
block = brushLoc.POS['world':pos]
for block_type in types:
try:
allowed = brushLoc.BLOCK_LOOKUP[block_type.casefold()]
except KeyError:
raise ValueError(
'"{}" is not a valid block type!'.format(block_type))
if block in allowed:
return True
return False
def flag_angles(flag: Property) -> Callable[[Entity], bool]:
"""Check that a instance is pointed in a direction.
The value should be either just the angle to check, or a block of
options:
- `direction`: A unit vector (XYZ value) pointing in a direction, or some
keywords: `+z`, `-y`, `N`/`S`/`E`/`W`, `up`/`down`, `floor`/`ceiling`, or `walls` for any wall side.
- `From_dir`: The direction the unrotated instance is pointed in.
This lets the flag check multiple directions.
- `Allow_inverse`: If true, this also returns True if the instance is
pointed the opposite direction .
"""
if flag.has_children():
targ_angle = flag['direction', '0 0 0']
from_dir = flag['from_dir', '0 0 1']
if from_dir.casefold() in DIRECTIONS:
from_dir = Vec(DIRECTIONS[from_dir.casefold()])
else:
from_dir = Vec.from_str(from_dir, 0, 0, 1)
allow_inverse = flag.bool('allow_inverse')
else:
targ_angle = flag.value
from_dir = Vec(0, 0, 1)
allow_inverse = False
try:
normal = DIRECTIONS[targ_angle.casefold()]
except KeyError:
normal = Vec.from_str(targ_angle)
def check_orient(inst: Entity) -> bool:
"""Check the orientation against the instance."""
inst_normal = from_dir @ Angle.from_str(inst['angles'])
if normal == 'WALL':
# Special case - it's not on the floor or ceiling
return abs(inst_normal.z) < 1e-6
else:
return inst_normal == normal or (
allow_inverse and -inst_normal == normal
)
return check_orient
def debug_flag(inst: Entity, props: Property):
"""Displays text when executed, for debugging conditions.
If the text ends with an '=', the instance will also be displayed.
As a flag, this always evaluates as true.
"""
# Mark as a warning so it's more easily seen.
if props.has_children():
LOGGER.warning('Debug:')
LOGGER.warning(str(props))
LOGGER.warning(str(inst))
elif props.value.strip().endswith('='):
LOGGER.warning('Debug: {props}{inst!s}'.format(
inst=inst,
props=props.value,
))
else:
LOGGER.warning('Debug: ' + props.value)
return True # The flag is always true
def flag_random(inst: Entity, res: Property):
"""Randomly is either true or false."""
if res.has_children():
chance = res['chance', '100']
seed = res['seed', '']
else:
chance = res.value
seed = ''
# Allow ending with '%' sign
chance = srctools.conv_int(chance.rstrip('%'), 100)
random.seed('random_chance_{}:{}_{}_{}'.format(
seed,
inst['targetname', ''],
inst['origin'],
inst['angles'],
))
return random.randrange(100) < chance
def res_global_input_setup(res: Property) -> tuple[str, Output]:
"""Pre-parse the global input."""
if res.has_children():
name = res['name', '']
if not name and res.bool('alsoonload'):
name = ON_LOAD
inp_name, inp_command = Output.parse_name(res['input'])
return name, Output(
out=res['output', 'OnTrigger'],
targ=res['target', ''],
inp=inp_command,
inst_in=inp_name,
delay=srctools.conv_float(res['delay', '']),
param=res['param', ''],
)
else:
out = Output.parse(res)
out.output = '' # Don't need to store GlobalInput...
return '', out
def res_add_global_inst(vmf: VMF, res: Property):
"""Add one instance in a specific location.
Options:
- `allow_multiple`: Allow multiple copies of this instance. If 0, the
instance will not be added if it was already added.
- `name`: The targetname of the instance. If blank, the instance will
be given a name of the form `inst_1234`.
- `file`: The filename for the instance.
- `angles`: The orientation of the instance (defaults to `0 0 0`).
- `fixup_style`: The Fixup style for the instance. `0` (default) is
Prefix, `1` is Suffix, and `2` is None.
- `position`: The location of the instance. If not set, it will be placed
in a 128x128 nodraw room somewhere in the map. Objects which can
interact with nearby object should not be placed there.
"""
if not res.has_children():
res = Property('AddGlobal', [Property('File', res.value)])
file = instanceLocs.resolve_one(res['file'], error=True)
if res.bool('allow_multiple') or file.casefold() not in conditions.GLOBAL_INSTANCES:
# By default we will skip adding the instance
# if was already added - this is helpful for
# items that add to original items, or to avoid
# bugs.
new_inst = vmf.create_ent(
classname="func_instance",
targetname=res['name', ''],
file=file,
angles=res['angles', '0 0 0'],
fixup_style=res['fixup_style', '0'],
)
try:
new_inst['origin'] = res['position']
except IndexError:
new_inst['origin'] = options.get(Vec, 'global_ents_loc')
conditions.GLOBAL_INSTANCES.add(file.casefold())
conditions.ALL_INST.add(file.casefold())
if new_inst['targetname'] == '':
new_inst['targetname'] = "inst_"
new_inst.make_unique()
return conditions.RES_EXHAUSTED
def res_add_variant(res: Property):
"""This allows using a random instance from a weighted group.
A suffix will be added in the form `_var4`.
Two or three properties should be given:
- `Number`: The number of random instances.
- `Weights`: A comma-separated list of weights for each instance.
- `seed`: Optional seed to disambiuate multiple options.
Any variant has a chance of weight/sum(weights) of being chosen:
A weight of `2, 1, 1` means the first instance has a 2/4 chance of
being chosen, and the other 2 have a 1/4 chance of being chosen.
The chosen variant depends on the position, direction and name of
the instance.
Alternatively, you can use `"variant" "number"` to choose from
equally-weighted options.
"""
if res.has_children():
count_val = res['Number'] # or raise an error
try:
count = int(count_val)
except (TypeError, ValueError):
raise ValueError(f'Invalid variant count {count_val}!')
weighting = rand.parse_weights(count, res['weights', ''])
seed = res['seed', '']
else:
try:
count = int(res.value)
except (TypeError, ValueError):
raise ValueError(f'Invalid variant count {res.value!r}!')
else:
weighting = list(range(count))
seed = res.value
def apply_variant(inst: Entity) -> None:
"""Apply the variant."""
rng = rand.seed(b'variant', inst, seed)
conditions.add_suffix(inst, f"_var{rng.choice(weighting) + 1}")
return apply_variant
def flag_angles(inst: Entity, flag: Property):
"""Check that a instance is pointed in a direction.
The value should be either just the angle to check, or a block of
options:
- `direction`: A unit vector (XYZ value) pointing in a direction, or some
keywords: `+z`, `-y`, `N`/`S`/`E`/`W`, `up`/`down`, `floor`/`ceiling`, or `walls` for any wall side.
- `From_dir`: The direction the unrotated instance is pointed in.
This lets the flag check multiple directions.
- `Allow_inverse`: If true, this also returns True if the instance is
pointed the opposite direction .
"""
angle = inst['angles', '0 0 0']
if flag.has_children():
targ_angle = flag['direction', '0 0 0']
from_dir = flag['from_dir', '0 0 1']
if from_dir.casefold() in DIRECTIONS:
from_dir = Vec(DIRECTIONS[from_dir.casefold()])
else:
from_dir = Vec.from_str(from_dir, 0, 0, 1)
allow_inverse = flag.bool('allow_inverse')
else:
targ_angle = flag.value
from_dir = Vec(0, 0, 1)
allow_inverse = False
normal = DIRECTIONS.get(targ_angle.casefold(), None)
if normal is None:
return False # If it's not a special angle,
# so it failed the exact match
inst_normal = from_dir.rotate_by_str(angle)
if normal == 'WALL':
# Special case - it's not on the floor or ceiling
return not (inst_normal == (0, 0, 1) or inst_normal == (0, 0, -1))
else:
return inst_normal == normal or (allow_inverse
and -inst_normal == normal)
def flag_angles(inst: Entity, flag: Property):
"""Check that a instance is pointed in a direction.
The value should be either just the angle to check, or a block of
options:
- `Angle`: A unit vector (XYZ value) pointing in a direction, or some
keywords: `+z`, `-y`, `N`/`S`/`E`/`W`, `up`/`down`, `floor`/`ceiling`, or `walls` for any wall side.
- `From_dir`: The direction the unrotated instance is pointed in.
This lets the flag check multiple directions
- `Allow_inverse`: If true, this also returns True if the instance is
pointed the opposite direction .
"""
angle = inst['angles', '0 0 0']
if flag.has_children():
targ_angle = flag['direction', '0 0 0']
from_dir = flag['from_dir', '0 0 1']
if from_dir.casefold() in DIRECTIONS:
from_dir = Vec(DIRECTIONS[from_dir.casefold()])
else:
from_dir = Vec.from_str(from_dir, 0, 0, 1)
allow_inverse = srctools.conv_bool(flag['allow_inverse', '0'])
else:
targ_angle = flag.value
from_dir = Vec(0, 0, 1)
allow_inverse = False
normal = DIRECTIONS.get(targ_angle.casefold(), None)
if normal is None:
return False # If it's not a special angle,
# so it failed the exact match
inst_normal = from_dir.rotate_by_str(angle)
if normal == 'WALL':
# Special case - it's not on the floor or ceiling
return not (inst_normal == (0, 0, 1) or inst_normal == (0, 0, -1))
else:
return inst_normal == normal or (
allow_inverse and -inst_normal == normal
)
def res_locking_output(inst: Entity, res: Property):
"""Marks an output item for locked connections.
The parameter is an `instance:name;Output` value, which is fired when the
item resets. This must be executed before `LockingIO`.
This only applies if `$connectioncount` is 1.
"""
# Items with more than one connection have AND logic in the mix - it makes
# it unsafe to lock the input item.
if inst.fixup['$connectioncount'] != '1':
return
if res.has_children():
name, output = Output.parse_name(res['output'])
relay_name = res['rl_name', None]
else:
name, output = Output.parse_name(res.value)
relay_name = None
LOCKABLE_ITEMS[inst['targetname']] = inst, name, output, relay_name
def flag_angles(inst: Entity, flag: Property):
"""Check that a instance is pointed in a direction.
The value should be either just the angle to check, or a block of
options:
- Angle: A unit vector (XYZ value) pointing in a direction, or some
keywords: +z, -y, N/S/E/W, up/down, floor/ceiling, or walls
- From_dir: The direction the unrotated instance is pointed in.
This lets the flag check multiple directions
- Allow_inverse: If true, this also returns True if the instance is
pointed the opposite direction .
"""
angle = inst['angles', '0 0 0']
if flag.has_children():
targ_angle = flag['direction', '0 0 0']
from_dir = flag['from_dir', '0 0 1']
if from_dir.casefold() in DIRECTIONS:
from_dir = Vec(DIRECTIONS[from_dir.casefold()])
else:
from_dir = Vec.from_str(from_dir, 0, 0, 1)
allow_inverse = srctools.conv_bool(flag['allow_inverse', '0'])
else:
targ_angle = flag.value
from_dir = Vec(0, 0, 1)
allow_inverse = False
normal = DIRECTIONS.get(targ_angle.casefold(), None)
if normal is None:
return False # If it's not a special angle,
# so it failed the exact match
inst_normal = from_dir.rotate_by_str(angle)
if normal == 'WALL':
# Special case - it's not on the floor or ceiling
return not (inst_normal == (0, 0, 1) or inst_normal == (0, 0, -1))
else:
return inst_normal == normal or (allow_inverse
and -inst_normal == normal)
def res_add_global_inst(res: Property):
"""Add one instance in a specific location.
Options:
`allow_multiple`: Allow multiple copies of this instance. If 0, the
instance will not be added if it was already added.
`name`: The targetname of the instance. If blank, the instance will
be given a name of the form `inst_1234`.
`file`: The filename for the instance.
`angles`: The orientation of the instance (defaults to `0 0 0`).
`fixup_style`: The Fixup style for the instance. `0` (default) is
Prefix, `1` is Suffix, and `2` is None.
`position`: The location of the instance. If not set, it will be placed
in a 128x128 nodraw room somewhere in the map. Objects which can
interact with nearby object should not be placed there.
"""
if not res.has_children():
res = Property('AddGlobal', [Property('File', res.value)])
if res.bool('allow_multiple') or res['file'] not in GLOBAL_INSTANCES:
# By default we will skip adding the instance
# if was already added - this is helpful for
# items that add to original items, or to avoid
# bugs.
new_inst = vbsp.VMF.create_ent(
classname="func_instance",
targetname=res['name', ''],
file=instanceLocs.resolve_one(res['file'], error=True),
angles=res['angles', '0 0 0'],
fixup_style=res['fixup_style', '0'],
)
try:
new_inst['origin'] = res['position']
except IndexError:
new_inst['origin'] = vbsp_options.get(Vec, 'global_ents_loc')
GLOBAL_INSTANCES.add(res['file'])
if new_inst['targetname'] == '':
new_inst['targetname'] = "inst_"
new_inst.make_unique()
return RES_EXHAUSTED
def res_add_global_inst(res: Property):
"""Add one instance in a specific location.
Options:
allow_multiple: Allow multiple copies of this instance. If 0, the
instance will not be added if it was already added.
name: The targetname of the instance. IF blank, the instance will
be given a name of the form 'inst_1234'.
file: The filename for the instance.
Angles: The orientation of the instance (defaults to '0 0 0').
Fixup_style: The Fixup style for the instance. '0' (default) is
Prefix, '1' is Suffix, and '2' is None.
Position: The location of the instance. If not set, it will be placed
in a 128x128 nodraw room somewhere in the map. Objects which can
interact with nearby object should not be placed there.
"""
if not res.has_children():
res = Property('AddGlobal', [Property('File', res.value)])
if res.bool('allow_multiple') or res['file'] not in GLOBAL_INSTANCES:
# By default we will skip adding the instance
# if was already added - this is helpful for
# items that add to original items, or to avoid
# bugs.
new_inst = vbsp.VMF.create_ent(
classname="func_instance",
targetname=res['name', ''],
file=instanceLocs.resolve_one(res['file'], error=True),
angles=res['angles', '0 0 0'],
fixup_style=res['fixup_style', '0'],
)
try:
new_inst['origin'] = res['position']
except IndexError:
new_inst['origin'] = vbsp_options.get(Vec, 'global_ents_loc')
GLOBAL_INSTANCES.add(res['file'])
if new_inst['targetname'] == '':
new_inst['targetname'] = "inst_"
new_inst.make_unique()
return RES_EXHAUSTED
def get_config(
prop_block: Property,
fsys: FileSystem,
folder: str,
pak_id='',
prop_name='config',
extension='.cfg',
):
"""Extract a config file referred to by the given property block.
Looks for the prop_name key in the given prop_block.
If the keyvalue has a value of "", an empty tree is returned.
If it has children, a copy of them is returned.
Otherwise the value is a filename in the zip which will be parsed.
"""
prop_block = prop_block.find_key(prop_name, "")
if prop_block.has_children():
prop = prop_block.copy()
prop.name = None
return prop
if prop_block.value == '':
return Property(None, [])
# Zips must use '/' for the separator, even on Windows!
path = folder + '/' + prop_block.value
if len(path) < 3 or path[-4] != '.':
# Add extension
path += extension
try:
return fsys.read_prop(path)
except FileNotFoundError:
LOGGER.warning('"{id}:{path}" not in zip!', id=pak_id, path=path)
return Property(None, [])
except UnicodeDecodeError:
LOGGER.exception('Unable to read "{id}:{path}"', id=pak_id, path=path)
raise
def parse(
cls: Type[Handle],
prop: Property,
pack: str,
width: int,
height: int,
*,
subkey: str='',
subfolder: str='',
) -> Handle:
"""Parse a property into an image handle.
If a package isn't specified, the given package will be used.
Optionally, 'subkey' can be used to specifiy that the property is a subkey.
An error icon will then be produced automatically.
If subfolder is specified, files will be relative to this folder.
The width/height may be zero to indicate it should not be resized.
"""
if subkey:
try:
prop = prop.find_key(subkey)
except LookupError:
return cls.error(width, height)
if prop.has_children():
children = []
for child in prop:
if child.name not in ('image', 'img', 'layer'):
raise ValueError(f'Unknown compound type "{child}"!')
children.append(cls.parse(
child, pack,
width, height,
subfolder=subfolder
))
return cls.composite(children, width, height)
return cls.parse_uri(utils.PackagePath.parse(prop.value, pack), width, height, subfolder=subfolder)
def res_add_overlay_inst(inst: Entity, res: Property):
"""Add another instance on top of this one.
If a single value, this sets only the filename.
Values:
`file`: The filename.
`fixup_style`: The Fixup style for the instance. '0' (default) is
Prefix, '1' is Suffix, and '2' is None.
`copy_fixup`: If true, all the $replace values from the original
instance will be copied over.
`move_outputs`: If true, outputs will be moved to this instance.
`offset`: The offset (relative to the base) that the instance
will be placed. Can be set to '<piston_top>' and
'<piston_bottom>' to offset based on the configuration.
'<piston_start>' will set it to the starting position, and
'<piston_end>' will set it to the ending position.
of piston platform handles.
`angles`: If set, overrides the base instance angles. This does
not affect the offset property.
`fixup`/`localfixup`: Keyvalues in this block will be copied to the
overlay entity.
If the value starts with $, the variable will be copied over.
If this is present, copy_fixup will be disabled.
"""
if not res.has_children():
# Use all the defaults.
res = Property('AddOverlay', [
Property('File', res.value)
])
angle = res['angles', inst['angles', '0 0 0']]
orig_name = conditions.resolve_value(inst, res['file', ''])
filename = instanceLocs.resolve_one(orig_name)
if not filename:
if not res.bool('silentLookup'):
LOGGER.warning('Bad filename for "{}" when adding overlay!', orig_name)
# Don't bother making a overlay which will be deleted.
return
overlay_inst = vbsp.VMF.create_ent(
classname='func_instance',
targetname=inst['targetname', ''],
file=filename,
angles=angle,
origin=inst['origin'],
fixup_style=res['fixup_style', '0'],
)
# Don't run if the fixup block exists..
if srctools.conv_bool(res['copy_fixup', '1']):
if 'fixup' not in res and 'localfixup' not in res:
# Copy the fixup values across from the original instance
for fixup, value in inst.fixup.items():
overlay_inst.fixup[fixup] = value
conditions.set_ent_keys(overlay_inst.fixup, inst, res, 'fixup')
if res.bool('move_outputs', False):
overlay_inst.outputs = inst.outputs
inst.outputs = []
if 'offset' in res:
overlay_inst['origin'] = conditions.resolve_offset(inst, res['offset'])
return overlay_inst
def res_add_overlay_inst(inst: Entity, res: Property):
"""Add another instance on top of this one.
If a single value, this sets only the filename.
Values:
`file`: The filename.
`fixup_style`: The Fixup style for the instance. '0' (default) is
Prefix, '1' is Suffix, and '2' is None.
`copy_fixup`: If true, all the $replace values from the original
instance will be copied over.
`move_outputs`: If true, outputs will be moved to this instance.
`offset`: The offset (relative to the base) that the instance
will be placed. Can be set to '<piston_top>' and
'<piston_bottom>' to offset based on the configuration.
'<piston_start>' will set it to the starting position, and
'<piston_end>' will set it to the ending position.
of piston platform handles.
`angles`: If set, overrides the base instance angles. This does
not affect the offset property.
`fixup`/`localfixup`: Keyvalues in this block will be copied to the
overlay entity.
If the value starts with $, the variable will be copied over.
If this is present, copy_fixup will be disabled.
"""
if not res.has_children():
# Use all the defaults.
res = Property('AddOverlay', [Property('File', res.value)])
angle = res['angles', inst['angles', '0 0 0']]
orig_name = conditions.resolve_value(inst, res['file', ''])
filename = instanceLocs.resolve_one(orig_name)
if not filename:
if not res.bool('silentLookup'):
LOGGER.warning('Bad filename for "{}" when adding overlay!',
orig_name)
# Don't bother making a overlay which will be deleted.
return
overlay_inst = vbsp.VMF.create_ent(
classname='func_instance',
targetname=inst['targetname', ''],
file=filename,
angles=angle,
origin=inst['origin'],
fixup_style=res['fixup_style', '0'],
)
# Don't run if the fixup block exists..
if srctools.conv_bool(res['copy_fixup', '1']):
if 'fixup' not in res and 'localfixup' not in res:
# Copy the fixup values across from the original instance
for fixup, value in inst.fixup.items():
overlay_inst.fixup[fixup] = value
conditions.set_ent_keys(overlay_inst.fixup, inst, res, 'fixup')
if res.bool('move_outputs', False):
overlay_inst.outputs = inst.outputs
inst.outputs = []
if 'offset' in res:
overlay_inst['origin'] = conditions.resolve_offset(inst, res['offset'])
return overlay_inst
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_overlay_inst(vmf: VMF, inst: Entity,
res: Property) -> Optional[Entity]:
"""Add another instance on top of this one.
If a single value, this sets only the filename.
Values:
- `file`: The filename.
- `fixup_style`: The Fixup style for the instance. '0' (default) is
Prefix, '1' is Suffix, and '2' is None.
- `copy_fixup`: If true, all the `$replace` values from the original
instance will be copied over.
- `move_outputs`: If true, outputs will be moved to this instance.
- `offset`: The offset (relative to the base) that the instance
will be placed. Can be set to `<piston_top>` and
`<piston_bottom>` to offset based on the configuration.
`<piston_start>` will set it to the starting position, and
`<piston_end>` will set it to the ending position of the Piston
Platform's handles.
- `rotation`: Rotate the instance by this amount.
- `angles`: If set, overrides `rotation` and the instance angles entirely.
- `fixup`/`localfixup`: Keyvalues in this block will be copied to the
overlay entity.
- If the value starts with `$`, the variable will be copied over.
- If this is present, `copy_fixup` will be disabled.
"""
if not res.has_children():
# Use all the defaults.
res = Property('AddOverlay', [Property('File', res.value)])
if 'angles' in res:
angles = Angle.from_str(res['angles'])
if 'rotation' in res:
LOGGER.warning('"angles" option overrides "rotation"!')
else:
angles = Angle.from_str(res['rotation', '0 0 0'])
angles @= Angle.from_str(inst['angles', '0 0 0'])
orig_name = conditions.resolve_value(inst, res['file', ''])
filename = instanceLocs.resolve_one(orig_name)
if not filename:
if not res.bool('silentLookup'):
LOGGER.warning('Bad filename for "{}" when adding overlay!',
orig_name)
# Don't bother making a overlay which will be deleted.
return None
overlay_inst = vmf.create_ent(
classname='func_instance',
targetname=inst['targetname', ''],
file=filename,
angles=angles,
origin=inst['origin'],
fixup_style=res['fixup_style', '0'],
)
# Don't run if the fixup block exists..
if srctools.conv_bool(res['copy_fixup', '1']):
if 'fixup' not in res and 'localfixup' not in res:
# Copy the fixup values across from the original instance
for fixup, value in inst.fixup.items():
overlay_inst.fixup[fixup] = value
conditions.set_ent_keys(overlay_inst.fixup, inst, res, 'fixup')
if res.bool('move_outputs', False):
overlay_inst.outputs = inst.outputs
inst.outputs = []
if 'offset' in res:
overlay_inst['origin'] = conditions.resolve_offset(inst, res['offset'])
return overlay_inst
def load_config(conf: Property):
"""Setup all the generators from the config data."""
global SPECIAL, OVERLAYS
global_options = {
prop.name: prop.value
for prop in conf.find_children('Options')
}
# Give generators access to the global settings.
Generator.global_settings.update(
parse_options(
# Pass it to both, the second will fail too.
global_options,
global_options,
))
data: Dict[Any, Tuple[Dict[str, Any], Dict[str, List[str]]]] = {}
gen_cat: GenCat
gen_orient: Optional[Orient]
gen_portal: Optional[Portalable]
# Use this to allow alternate names for generators.
conf_for_gen: Dict[Tuple[GenCat, Optional[Orient], Optional[Portalable]],
Property, ] = {}
for prop in conf:
if prop.name in ('options', 'antlines'):
continue
if '.' in prop.name:
try:
gen_cat_name, gen_portal_raw, gen_orient_raw = prop.name.split(
'.')
gen_cat = GEN_CATS[gen_cat_name]
gen_orient = ORIENTS[gen_orient_raw]
gen_portal = Portalable(gen_portal_raw)
except (KeyError, ValueError):
LOGGER.warning('Could not parse texture generator type "{}"!',
prop.name)
continue
conf_for_gen[gen_cat, gen_orient, gen_portal] = prop
else:
try:
gen_cat = GEN_CATS[prop.name]
except KeyError:
LOGGER.warning('Unknown texture generator type "{}"!',
prop.name)
continue
conf_for_gen[gen_cat, None, None] = prop
for gen_key, tex_defaults in TEX_DEFAULTS.items():
if isinstance(gen_key, GenCat):
# It's a non-tile generator.
is_tile = False
gen_cat = gen_key
try:
gen_conf = conf_for_gen[gen_key, None, None]
except KeyError:
gen_conf = Property(gen_key.value, [])
else:
# Tile-type generator
is_tile = True
try:
gen_conf = conf_for_gen[gen_key]
except KeyError:
gen_conf = Property('', [])
if not gen_conf.has_children():
# Special case - using a single value to indicate that all
# textures are the same.
gen_conf = Property(
gen_conf.real_name,
[
Property('4x4', gen_conf.value),
Property(
'Options',
[
# Clumping isn't useful since it's all the same.
Property('Algorithm', 'RAND'),
])
])
textures = {}
# First parse the options.
options = parse_options(
{
prop.name: prop.value
for prop in gen_conf.find_children('Options')
}, global_options)
# Now do textures.
if is_tile:
# Tile generator, always have all tile sizes, and
# only use the defaults if no textures were specified.
for tex_name in TileSize:
textures[tex_name] = [
prop.value for prop in gen_conf.find_all(str(tex_name))
]
# In case someone switches them around, add on 2x1 to 1x2 textures.
textures[TileSize.TILE_2x1] += [
prop.value for prop in gen_conf.find_all('1x2')
]
if not any(textures.values()):
for tex_name, tex_default in tex_defaults.items():
textures[tex_name] = [tex_default]
else:
# Non-tile generator, use defaults for each value
for tex_name, tex_default in tex_defaults.items():
textures[tex_name] = tex = [
prop.value for prop in gen_conf.find_all(str(tex_name))
]
if not tex and tex_default:
tex.append(tex_default)
data[gen_key] = options, textures
# Next, do a check to see if any texture names were specified that
# we don't recognise.
extra_keys = {prop.name for prop in gen_conf}
extra_keys.discard('options') # Not a texture name, but valid.
if isinstance(gen_key, GenCat):
extra_keys.difference_update(map(str.casefold,
tex_defaults.keys()))
else:
# The defaults are just the size values.
extra_keys.difference_update(map(str, TileSize))
if extra_keys:
LOGGER.warning('{}: Unknown texture names {}',
format_gen_key(gen_key),
', '.join(sorted(extra_keys)))
# Now complete textures for tile types,
# copying over data from other generators.
for gen_key, tex_defaults in TEX_DEFAULTS.items():
if isinstance(gen_key, GenCat):
continue
gen_cat, gen_orient, gen_portal = gen_key
options, textures = data[gen_key]
if not any(textures.values()) and gen_cat is not GenCat.NORMAL:
# For the additional categories of tiles, we copy the entire
# NORMAL one over if it's not set.
textures.update(data[GenCat.NORMAL, gen_orient, gen_portal][1])
if not textures[TileSize.TILE_4x4]:
raise ValueError('No 4x4 tile set for "{}"!'.format(gen_key))
# Copy 4x4, 2x2, 2x1 textures to the 1x1 size if the option was set.
# Do it before inheriting tiles, so there won't be duplicates.
if options['mixtiles']:
block_tex = textures[TileSize.TILE_1x1]
block_tex += textures[TileSize.TILE_4x4]
block_tex += textures[TileSize.TILE_2x2]
block_tex += textures[TileSize.TILE_2x1]
# We need to do more processing.
for orig, targ in TILE_INHERIT:
if not textures[targ]:
textures[targ] = textures[orig].copy()
# Now finally create the generators.
for gen_key, tex_defaults in TEX_DEFAULTS.items():
options, textures = data[gen_key]
if isinstance(gen_key, tuple):
# Check the algorithm to use.
algo = options['algorithm']
gen_cat, gen_orient, gen_portal = gen_key
try:
generator: Type[Generator] = GEN_CLASSES[algo] # type: ignore
except KeyError:
raise ValueError('Invalid algorithm "{}" for {}!'.format(
algo, gen_key))
else:
# Signage, Overlays always use the Random generator.
generator = GenRandom
gen_cat = gen_key
gen_orient = gen_portal = None
GENERATORS[gen_key] = gen = generator(gen_cat, gen_orient, gen_portal,
options, textures)
# Allow it to use the default enums as direct lookups.
if isinstance(gen, GenRandom):
if gen_portal is None:
gen.set_enum(tex_defaults.items())
else:
# Tiles always use TileSize.
gen.set_enum((size.value, size) for size in TileSize)
SPECIAL = GENERATORS[GenCat.SPECIAL]
OVERLAYS = GENERATORS[GenCat.OVERLAYS]