def load_conf(prop_block: Property):
"""Read the config and build our dictionaries."""
global INST_SPECIAL
# Extra definitions: key -> filename.
# Make sure to do this first, so numbered instances are set in
# ITEM_FOR_FILE.
for prop in prop_block.find_key('CustInstances', []):
CUST_INST_FILES[prop.name] = special_inst = {}
for inst in prop:
file = inst.value.casefold()
special_inst[inst.name] = file
ITEM_FOR_FILE[file] = (prop.name, inst.name)
# Normal instances: index -> filename
for prop in prop_block.find_key('Allinstances', []):
INSTANCE_FILES[prop.name] = inst_list = []
for ind, inst in enumerate(prop):
file = inst.value.casefold()
inst_list.append(file)
ITEM_FOR_FILE[file] = (prop.name, ind)
INST_SPECIAL = {
key.casefold(): resolve(val_string, silent=True)
for key, val_string in SPECIAL_INST.items()
}
def set_ent_keys(
ent: Entity,
inst: Entity,
prop_block: Property,
block_name: str='Keys',
) -> None:
"""Copy the given key prop block to an entity.
This uses the keys and 'localkeys' properties on the prop_block.
Values with $fixup variables will be treated appropriately.
LocalKeys keys will be changed to use instance-local names, where needed.
block_name lets you change the 'keys' suffix on the prop_block name.
ent can be any mapping.
"""
for prop in prop_block.find_key(block_name, []):
ent[prop.real_name] = resolve_value(inst, prop.value)
for prop in prop_block.find_key('Local' + block_name, []):
if prop.value.startswith('$'):
val = inst.fixup[prop.value]
else:
val = prop.value
if val.startswith('@'):
ent[prop.real_name] = val
else:
ent[prop.real_name] = local_name(inst, val)
def set_ent_keys(
ent: Entity,
inst: Entity,
prop_block: Property,
block_name: str = 'Keys',
) -> None:
"""Copy the given key prop block to an entity.
This uses the keys and 'localkeys' properties on the prop_block.
Values with $fixup variables will be treated appropriately.
LocalKeys keys will be changed to use instance-local names, where needed.
block_name lets you change the 'keys' suffix on the prop_block name.
ent can be any mapping.
"""
for prop in prop_block.find_key(block_name, []):
ent[prop.real_name] = resolve_value(inst, prop.value)
for prop in prop_block.find_key('Local' + block_name, []):
if prop.value.startswith('$'):
val = inst.fixup[prop.value]
else:
val = prop.value
if val.startswith('@'):
ent[prop.real_name] = val
else:
ent[prop.real_name] = local_name(inst, val)
def load_conf(prop_block: Property):
"""Read the config and build our dictionaries."""
global INST_SPECIAL
# Extra definitions: key -> filename.
# Make sure to do this first, so numbered instances are set in
# ITEM_FOR_FILE.
for prop in prop_block.find_key('CustInstances', []):
CUST_INST_FILES[prop.name] = special_inst = {}
for inst in prop:
file = inst.value.casefold()
special_inst[inst.name] = file
ITEM_FOR_FILE[file] = (prop.name, inst.name)
# Normal instances: index -> filename
for prop in prop_block.find_key('Allinstances', []):
INSTANCE_FILES[prop.name] = inst_list = []
for ind, inst in enumerate(prop):
file = inst.value.casefold()
inst_list.append(file)
ITEM_FOR_FILE[file] = (prop.name, ind)
INST_SPECIAL = {
key.casefold(): resolve(val_string, silent=True)
for key, val_string in
SPECIAL_INST.items()
}
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 res_cust_antline_setup(res: Property):
if 'wall' in res:
wall_type = antlines.AntType.parse(res.find_key('wall'))
else:
wall_type = None
if 'floor' in res:
floor_type = antlines.AntType.parse(res.find_key('floor'))
else:
floor_type = wall_type
return (
wall_type,
floor_type,
res.bool('remove_signs'),
res['toggle_var', ''],
)
def res_cust_antline_setup(res: Property):
if 'wall' in res:
wall_type = antlines.AntType.parse(res.find_key('wall'))
else:
wall_type = None
if 'floor' in res:
floor_type = antlines.AntType.parse(res.find_key('floor'))
else:
floor_type = wall_type
return (
wall_type,
floor_type,
res.bool('remove_signs'),
res['toggle_var', ''],
)
def res_cust_antline_setup(res: Property) -> Callable[[Entity], None]:
"""Customise the output antlines.
Options:
* `wall`: The configuration for antlines on walls. Same as global
style options.
* `floor`: The configuration for floor/ceiling antlines. If not provided,
this is assumed to be the same as `wall`.
* `remove_signs`: If true, remove the indicator signs.
* `toggle_var`: If set, this item controls the toggle state fully of its
antlines. This is a fixup var which will be set to the name of the
overlays, for user control.
"""
wall_style: antlines.AntType | None
floor_type: antlines.AntType | None
if 'wall' in res:
wall_style = antlines.AntType.parse(res.find_key('wall'))
else:
wall_style = None
if 'floor' in res:
floor_style = antlines.AntType.parse(res.find_key('floor'))
else:
floor_style = wall_style
remove_signs = res.bool('remove_signs')
toggle_var = res['toggle_var', '']
def change_antlines(inst: Entity) -> None:
"""Change the antlines of an item."""
item = connections.ITEMS[inst['targetname']]
if wall_style is not None:
item.ant_wall_style = wall_style
if floor_style is not None:
item.ant_floor_style = floor_style
if remove_signs:
for sign in item.ind_panels:
sign.remove()
item.ind_panels.clear()
if toggle_var:
item.ant_toggle_var = toggle_var
return change_antlines
def parse_package(
pack: 'Package',
obj_override: Dict[str, Dict[str, List[ParseData]]],
has_tag: bool = False,
has_mel: bool = False,
) -> None:
"""Parse through the given package to find all the components."""
for pre in Property.find_key(pack.info, 'Prerequisites', []):
# Special case - disable these packages when the music isn't copied.
if pre.value == '<TAG_MUSIC>':
if not has_tag:
return
elif pre.value == '<MEL_MUSIC>':
if not has_mel:
return
elif pre.value not in packages:
LOGGER.warning(
'Package "{pre}" required for "{id}" - '
'ignoring package!',
pre=pre.value,
id=pack.id,
)
return
# First read through all the components we have, so we can match
# overrides to the originals
for comp_type in OBJ_TYPES:
allow_dupes = OBJ_TYPES[comp_type].allow_mult
# Look for overrides
for obj in pack.info.find_all("Overrides", comp_type):
obj_id = obj['id']
obj_override[comp_type][obj_id].append(
ParseData(pack.fsys, obj_id, obj, pack.id, True))
for obj in pack.info.find_all(comp_type):
try:
obj_id = obj['id']
except IndexError:
raise ValueError(
'No ID for "{}" object type in "{}" package!'.format(
comp_type, pack.id)) from None
if obj_id in all_obj[comp_type]:
if allow_dupes:
# Pretend this is an override
obj_override[comp_type][obj_id].append(
ParseData(pack.fsys, obj_id, obj, pack.id, True))
# Don't continue to parse and overwrite
continue
else:
raise Exception('ERROR! "' + obj_id + '" defined twice!')
all_obj[comp_type][obj_id] = ObjData(
pack.fsys,
obj,
pack.id,
pack.disp_name,
)
def load_conf(prop_block: Property):
"""Read the config and build our dictionaries."""
global INST_SPECIAL
for prop in prop_block.find_key('Allinstances', []):
INSTANCE_FILES[prop.name] = [
inst.value.casefold()
for inst in
prop
]
for prop in prop_block.find_key('CustInstances', []):
CUST_INST_FILES[prop.name] = {
inst.name: inst.value.casefold()
for inst in
prop
}
INST_SPECIAL = {
key.casefold(): resolve(val_string, silent=True)
for key, val_string in
SPECIAL_INST.items()
}
def save_load_itemvar(prop: Property = None) -> Optional[Property]:
"""Save or load item variables into the palette."""
if prop is None:
prop = Property('', [])
for group in CONFIG_ORDER:
conf = Property(group.id, [])
for widget in group.widgets: # ItemVariant special case.
if widget.values is not None:
conf.append(Property(widget.id, widget.values.get()))
for widget in group.multi_widgets:
conf.append(
Property(widget.id, [
Property(str(tim_val), var.get())
for tim_val, var in widget.values
]))
prop.append(conf)
return prop
else:
# Loading.
for group in CONFIG_ORDER:
conf = prop.find_key(group.id, [])
for widget in group.widgets:
if widget.values is not None: # ItemVariants
try:
widget.values.set(conf[widget.id])
except LookupError:
pass
for widget in group.multi_widgets:
time_conf = conf.find_key(widget.id, [])
for tim_val, var in widget.values:
try:
var.set(time_conf[str(tim_val)])
except LookupError:
pass
return None
def save_load_itemvar(prop: Property=None) -> Optional[Property]:
"""Save or load item variables into the palette."""
if prop is None:
prop = Property('', [])
for group in CONFIG_ORDER:
conf = Property(group.id, [])
for widget in group.widgets: # ItemVariant special case.
if widget.values is not None:
conf.append(Property(widget.id, widget.values.get()))
for widget in group.multi_widgets:
conf.append(Property(widget.id, [
Property(str(tim_val), var.get())
for tim_val, var in
widget.values
]))
prop.append(conf)
return prop
else:
# Loading.
for group in CONFIG_ORDER:
conf = prop.find_key(group.id, [])
for widget in group.widgets:
if widget.values is not None: # ItemVariants
try:
widget.values.set(conf[widget.id])
except LookupError:
pass
for widget in group.multi_widgets:
time_conf = conf.find_key(widget.id, [])
for tim_val, var in widget.values:
try:
var.set(time_conf[str(tim_val)])
except LookupError:
pass
return None
def from_file(cls, path, zip_file):
"""Initialise from a file.
path is the file path for the map inside the zip, without extension.
zip_file is either a ZipFile or FakeZip object.
"""
# Some P2Cs may have non-ASCII characters in descriptions, so we
# need to read it as bytes and convert to utf-8 ourselves - zips
# don't convert encodings automatically for us.
try:
with zip_open_bin(zip_file, path + '.p2c') as file:
props = Property.parse(
# Decode the P2C as UTF-8, and skip unknown characters.
# We're only using it for display purposes, so that should
# be sufficent.
TextIOWrapper(
file,
encoding='utf-8',
errors='replace',
),
path,
)
except KeyValError:
# Silently fail if we can't parse the file. That way it's still
# possible to backup.
LOGGER.warning('Failed parsing puzzle file!', path, exc_info=True)
props = Property('portal2_puzzle', [])
title = None
desc = _('Failed to parse this puzzle file. It can still be backed up.')
else:
props = props.find_key('portal2_puzzle', [])
title = props['title', None]
desc = props['description', _('No description found.')]
if title is None:
title = '<' + path.rsplit('/', 1)[-1] + '.p2c>'
return cls(
filename=os.path.basename(path),
zip_file=zip_file,
title=title,
desc=desc,
is_coop=srctools.conv_bool(props['coop', '0']),
create_time=Date(props['timestamp_created', '']),
mod_time=Date(props['timestamp_modified', '']),
)
def from_file(cls, path, zip_file):
"""Initialise from a file.
path is the file path for the map inside the zip, without extension.
zip_file is either a ZipFile or FakeZip object.
"""
# Some P2Cs may have non-ASCII characters in descriptions, so we
# need to read it as bytes and convert to utf-8 ourselves - zips
# don't convert encodings automatically for us.
try:
with zip_open_bin(zip_file, path + '.p2c') as file:
props = Property.parse(
# Decode the P2C as UTF-8, and skip unknown characters.
# We're only using it for display purposes, so that should
# be sufficent.
TextIOWrapper(
file,
encoding='utf-8',
errors='replace',
),
path,
)
except KeyValError:
# Silently fail if we can't parse the file. That way it's still
# possible to backup.
LOGGER.warning('Failed parsing puzzle file!', path, exc_info=True)
props = Property('portal2_puzzle', [])
title = None
desc = _('Failed to parse this puzzle file. It can still be backed up.')
else:
props = props.find_key('portal2_puzzle', [])
title = props['title', None]
desc = props['description', _('No description found.')]
if title is None:
title = '<' + path.rsplit('/', 1)[-1] + '.p2c>'
return cls(
filename=os.path.basename(path),
zip_file=zip_file,
title=title,
desc=desc,
is_coop=srctools.conv_bool(props['coop', '0']),
create_time=Date(props['timestamp_created', '']),
mod_time=Date(props['timestamp_modified', '']),
)
def res_import_template_setup(res: Property):
temp_id = res['id'].casefold()
face = Vec.from_str(res['face_pos', '0 0 -64'])
norm = Vec.from_str(res['normal', '0 0 1'])
replace_tex = defaultdict(list)
for prop in res.find_key('replace', []):
replace_tex[prop.name].append(prop.value)
offset = Vec.from_str(res['offset', '0 0 0'])
return (
temp_id,
dict(replace_tex),
face,
norm,
offset,
)
def res_import_template_setup(res: Property):
temp_id = res['id'].casefold()
face = Vec.from_str(res['face_pos', '0 0 -64'])
norm = Vec.from_str(res['normal', '0 0 1'])
replace_tex = defaultdict(list)
for prop in res.find_key('replace', []):
replace_tex[prop.name].append(prop.value)
offset = Vec.from_str(res['offset', '0 0 0'])
return (
temp_id,
dict(replace_tex),
face,
norm,
offset,
)
def res_import_template_setup(
res: Property, ) -> Tuple[str, Dict[str, List[str]], Vec, Vec, Vec]:
temp_id = res['id'].casefold()
face = Vec.from_str(res['face_pos', '0 0 -64'])
norm = Vec.from_str(res['normal', '0 0 1'])
replace_tex = defaultdict(list) # type: Dict[str, List[str]]
for prop in res.find_key('replace', []):
replace_tex[prop.name.replace('\\', '/')].append(prop.value)
offset = Vec.from_str(res['offset', '0 0 0'])
return (
temp_id,
dict(replace_tex),
face,
norm,
offset,
)
def res_make_tag_fizzler_setup(res: Property):
"""We need this to pre-parse the fizzler type."""
if 'ioconf' in res:
fizz_conn = Config.parse('<TAG_FIZZER>', res.find_key('ioconf'))
else:
fizz_conn = None
# The distance from origin the double signs are seperated by.
sign_offset = res.int('signoffset', 16)
return (
sign_offset,
fizz_conn,
res['frame_double'],
res['frame_single'],
res['blue_sign', ''],
res['blue_off_sign', ''],
res['oran_sign', ''],
res['oran_off_sign', ''],
)
def res_make_tag_fizzler_setup(res: Property):
"""We need this to pre-parse the fizzler type."""
if 'ioconf' in res:
fizz_type = ItemType.parse('<TAG_FIZZER>', res.find_key('ioconf'))
else:
fizz_type = None
# The distance from origin the double signs are seperated by.
sign_offset = res.int('signoffset', 16)
return (
sign_offset,
fizz_type,
res['frame_double'],
res['frame_single'],
res['blue_sign', ''],
res['blue_off_sign', ''],
res['oran_sign', ''],
res['oran_off_sign', ''],
)
def build_connections_dict(prop_block: Property):
"""Load in the dictionary mapping item ids to connections."""
global TBEAM_CONN_ACT, TBEAM_CONN_DEACT
def parse(item, key):
"""Parse the output value, handling values that aren't present."""
val = item[key, '']
if not val:
return None, ''
return Output.parse_name(val)
for item_data in prop_block.find_key('Connections', []):
CONNECTIONS[item_data.name] = ItemConnections(
in_act=parse(item_data, 'input_activate'),
in_deact=parse(item_data, 'input_deactivate'),
out_act=parse(item_data, 'output_activate'),
out_deact=parse(item_data, 'output_deactivate'),
)
if item_data.name == 'item_tbeam':
TBEAM_CONN_ACT = parse(item_data, 'tbeam_activate')
TBEAM_CONN_DEACT = parse(item_data, 'tbeam_deactivate')
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_import_template_setup(res: Property):
temp_id = res['id']
force = res['force', ''].casefold().split()
if 'white' in force:
force_colour = template_brush.MAT_TYPES.white
elif 'black' in force:
force_colour = template_brush.MAT_TYPES.black
elif 'invert' in force:
force_colour = 'INVERT'
else:
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
for size in ('2x2', '4x4', 'wall', 'special'):
if size in force:
force_grid = size
break
else:
force_grid = None
invert_var = res['invertVar', '']
color_var = res['colorVar', '']
replace_tex = defaultdict(list)
for prop in res.find_key('replace', []):
replace_tex[prop.name].append(prop.value)
rem_replace_brush = True
additional_ids = set()
transfer_overlays = '1'
try:
replace_brush = res.find_key('replaceBrush')
except NoKeyError:
replace_brush_pos = None
else:
if replace_brush.has_children():
replace_brush_pos = replace_brush['Pos', '0 0 0']
additional_ids = set(map(
srctools.conv_int,
replace_brush['additionalIDs', ''].split(),
))
rem_replace_brush = replace_brush.bool('removeBrush', True)
transfer_overlays = replace_brush['transferOverlay', '1']
else:
replace_brush_pos = replace_brush.value # type: str
replace_brush_pos = Vec.from_str(replace_brush_pos)
replace_brush_pos.z -= 64 # 0 0 0 defaults to the floor.
key_values = res.find_key("Keys", [])
if key_values:
keys = Property("", [
key_values,
res.find_key("LocalKeys", []),
])
# 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:
keys = None
outputs = []
visgroup_mode = res['visgroup', 'none'].casefold()
if visgroup_mode not in ('none', 'choose'):
visgroup_mode = srctools.conv_float(visgroup_mode.rstrip('%'), 0.00)
if visgroup_mode == 0:
visgroup_mode = 'none'
# Generate the function which picks which visgroups to add to the map.
if visgroup_mode == 'none':
def visgroup_func(_):
"""none = don't add any visgroups."""
return ()
elif visgroup_mode == 'choose':
def visgroup_func(groups):
"""choose = add one random group."""
return [random.choice(groups)]
else:
def visgroup_func(groups):
"""Number = percent chance for each to be added"""
for group in groups:
val = random.uniform(0, 100)
if val <= visgroup_mode:
yield group
# If true, force visgroups to all be used.
visgroup_force_var = res['forceVisVar', '']
return (
temp_id,
dict(replace_tex),
force_colour,
force_grid,
force_type,
replace_brush_pos,
rem_replace_brush,
transfer_overlays,
additional_ids,
invert_var,
color_var,
visgroup_func,
visgroup_force_var,
keys,
outputs,
)
def res_resizeable_trigger(vmf: VMF, res: Property):
"""Replace two markers with a trigger brush.
This is run once to affect all of an item.
Options:
* `markerInst`: <ITEM_ID:1,2> value referencing the marker instances, or a filename.
* `markerItem`: The item's ID
* `previewConf`: A item config which enables/disables the preview overlay.
* `previewInst`: An instance to place at the marker location in preview mode.
This should contain checkmarks to display the value when testing.
* `previewMat`: If set, the material to use for an overlay func_brush.
The brush will be parented to the trigger, so it vanishes once killed.
It is also non-solid.
* `previewScale`: The scale for the func_brush materials.
* `previewActivate`, `previewDeactivate`: The VMF output to turn the
previewInst on and off.
* `triggerActivate, triggerDeactivate`: The `instance:name;Output`
outputs used when the trigger turns on or off.
* `coopVar`: The instance variable which enables detecting both Coop players.
The trigger will be a trigger_playerteam.
* `coopActivate, coopDeactivate`: The `instance:name;Output` outputs used
when coopVar is enabled. These should be suitable for a logic_coop_manager.
* `coopOnce`: If true, kill the manager after it first activates.
* `keys`: A block of keyvalues for the trigger brush. Origin and targetname
will be set automatically.
* `localkeys`: The same as above, except values will be changed to use
instance-local names.
"""
marker = instanceLocs.resolve(res['markerInst'])
marker_names = set()
for inst in vmf.by_class['func_instance']:
if inst['file'].casefold() in marker:
marker_names.add(inst['targetname'])
# Unconditionally delete from the map, so it doesn't
# appear even if placed wrongly.
inst.remove()
if not marker_names: # No markers in the map - abort
return RES_EXHAUSTED
item_id = res['markerItem']
# Synthesise the item type used for the final trigger.
item_type_sp = connections.ItemType(
id=item_id + ':TRIGGER',
output_act=Output.parse_name(res['triggerActivate', 'OnStartTouchAll']),
output_deact=Output.parse_name(res['triggerDeactivate', 'OnEndTouchAll']),
)
# For Coop, we add a logic_coop_manager in the mix so both players can
# be handled.
try:
coop_var = res['coopVar']
except LookupError:
coop_var = item_type_coop = None
coop_only_once = False
else:
coop_only_once = res.bool('coopOnce')
item_type_coop = connections.ItemType(
id=item_id + ':TRIGGER_COOP',
output_act=Output.parse_name(
res['coopActivate', 'OnChangeToAllTrue']
),
output_deact=Output.parse_name(
res['coopDeactivate', 'OnChangeToAnyFalse']
),
)
# Display preview overlays if it's preview mode, and the config is true
pre_act = pre_deact = None
if vbsp.IS_PREVIEW and vbsp_options.get_itemconf(res['previewConf', ''], False):
preview_mat = res['previewMat', '']
preview_inst_file = res['previewInst', '']
preview_scale = res.float('previewScale', 0.25)
# None if not found.
with suppress(LookupError):
pre_act = Output.parse(res.find_key('previewActivate'))
with suppress(LookupError):
pre_deact = Output.parse(res.find_key('previewDeactivate'))
else:
# Deactivate the preview_ options when publishing.
preview_mat = preview_inst_file = ''
preview_scale = 0.25
# Now go through each brush.
# We do while + pop to allow removing both names each loop through.
todo_names = set(marker_names)
while todo_names:
targ = todo_names.pop()
mark1 = connections.ITEMS.pop(targ)
for conn in mark1.outputs:
if conn.to_item.name in marker_names:
mark2 = conn.to_item
conn.remove() # Delete this connection.
todo_names.discard(mark2.name)
del connections.ITEMS[mark2.name]
break
else:
if not mark1.inputs:
# If the item doesn't have any connections, 'connect'
# it to itself so we'll generate a 1-block trigger.
mark2 = mark1
else:
# It's a marker with an input, the other in the pair
# will handle everything.
# But reinstate it in ITEMS.
connections.ITEMS[targ] = mark1
continue
inst1 = mark1.inst
inst2 = mark2.inst
is_coop = coop_var is not None and vbsp.GAME_MODE == 'COOP' and (
inst1.fixup.bool(coop_var) or
inst2.fixup.bool(coop_var)
)
bbox_min, bbox_max = Vec.bbox(
Vec.from_str(inst1['origin']),
Vec.from_str(inst2['origin'])
)
origin = (bbox_max + bbox_min) / 2
# Extend to the edge of the blocks.
bbox_min -= 64
bbox_max += 64
out_ent = trig_ent = vmf.create_ent(
classname='trigger_multiple', # Default
targetname=targ,
origin=origin,
angles='0 0 0',
)
trig_ent.solids = [
vmf.make_prism(
bbox_min,
bbox_max,
mat=const.Tools.TRIGGER,
).solid,
]
# Use 'keys' and 'localkeys' blocks to set all the other keyvalues.
conditions.set_ent_keys(trig_ent, inst, res)
if is_coop:
trig_ent['spawnflags'] = '1' # Clients
trig_ent['classname'] = 'trigger_playerteam'
out_ent = manager = vmf.create_ent(
classname='logic_coop_manager',
targetname=conditions.local_name(inst, 'man'),
origin=origin,
)
item = connections.Item(
out_ent,
item_type_coop,
mark1.ant_floor_style,
mark1.ant_wall_style,
)
if coop_only_once:
# Kill all the ents when both players are present.
manager.add_out(
Output('OnChangeToAllTrue', manager, 'Kill'),
Output('OnChangeToAllTrue', targ, 'Kill'),
)
trig_ent.add_out(
Output('OnStartTouchBluePlayer', manager, 'SetStateATrue'),
Output('OnStartTouchOrangePlayer', manager, 'SetStateBTrue'),
Output('OnEndTouchBluePlayer', manager, 'SetStateAFalse'),
Output('OnEndTouchOrangePlayer', manager, 'SetStateBFalse'),
)
else:
item = connections.Item(
trig_ent,
item_type_sp,
mark1.ant_floor_style,
mark1.ant_wall_style,
)
# Register, and copy over all the antlines.
connections.ITEMS[item.name] = item
item.ind_panels = mark1.ind_panels | mark2.ind_panels
item.antlines = mark1.antlines | mark2.antlines
item.shape_signs = mark1.shape_signs + mark2.shape_signs
if preview_mat:
preview_brush = vmf.create_ent(
classname='func_brush',
parentname=targ,
origin=origin,
Solidity='1', # Not solid
drawinfastreflection='1', # Draw in goo..
# Disable shadows and lighting..
disableflashlight='1',
disablereceiveshadows='1',
disableshadowdepth='1',
disableshadows='1',
)
preview_brush.solids = [
# Make it slightly smaller, so it doesn't z-fight with surfaces.
vmf.make_prism(
bbox_min + 0.5,
bbox_max - 0.5,
mat=preview_mat,
).solid,
]
for face in preview_brush.sides():
face.scale = preview_scale
if preview_inst_file:
pre_inst = vmf.create_ent(
classname='func_instance',
targetname=targ + '_preview',
file=preview_inst_file,
# Put it at the second marker, since that's usually
# closest to antlines if present.
origin=inst2['origin'],
)
if pre_act is not None:
out = pre_act.copy()
out.inst_out, out.output = item.output_act()
out.target = conditions.local_name(pre_inst, out.target)
out_ent.add_out(out)
if pre_deact is not None:
out = pre_deact.copy()
out.inst_out, out.output = item.output_deact()
out.target = conditions.local_name(pre_inst, out.target)
out_ent.add_out(out)
for conn in mark1.outputs | mark2.outputs:
conn.from_item = item
return RES_EXHAUSTED
def generate_music_script(data: Property, pack_list: PackList) -> bytes:
"""Generate a soundscript file for music."""
# We also pack the filenames used for the tracks - that way funnel etc
# only get packed when needed. Stock sounds are in VPKS or in aperturetag/,
# we don't check there.
# The voice attrs used in the map - we can skip tracks
voice_attr = CONF['VoiceAttr', ''].casefold().split(';')
funnel = data.find_key('tbeam', '')
bounce = data.find_key('bouncegel', '')
speed = data.find_key('speedgel', '')
sync_funnel = data.bool('sync_funnel')
if 'base' not in data:
base = Property('base', 'BEE2/silent_lp.wav')
# Don't sync to a 2-second sound.
sync_funnel = False
else:
base = data.find_key('base')
# The sounds must be present, and the items should be in the map.
has_funnel = funnel.value and ('funnel' in voice_attr
or 'excursionfunnel' in voice_attr)
has_bounce = bounce.value and ('bouncegel' in voice_attr
or 'bluegel' in voice_attr)
# Speed-gel sounds also play when flinging, so keep it always.
file = StringIO()
# Write the base music track
file.write(MUSIC_START.format(name='', vol='1'))
write_sound(file, base, pack_list, snd_prefix='#*')
file.write(MUSIC_BASE)
# The 'soundoperators' section is still open now.
# Add the operators to play the auxilluary sounds..
if has_funnel:
file.write(MUSIC_FUNNEL_MAIN)
if has_bounce:
file.write(MUSIC_GEL_BOUNCE_MAIN)
if speed.value:
file.write(MUSIC_GEL_SPEED_MAIN)
# End the main sound block
file.write(MUSIC_END)
if has_funnel:
# Write the 'music.BEE2_funnel' sound entry
file.write('\n')
file.write(MUSIC_START.format(name='_funnel', vol='1'))
write_sound(file, funnel, pack_list, snd_prefix='*')
# Some tracks want the funnel music to sync with the normal
# track, others randomly choose a start.
file.write(MUSIC_FUNNEL_SYNC_STACK
if sync_funnel else MUSIC_FUNNEL_RAND_STACK)
file.write(MUSIC_FUNNEL_UPDATE_STACK)
if has_bounce:
file.write('\n')
file.write(MUSIC_START.format(name='_gel_bounce', vol='0.5'))
write_sound(file, bounce, pack_list, snd_prefix='*')
# Fade in fast (we never get false positives, but fade out slow
# since this disables when falling back..
file.write(MUSIC_GEL_STACK.format(fadein=0.25, fadeout=1.5))
if speed.value:
file.write('\n')
file.write(MUSIC_START.format(name='_gel_speed', vol='0.5'))
write_sound(file, speed, pack_list, snd_prefix='*')
# We need to shut off the sound fast, so portals don't confuse it.
# Fade in slow so it doesn't make much sound (and also as we get
# up to speed). We stop almost immediately on gel too.
file.write(MUSIC_GEL_STACK.format(fadein=0.5, fadeout=0.1))
return file.getvalue().encode()
def add(
vmf: VMF,
loc: Vec,
conf: Property,
voice_attr: Dict[str, str],
is_sp: bool,
) -> None:
"""Add music to the map."""
LOGGER.info("Adding Music...")
# These values are exported by the BEE2 app, indicating the
# options on the music item.
inst = options.get(str, 'music_instance')
snd_length = options.get(int, 'music_looplen')
# Don't add our logic if an instance was provided.
# If this settings is set, we have a music config.
if conf and not inst:
music = vmf.create_ent(
classname='ambient_generic',
spawnflags='17', # Looping, Infinite Range, Starts Silent
targetname='@music',
origin=loc,
message='music.BEE2',
health='10', # Volume
)
music_start = vmf.create_ent(
classname='logic_relay',
spawnflags='0',
targetname='@music_start',
origin=loc + (-16, 0, -16),
)
music_stop = vmf.create_ent(
classname='logic_relay',
spawnflags='0',
targetname='@music_stop',
origin=loc + (16, 0, -16),
)
music_stop.add_out(
Output('OnTrigger', music, 'StopSound'),
Output('OnTrigger', music, 'Volume', '0'),
)
# In SinglePlayer, music gets killed during reload,
# so we need to restart it.
# If snd_length is set, we have a non-loopable MP3
# and want to re-trigger it after the time elapses, to simulate
# looping.
# In either case, we need @music_restart to do that safely.
if is_sp or snd_length > 0:
music_restart = vmf.create_ent(
classname='logic_relay',
spawnflags='2', # Allow fast retrigger.
targetname='@music_restart',
StartDisabled='1',
origin=loc + (0, 0, -16),
)
music_start.add_out(
Output('OnTrigger', music_restart, 'Enable'),
Output('OnTrigger', music_restart, 'Trigger', delay=0.01),
)
music_stop.add_out(
Output('OnTrigger', music_restart, 'Disable'),
Output('OnTrigger', music_restart, 'CancelPending'),
)
music_restart.add_out(
Output('OnTrigger', music, 'StopSound'),
Output('OnTrigger', music, 'Volume', '0'),
Output('OnTrigger', music, 'Volume', '10', delay=0.1),
Output('OnTrigger', music, 'PlaySound', delay=0.1),
)
if is_sp == 'SP':
# Trigger on level loads.
vmf.create_ent(
classname='logic_auto',
origin=loc + (0, 0, 16),
spawnflags='0', # Don't remove after fire
globalstate='',
).add_out(
Output('OnLoadGame', music_restart, 'CancelPending'),
Output('OnLoadGame', music_restart, 'Trigger', delay=0.01),
)
if snd_length > 0:
# Re-trigger after the music duration.
music_restart.add_out(
Output('OnTrigger', '!self', 'Trigger', delay=snd_length)
)
# Set to non-looping, so re-playing will restart it correctly.
music['spawnflags'] = '49'
else:
# The music track never needs to have repeating managed,
# just directly trigger.
music_start.add_out(
Output('OnTrigger', music, 'PlaySound'),
Output('OnTrigger', music, 'Volume', '10'),
)
# Add the ents for the config itself.
# If the items aren't in the map, we can skip adding them.
# Speed-gel sounds also play when flinging, so keep it always.
funnel = conf.find_key('tbeam', or_blank=True)
bounce = conf.find_key('bouncegel', or_blank=True)
make_channel_conf(
vmf, loc,
Channel.BASE,
conf.find_key('base', or_blank=True).as_array(),
)
make_channel_conf(
vmf, loc,
Channel.SPEED,
conf.find_key('speedgel', or_blank=True).as_array(),
)
if 'funnel' in voice_attr or 'excursionfunnel' in voice_attr:
make_channel_conf(
vmf, loc,
Channel.TBEAM,
funnel.as_array(),
conf.bool('sync_funnel'),
)
if 'bouncegel' in voice_attr or 'bluegel' in voice_attr:
make_channel_conf(
vmf, loc,
Channel.BOUNCE,
bounce.as_array(),
)
packfiles = conf.find_key('pack', or_blank=True).as_array()
if packfiles:
packer = vmf.create_ent('comp_pack', origin=loc)
for i, fname in enumerate(packfiles, 1):
packer[f'generic{i:02}'] = fname
if inst:
# We assume the instance is setup correct.
vmf.create_ent(
classname='func_instance',
targetname='music',
angles='0 0 0',
origin=loc,
file=inst,
fixup_style='0',
)
def modify(self, fsys: FileSystem, props: Property,
source: str) -> 'ItemVariant':
"""Apply a config to this item variant.
This produces a copy with various modifications - switching
out palette or instance values, changing the config, etc.
"""
if 'config' in props:
# Item.parse() has resolved this to the actual config.
vbsp_config = get_config(
props,
fsys,
'items',
pak_id=fsys.path,
)
else:
vbsp_config = self.vbsp_config.copy()
if 'replace' in props:
# Replace property values in the config via regex.
replace_vals = [(re.compile(prop.real_name,
re.IGNORECASE), prop.value)
for prop in props.find_children('Replace')]
for prop in vbsp_config.iter_tree():
for regex, sub in replace_vals:
prop.name = regex.sub(sub, prop.real_name)
prop.value = regex.sub(sub, prop.value)
vbsp_config += list(
get_config(
props,
fsys,
'items',
prop_name='append',
pak_id=fsys.path,
))
if 'description' in props:
desc = desc_parse(props, source)
else:
desc = self.desc.copy()
if 'appenddesc' in props:
desc = tkMarkdown.join(
desc,
desc_parse(props, source, prop_name='appenddesc'),
)
if 'authors' in props:
authors = sep_values(props['authors', ''])
else:
authors = self.authors
if 'tags' in props:
tags = sep_values(props['tags', ''])
else:
tags = self.tags.copy()
variant = ItemVariant(
self.editor,
vbsp_config,
self.editor_extra.copy(),
authors=authors,
tags=tags,
desc=desc,
icons=self.icons.copy(),
ent_count=props['ent_count', self.ent_count],
url=props['url', self.url],
all_name=self.all_name,
all_icon=self.all_icon,
source='{} from {}'.format(source, self.source),
)
[variant.editor] = variant._modify_editoritems(
props,
[variant.editor],
source,
is_extra=False,
)
if 'extra' in props:
variant.editor_extra = variant._modify_editoritems(
props.find_key('extra'),
variant.editor_extra,
source,
is_extra=True)
return variant
def parse(cls, conf: Property):
"""Read in a fizzler from a config."""
fizz_id = conf['id']
item_ids = [
prop.value.casefold()
for prop in
conf.find_all('item_id')
]
try:
model_name_type = ModelName(conf['NameType', 'same'].casefold())
except ValueError:
LOGGER.warning('Bad model name type: "{}"', conf['NameType'])
model_name_type = ModelName.SAME
model_local_name = conf['ModelName', '']
if not model_local_name:
# We can't rename without a local name.
model_name_type = ModelName.SAME
inst = {}
for inst_type, is_static in itertools.product(FizzInst, (False, True)):
inst_type_name = inst_type.value + ('_static' if is_static else '')
inst[inst_type, is_static] = instances = [
file
for prop in conf.find_all(inst_type_name)
for file in instanceLocs.resolve(prop.value)
]
# Allow specifying weights to bias model locations
weights = conf[inst_type_name + '_weight', '']
if weights:
# Produce the weights, then process through the original
# list to build a new one with repeated elements.
inst[inst_type, is_static] = instances = [
instances[i]
for i in conditions.weighted_random(len(instances), weights)
]
# If static versions aren't given, reuse non-static ones.
# We do False, True so it's already been calculated.
if not instances and is_static:
inst[inst_type, True] = inst[inst_type, False]
if not inst[FizzInst.BASE, False]:
LOGGER.warning('No base instance set! for "{}"!', fizz_id)
voice_attrs = []
for prop in conf.find_all('Has'):
if prop.has_children():
for child in prop:
voice_attrs.append(child.name.casefold())
else:
voice_attrs.append(prop.value.casefold())
pack_lists = {
prop.value
for prop in
conf.find_all('Pack')
}
pack_lists_static = {
prop.value
for prop in
conf.find_all('PackStatic')
}
brushes = [
FizzlerBrush.parse(prop)
for prop in
conf.find_all('Brush')
]
beams = [] # type: List[FizzBeam]
for beam_prop in conf.find_all('Beam'):
offsets = [
Vec.from_str(off.value)
for off in
beam_prop.find_all('pos')
]
keys = Property('', [
beam_prop.find_key('Keys', []),
beam_prop.find_key('LocalKeys', [])
])
beams.append(FizzBeam(
offsets,
keys,
beam_prop.int('RandSpeedMin', 0),
beam_prop.int('RandSpeedMax', 0),
))
try:
temp_conf = conf.find_key('TemplateBrush')
except NoKeyError:
temp_brush_keys = temp_min = temp_max = temp_single = None
else:
temp_brush_keys = Property('--', [
temp_conf.find_key('Keys'),
temp_conf.find_key('LocalKeys', []),
])
# Find and load the templates.
temp_min = temp_conf['Left', None]
temp_max = temp_conf['Right', None]
temp_single = temp_conf['Single', None]
return FizzlerType(
fizz_id,
item_ids,
voice_attrs,
pack_lists,
pack_lists_static,
model_local_name,
model_name_type,
brushes,
beams,
inst,
temp_brush_keys,
temp_min,
temp_max,
temp_single,
)
def res_resizeable_trigger(vmf: VMF, res: Property):
"""Replace two markers with a trigger brush.
This is run once to affect all of an item.
Options:
* `markerInst`: <ITEM_ID:1,2> value referencing the marker instances, or a filename.
* `markerItem`: The item's ID
* `previewConf`: A item config which enables/disables the preview overlay.
* `previewInst`: An instance to place at the marker location in preview mode.
This should contain checkmarks to display the value when testing.
* `previewMat`: If set, the material to use for an overlay func_brush.
The brush will be parented to the trigger, so it vanishes once killed.
It is also non-solid.
* `previewScale`: The scale for the func_brush materials.
* `previewActivate`, `previewDeactivate`: The VMF output to turn the
previewInst on and off.
* `triggerActivate, triggerDeactivate`: The `instance:name;Output`
outputs used when the trigger turns on or off.
* `coopVar`: The instance variable which enables detecting both Coop players.
The trigger will be a trigger_playerteam.
* `coopActivate, coopDeactivate`: The `instance:name;Output` outputs used
when coopVar is enabled. These should be suitable for a logic_coop_manager.
* `coopOnce`: If true, kill the manager after it first activates.
* `keys`: A block of keyvalues for the trigger brush. Origin and targetname
will be set automatically.
* `localkeys`: The same as above, except values will be changed to use
instance-local names.
"""
marker = instanceLocs.resolve(res['markerInst'])
marker_names = set()
for inst in vmf.by_class['func_instance']:
if inst['file'].casefold() in marker:
marker_names.add(inst['targetname'])
# Unconditionally delete from the map, so it doesn't
# appear even if placed wrongly.
inst.remove()
if not marker_names: # No markers in the map - abort
return RES_EXHAUSTED
item_id = res['markerItem']
# Synthesise the item type used for the final trigger.
item_type_sp = connections.ItemType(
id=item_id + ':TRIGGER',
output_act=Output.parse_name(res['triggerActivate',
'OnStartTouchAll']),
output_deact=Output.parse_name(res['triggerDeactivate',
'OnEndTouchAll']),
)
# For Coop, we add a logic_coop_manager in the mix so both players can
# be handled.
try:
coop_var = res['coopVar']
except LookupError:
coop_var = item_type_coop = None
coop_only_once = False
else:
coop_only_once = res.bool('coopOnce')
item_type_coop = connections.ItemType(
id=item_id + ':TRIGGER_COOP',
output_act=Output.parse_name(res['coopActivate',
'OnChangeToAllTrue']),
output_deact=Output.parse_name(res['coopDeactivate',
'OnChangeToAnyFalse']),
)
# Display preview overlays if it's preview mode, and the config is true
pre_act = pre_deact = None
if vbsp.IS_PREVIEW and vbsp_options.get_itemconf(res['previewConf', ''],
False):
preview_mat = res['previewMat', '']
preview_inst_file = res['previewInst', '']
preview_scale = res.float('previewScale', 0.25)
# None if not found.
with suppress(LookupError):
pre_act = Output.parse(res.find_key('previewActivate'))
with suppress(LookupError):
pre_deact = Output.parse(res.find_key('previewDeactivate'))
else:
# Deactivate the preview_ options when publishing.
preview_mat = preview_inst_file = ''
preview_scale = 0.25
# Now go through each brush.
# We do while + pop to allow removing both names each loop through.
todo_names = set(marker_names)
while todo_names:
targ = todo_names.pop()
mark1 = connections.ITEMS.pop(targ)
for conn in mark1.outputs:
if conn.to_item.name in marker_names:
mark2 = conn.to_item
conn.remove() # Delete this connection.
todo_names.discard(mark2.name)
del connections.ITEMS[mark2.name]
break
else:
if not mark1.inputs:
# If the item doesn't have any connections, 'connect'
# it to itself so we'll generate a 1-block trigger.
mark2 = mark1
else:
# It's a marker with an input, the other in the pair
# will handle everything.
# But reinstate it in ITEMS.
connections.ITEMS[targ] = mark1
continue
inst1 = mark1.inst
inst2 = mark2.inst
is_coop = coop_var is not None and vbsp.GAME_MODE == 'COOP' and (
inst1.fixup.bool(coop_var) or inst2.fixup.bool(coop_var))
bbox_min, bbox_max = Vec.bbox(Vec.from_str(inst1['origin']),
Vec.from_str(inst2['origin']))
origin = (bbox_max + bbox_min) / 2
# Extend to the edge of the blocks.
bbox_min -= 64
bbox_max += 64
out_ent = trig_ent = vmf.create_ent(
classname='trigger_multiple', # Default
targetname=targ,
origin=origin,
angles='0 0 0',
)
trig_ent.solids = [
vmf.make_prism(
bbox_min,
bbox_max,
mat=const.Tools.TRIGGER,
).solid,
]
# Use 'keys' and 'localkeys' blocks to set all the other keyvalues.
conditions.set_ent_keys(trig_ent, inst, res)
if is_coop:
trig_ent['spawnflags'] = '1' # Clients
trig_ent['classname'] = 'trigger_playerteam'
out_ent = manager = vmf.create_ent(
classname='logic_coop_manager',
targetname=conditions.local_name(inst, 'man'),
origin=origin,
)
item = connections.Item(
out_ent,
item_type_coop,
mark1.ant_floor_style,
mark1.ant_wall_style,
)
if coop_only_once:
# Kill all the ents when both players are present.
manager.add_out(
Output('OnChangeToAllTrue', manager, 'Kill'),
Output('OnChangeToAllTrue', targ, 'Kill'),
)
trig_ent.add_out(
Output('OnStartTouchBluePlayer', manager, 'SetStateATrue'),
Output('OnStartTouchOrangePlayer', manager, 'SetStateBTrue'),
Output('OnEndTouchBluePlayer', manager, 'SetStateAFalse'),
Output('OnEndTouchOrangePlayer', manager, 'SetStateBFalse'),
)
else:
item = connections.Item(
trig_ent,
item_type_sp,
mark1.ant_floor_style,
mark1.ant_wall_style,
)
# Register, and copy over all the antlines.
connections.ITEMS[item.name] = item
item.ind_panels = mark1.ind_panels | mark2.ind_panels
item.antlines = mark1.antlines | mark2.antlines
item.shape_signs = mark1.shape_signs + mark2.shape_signs
if preview_mat:
preview_brush = vmf.create_ent(
classname='func_brush',
parentname=targ,
origin=origin,
Solidity='1', # Not solid
drawinfastreflection='1', # Draw in goo..
# Disable shadows and lighting..
disableflashlight='1',
disablereceiveshadows='1',
disableshadowdepth='1',
disableshadows='1',
)
preview_brush.solids = [
# Make it slightly smaller, so it doesn't z-fight with surfaces.
vmf.make_prism(
bbox_min + 0.5,
bbox_max - 0.5,
mat=preview_mat,
).solid,
]
for face in preview_brush.sides():
face.scale = preview_scale
if preview_inst_file:
pre_inst = vmf.create_ent(
classname='func_instance',
targetname=targ + '_preview',
file=preview_inst_file,
# Put it at the second marker, since that's usually
# closest to antlines if present.
origin=inst2['origin'],
)
if pre_act is not None:
out = pre_act.copy()
out.inst_out, out.output = item.output_act()
out.target = conditions.local_name(pre_inst, out.target)
out_ent.add_out(out)
if pre_deact is not None:
out = pre_deact.copy()
out.inst_out, out.output = item.output_deact()
out.target = conditions.local_name(pre_inst, out.target)
out_ent.add_out(out)
for conn in mark1.outputs | mark2.outputs:
conn.from_item = item
return RES_EXHAUSTED
def res_cutout_tile(vmf: srctools.VMF, res: Property):
"""Generate random quarter tiles, like in Destroyed or Retro maps.
- "MarkerItem" is the instance to look for.
- "TileSize" can be "2x2" or "4x4".
- rotateMax is the amount of degrees to rotate squarebeam models.
Materials:
- "squarebeams" is the squarebeams variant to use.
- "ceilingwalls" are the sides of the ceiling section.
- "floorbase" is the texture under floor sections.
- "tile_glue" is used on top of a thinner tile segment.
- "clip" is the player_clip texture used over floor segments.
(This allows customising the surfaceprop.)
- "Floor4x4Black", "Ceil2x2White" and other combinations can be used to
override the textures used.
"""
marker_filenames = instanceLocs.resolve(res['markeritem'])
INST_LOCS = {} # Map targetnames -> surface loc
CEIL_IO = [] # Pairs of ceil inst corners to cut out.
FLOOR_IO = [] # Pairs of floor inst corners to cut out.
overlay_ids = {} # When we replace brushes, we need to fix any overlays
# on that surface.
MATS.clear()
floor_edges = [] # Values to pass to add_floor_sides() at the end
sign_locs = set()
# If any signage is present in the map, we need to force tiles to
# appear at that location!
for over in vmf.by_class['info_overlay']:
if (
over['material'].casefold() in FORCE_TILE_MATS and
# Only check floor/ceiling overlays
over['basisnormal'] in ('0 0 1', '0 0 -1')
):
add_signage_loc(sign_locs, Vec.from_str(over['origin']))
for item in connections.ITEMS.values():
for ind_pan in item.ind_panels:
loc = Vec(0, 0, -64)
loc.localise(
Vec.from_str(ind_pan['origin']),
Vec.from_str(ind_pan['angles']),
)
add_signage_loc(sign_locs, loc)
SETTINGS = {
'floor_chance': srctools.conv_int(
res['floorChance', '100'], 100),
'ceil_chance': srctools.conv_int(
res['ceilingChance', '100'], 100),
'floor_glue_chance': srctools.conv_int(
res['floorGlueChance', '0']),
'ceil_glue_chance': srctools.conv_int(
res['ceilingGlueChance', '0']),
'rotate_beams': int(srctools.conv_float(
res['rotateMax', '0']) * BEAM_ROT_PRECISION),
'beam_skin': res['squarebeamsSkin', '0'],
'base_is_disp': srctools.conv_bool(res['dispBase', '0']),
'quad_floor': res['FloorSize', '4x4'].casefold() == '2x2',
'quad_ceil': res['CeilingSize', '4x4'].casefold() == '2x2',
}
random.seed(vbsp.MAP_RAND_SEED + '_CUTOUT_TILE_NOISE')
noise = SimplexNoise(period=4 * 40) # 4 tiles/block, 50 blocks max
# We want to know the number of neighbouring tile cutouts before
# placing tiles - blocks away from the sides generate fewer tiles.
floor_neighbours = defaultdict(dict) # all_floors[z][x,y] = count
for mat_prop in res.find_key('Materials', []):
MATS[mat_prop.name].append(mat_prop.value)
if SETTINGS['base_is_disp']:
# We want the normal brushes to become nodraw.
MATS['floorbase_disp'] = MATS['floorbase']
MATS['floorbase'] = ['tools/toolsnodraw']
# Since this uses random data for initialisation, the alpha and
# regular will use slightly different patterns.
alpha_noise = SimplexNoise(period=4 * 50)
else:
alpha_noise = None
for key, default in TEX_DEFAULT:
if key not in MATS:
MATS[key] = [default]
# Find our marker ents
for inst in vmf.by_class['func_instance']:
if inst['file'].casefold() not in marker_filenames:
continue
targ = inst['targetname']
normal = Vec(0, 0, 1).rotate_by_str(inst['angles', '0 0 0'])
# Check the orientation of the marker to figure out what to generate
if normal == (0, 0, 1):
io_list = FLOOR_IO
else:
io_list = CEIL_IO
# Reuse orient to calculate where the solid face will be.
loc = Vec.from_str(inst['origin']) - 64 * normal
INST_LOCS[targ] = loc
item = connections.ITEMS[targ]
item.delete_antlines()
if item.outputs:
for conn in list(item.outputs):
if conn.to_item.inst['file'].casefold() in marker_filenames:
io_list.append((targ, conn.to_item.name))
else:
LOGGER.warning('Cutout tile connected to non-cutout!')
conn.remove() # Delete the connection.
else:
# If the item doesn't have any connections, 'connect'
# it to itself so we'll generate a 128x128 tile segment.
io_list.append((targ, targ))
# Remove all traces of this item (other than in connections lists).
inst.remove()
del connections.ITEMS[targ]
for start_floor, end_floor in FLOOR_IO:
box_min = Vec(INST_LOCS[start_floor])
box_min.min(INST_LOCS[end_floor])
box_max = Vec(INST_LOCS[start_floor])
box_max.max(INST_LOCS[end_floor])
if box_min.z != box_max.z:
continue # They're not in the same level!
z = box_min.z
if SETTINGS['rotate_beams']:
# We have to generate 1 model per 64x64 block to do rotation...
gen_rotated_squarebeams(
vmf,
box_min - (64, 64, 0),
box_max + (64, 64, -8),
skin=SETTINGS['beam_skin'],
max_rot=SETTINGS['rotate_beams'],
)
else:
# Make the squarebeams props, using big models if possible
gen_squarebeams(
vmf,
box_min + (-64, -64, 0),
box_max + (64, 64, -8),
skin=SETTINGS['beam_skin']
)
# Add a player_clip brush across the whole area
vmf.add_brush(vmf.make_prism(
p1=box_min - (64, 64, FLOOR_DEPTH),
p2=box_max + (64, 64, 0),
mat=MATS['clip'][0],
).solid)
# Add a noportal_volume covering the surface, in case there's
# room for a portal.
noportal_solid = vmf.make_prism(
# Don't go all the way to the sides, so it doesn't affect wall
# brushes.
p1=box_min - (63, 63, 9),
p2=box_max + (63, 63, 0),
mat='tools/toolsinvisible',
).solid
noportal_ent = vmf.create_ent(
classname='func_noportal_volume',
origin=box_min.join(' '),
)
noportal_ent.solids.append(noportal_solid)
if SETTINGS['base_is_disp']:
# Use displacements for the base instead.
make_alpha_base(
vmf,
box_min + (-64, -64, 0),
box_max + (64, 64, 0),
noise=alpha_noise,
)
for x, y in utils.iter_grid(
min_x=int(box_min.x),
max_x=int(box_max.x) + 1,
min_y=int(box_min.y),
max_y=int(box_max.y) + 1,
stride=128,
):
# Build the set of all positions..
floor_neighbours[z][x, y] = -1
# Mark borders we need to fill in, and the angle (for func_instance)
# The wall is the face pointing inwards towards the bottom brush,
# and the ceil is the ceiling of the block above the bordering grid
# points.
for x in range(int(box_min.x), int(box_max.x) + 1, 128):
# North
floor_edges.append(BorderPoints(
wall=Vec(x, box_max.y + 64, z - 64),
ceil=Vec_tuple(x, box_max.y + 128, z),
rot=270,
))
# South
floor_edges.append(BorderPoints(
wall=Vec(x, box_min.y - 64, z - 64),
ceil=Vec_tuple(x, box_min.y - 128, z),
rot=90,
))
for y in range(int(box_min.y), int(box_max.y) + 1, 128):
# East
floor_edges.append(BorderPoints(
wall=Vec(box_max.x + 64, y, z - 64),
ceil=Vec_tuple(box_max.x + 128, y, z),
rot=180,
))
# West
floor_edges.append(BorderPoints(
wall=Vec(box_min.x - 64, y, z - 64),
ceil=Vec_tuple(box_min.x - 128, y, z),
rot=0,
))
# Now count boundaries near tiles, then generate them.
# Do it separately for each z-level:
for z, xy_dict in floor_neighbours.items(): # type: float, dict
for x, y in xy_dict: # type: float, float
# We want to count where there aren't any tiles
xy_dict[x, y] = (
((x - 128, y - 128) not in xy_dict) +
((x - 128, y + 128) not in xy_dict) +
((x + 128, y - 128) not in xy_dict) +
((x + 128, y + 128) not in xy_dict) +
((x - 128, y) not in xy_dict) +
((x + 128, y) not in xy_dict) +
((x, y - 128) not in xy_dict) +
((x, y + 128) not in xy_dict)
)
max_x = max_y = 0
weights = {}
# Now the counts are all correct, compute the weight to apply
# for tiles.
# Adding the neighbouring counts will make a 5x5 area needed to set
# the center to 0.
for (x, y), cur_count in xy_dict.items():
max_x = max(x, max_x)
max_y = max(y, max_y)
# Orthrogonal is worth 0.2, diagonal is worth 0.1.
# Not-present tiles would be 8 - the maximum
tile_count = (
0.8 * cur_count +
0.1 * xy_dict.get((x - 128, y - 128), 8) +
0.1 * xy_dict.get((x - 128, y + 128), 8) +
0.1 * xy_dict.get((x + 128, y - 128), 8) +
0.1 * xy_dict.get((x + 128, y + 128), 8) +
0.2 * xy_dict.get((x - 128, y), 8) +
0.2 * xy_dict.get((x, y - 128), 8) +
0.2 * xy_dict.get((x, y + 128), 8) +
0.2 * xy_dict.get((x + 128, y), 8)
)
# The number ranges from 0 (all tiles) to 12.8 (no tiles).
# All tiles should still have a small chance to generate tiles.
weights[x, y] = min((tile_count + 0.5) / 8, 1)
# Share the detail entity among same-height tiles..
detail_ent = vmf.create_ent(
classname='func_detail',
)
for x, y in xy_dict:
convert_floor(
vmf,
Vec(x, y, z),
overlay_ids,
MATS,
SETTINGS,
sign_locs,
detail_ent,
noise_weight=weights[x, y],
noise_func=noise,
)
add_floor_sides(vmf, floor_edges)
conditions.reallocate_overlays(overlay_ids)
return conditions.RES_EXHAUSTED
def parse(cls, conf: Property):
"""Read in a fizzler from a config."""
fizz_id = conf['id']
item_ids = [prop.value.casefold() for prop in conf.find_all('item_id')]
try:
model_name_type = ModelName(conf['NameType', 'same'].casefold())
except ValueError:
LOGGER.warning('Bad model name type: "{}"', conf['NameType'])
model_name_type = ModelName.SAME
model_local_name = conf['ModelName', '']
if not model_local_name:
# We can't rename without a local name.
model_name_type = ModelName.SAME
inst = {}
for inst_type, is_static in itertools.product(FizzInst, (False, True)):
inst_type_name = inst_type.value + ('_static' if is_static else '')
inst[inst_type, is_static] = instances = [
file for prop in conf.find_all(inst_type_name)
for file in instanceLocs.resolve(prop.value)
]
# Allow specifying weights to bias model locations
weights = conf[inst_type_name + '_weight', '']
if weights:
# Produce the weights, then process through the original
# list to build a new one with repeated elements.
inst[inst_type, is_static] = instances = [
instances[i] for i in conditions.weighted_random(
len(instances), weights)
]
# If static versions aren't given, reuse non-static ones.
# We do False, True so it's already been calculated.
if not instances and is_static:
inst[inst_type, True] = inst[inst_type, False]
if not inst[FizzInst.BASE, False]:
LOGGER.warning('No base instance set! for "{}"!', fizz_id)
voice_attrs = []
for prop in conf.find_all('Has'):
if prop.has_children():
for child in prop:
voice_attrs.append(child.name.casefold())
else:
voice_attrs.append(prop.value.casefold())
pack_lists = {prop.value for prop in conf.find_all('Pack')}
pack_lists_static = {
prop.value
for prop in conf.find_all('PackStatic')
}
brushes = [FizzlerBrush.parse(prop) for prop in conf.find_all('Brush')]
beams = [] # type: List[FizzBeam]
for beam_prop in conf.find_all('Beam'):
offsets = [
Vec.from_str(off.value) for off in beam_prop.find_all('pos')
]
keys = Property('', [
beam_prop.find_key('Keys', []),
beam_prop.find_key('LocalKeys', [])
])
beams.append(
FizzBeam(
offsets,
keys,
beam_prop.int('RandSpeedMin', 0),
beam_prop.int('RandSpeedMax', 0),
))
try:
temp_conf = conf.find_key('TemplateBrush')
except NoKeyError:
temp_brush_keys = temp_min = temp_max = temp_single = None
else:
temp_brush_keys = Property('--', [
temp_conf.find_key('Keys'),
temp_conf.find_key('LocalKeys', []),
])
# Find and load the templates.
temp_min = temp_conf['Left', None]
temp_max = temp_conf['Right', None]
temp_single = temp_conf['Single', None]
return FizzlerType(
fizz_id,
item_ids,
voice_attrs,
pack_lists,
pack_lists_static,
model_local_name,
model_name_type,
brushes,
beams,
inst,
temp_brush_keys,
temp_min,
temp_max,
temp_single,
)
def generate_music_script(data: Property, pack_list: PackList) -> bytes:
"""Generate a soundscript file for music."""
# We also pack the filenames used for the tracks - that way funnel etc
# only get packed when needed. Stock sounds are in VPKS or in aperturetag/,
# we don't check there.
# The voice attrs used in the map - we can skip tracks
voice_attr = CONF['VoiceAttr', ''].casefold().split(';')
funnel = data.find_key('tbeam', '')
bounce = data.find_key('bouncegel', '')
speed = data.find_key('speedgel', '')
sync_funnel = data.bool('sync_funnel')
if 'base' not in data:
base = Property('base', 'bee2/silent_lp.wav')
# Don't sync to a 2-second sound.
sync_funnel = False
else:
base = data.find_key('base')
# The sounds must be present, and the items should be in the map.
has_funnel = funnel.value and (
'funnel' in voice_attr or
'excursionfunnel' in voice_attr
)
has_bounce = bounce.value and (
'bouncegel' in voice_attr or
'bluegel' in voice_attr
)
# Speed-gel sounds also play when flinging, so keep it always.
file = StringIO()
# Write the base music track
file.write(MUSIC_START.format(name='', vol='1'))
write_sound(file, base, pack_list, snd_prefix='#*')
file.write(MUSIC_BASE)
# The 'soundoperators' section is still open now.
# Add the operators to play the auxilluary sounds..
if has_funnel:
file.write(MUSIC_FUNNEL_MAIN)
if has_bounce:
file.write(MUSIC_GEL_BOUNCE_MAIN)
if speed.value:
file.write(MUSIC_GEL_SPEED_MAIN)
# End the main sound block
file.write(MUSIC_END)
if has_funnel:
# Write the 'music.BEE2_funnel' sound entry
file.write('\n')
file.write(MUSIC_START.format(name='_funnel', vol='1'))
write_sound(file, funnel, pack_list, snd_prefix='*')
# Some tracks want the funnel music to sync with the normal
# track, others randomly choose a start.
file.write(
MUSIC_FUNNEL_SYNC_STACK
if sync_funnel else
MUSIC_FUNNEL_RAND_STACK
)
file.write(MUSIC_FUNNEL_UPDATE_STACK)
if has_bounce:
file.write('\n')
file.write(MUSIC_START.format(name='_gel_bounce', vol='0.5'))
write_sound(file, bounce, pack_list, snd_prefix='*')
# Fade in fast (we never get false positives, but fade out slow
# since this disables when falling back..
file.write(MUSIC_GEL_STACK.format(fadein=0.25, fadeout=1.5))
if speed.value:
file.write('\n')
file.write(MUSIC_START.format(name='_gel_speed', vol='0.5'))
write_sound(file, speed, pack_list, snd_prefix='*')
# We need to shut off the sound fast, so portals don't confuse it.
# Fade in slow so it doesn't make much sound (and also as we get
# up to speed). We stop almost immediately on gel too.
file.write(MUSIC_GEL_STACK.format(fadein=0.5, fadeout=0.1))
return file.getvalue().encode()
def _modify_editoritems(
self,
props: Property,
editor: list[EditorItem],
pak_id: str,
source: str,
is_extra: bool,
) -> list[EditorItem]:
"""Modify either the base or extra editoritems block."""
# We can share a lot of the data, if it isn't changed and we take
# care to copy modified parts.
editor = list(map(copy.copy, editor))
# Create a list of subtypes in the file, in order to edit.
subtype_lookup = [(item, i, subtype) for item in editor
for i, subtype in enumerate(item.subtypes)]
# Implement overriding palette items
for item in props.find_children('Palette'):
try:
pal_icon = FSPath(item['icon'])
except LookupError:
pal_icon = None
pal_name = item['pal_name', None] # Name for the palette icon
try:
bee2_icon = img.Handle.parse(
item.find_key('BEE2'),
pak_id,
64,
64,
subfolder='items',
)
except LookupError:
bee2_icon = None
if item.name == 'all':
if is_extra:
raise Exception('Cannot specify "all" for hidden '
f'editoritems blocks in {source}!')
if pal_icon is not None:
self.all_icon = pal_icon
# If a previous BEE icon was present, remove so we use the VTF.
self.icons.pop('all', None)
if pal_name is not None:
self.all_name = pal_name
if bee2_icon is not None:
self.icons['all'] = bee2_icon
continue
try:
subtype_ind = int(item.name)
subtype_item, subtype_ind, subtype = subtype_lookup[
subtype_ind]
except (IndexError, ValueError, TypeError):
raise Exception(f'Invalid index "{item.name}" when modifying '
f'editoritems for {source}')
subtype_item.subtypes = subtype_item.subtypes.copy()
subtype_item.subtypes[subtype_ind] = subtype = copy.deepcopy(
subtype)
# Overriding model data.
if 'models' in item or 'model' in item:
subtype.models = []
for prop in item:
if prop.name in ('models', 'model'):
if prop.has_children():
subtype.models.extend(
[FSPath(subprop.value) for subprop in prop])
else:
subtype.models.append(FSPath(prop.value))
if item['name', None]:
subtype.name = item['name'] # Name for the subtype
if bee2_icon:
if is_extra:
raise ValueError('Cannot specify BEE2 icons for hidden '
f'editoritems blocks in {source}!')
self.icons[item.name] = bee2_icon
elif pal_icon is not None:
# If a previous BEE icon was present, remove so we use the VTF.
self.icons.pop(item.name, None)
if pal_name is not None:
subtype.pal_name = pal_name
if pal_icon is not None:
subtype.pal_icon = pal_icon
if 'Instances' in props:
if len(editor) != 1:
raise ValueError('Cannot specify instances for multiple '
f'editoritems blocks in {source}!')
editor[0].instances = editor[0].instances.copy()
editor[0].cust_instances = editor[0].cust_instances.copy()
for inst in props.find_children('Instances'):
if inst.has_children():
inst_data = InstCount(
FSPath(inst['name']),
inst.int('entitycount'),
inst.int('brushcount'),
inst.int('brushsidecount'),
)
else: # Allow just specifying the file.
inst_data = InstCount(FSPath(inst.value), 0, 0, 0)
if inst.real_name.isdecimal(): # Regular numeric
try:
ind = int(inst.real_name)
except IndexError:
# This would likely mean there's an extra definition or
# something.
raise ValueError(f'Invalid index {inst.real_name} for '
f'instances in {source}') from None
editor[0].set_inst(ind, inst_data)
else: # BEE2 named instance
inst_name = inst.name
if inst_name.startswith('bee2_'):
inst_name = inst_name[5:]
editor[0].cust_instances[inst_name] = inst_data.inst
# Override IO commands.
try:
io_props = props.find_key('IOConf')
except LookupError:
pass
else:
if len(editor) != 1:
raise ValueError('Cannot specify I/O for multiple '
f'editoritems blocks in {source}!')
force = io_props['force', '']
editor[0].conn_config = ConnConfig.parse(editor[0].id, io_props)
editor[0].force_input = 'in' in force
editor[0].force_output = 'out' in force
return editor
async def modify(self, pak_id: str, props: Property,
source: str) -> ItemVariant:
"""Apply a config to this item variant.
This produces a copy with various modifications - switching
out palette or instance values, changing the config, etc.
"""
vbsp_config: lazy_conf.LazyConf
if 'config' in props:
# Item.parse() has resolved this to the actual config.
vbsp_config = get_config(
props,
'items',
pak_id,
)
else:
vbsp_config = self.vbsp_config
if 'replace' in props:
# Replace property values in the config via regex.
vbsp_config = lazy_conf.replace(
vbsp_config,
[(re.compile(prop.real_name, re.IGNORECASE), prop.value)
for prop in props.find_children('Replace')])
vbsp_config = lazy_conf.concat(
vbsp_config,
get_config(
props,
'items',
pak_id,
prop_name='append',
))
if 'description' in props:
desc = desc_parse(props, source, pak_id)
else:
desc = self.desc.copy()
if 'appenddesc' in props:
desc = tkMarkdown.join(
desc,
desc_parse(props, source, pak_id, prop_name='appenddesc'),
)
if 'authors' in props:
authors = sep_values(props['authors', ''])
else:
authors = self.authors
if 'tags' in props:
tags = sep_values(props['tags', ''])
else:
tags = self.tags.copy()
variant = ItemVariant(
pak_id,
self.editor,
vbsp_config,
self.editor_extra.copy(),
authors=authors,
tags=tags,
desc=desc,
icons=self.icons.copy(),
ent_count=props['ent_count', self.ent_count],
url=props['url', self.url],
all_name=self.all_name,
all_icon=self.all_icon,
source=f'{source} from {self.source}',
)
[variant.editor] = variant._modify_editoritems(
props,
[variant.editor],
pak_id,
source,
is_extra=False,
)
if 'extra' in props:
variant.editor_extra = variant._modify_editoritems(
props.find_key('extra'),
variant.editor_extra,
pak_id,
source,
is_extra=True)
return variant
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 res_conveyor_belt(inst: Entity, res: Property):
"""Create a conveyor belt.
Options:
SegmentInst: Generated at each square. ('track' is the name of the path.)
TrackTeleport: Set the track points so they teleport trains to the start.
Speed: The fixup or number for the train speed.
MotionTrig: If set, a trigger_multiple will be spawned that EnableMotions
weighted cubes. The value is the name of the relevant filter.
EndOutput: Adds an output to the last track. The value is the same as
outputs in VMFs.
RotateSegments: If true (default), force segments to face in the
direction of movement
RailTemplate: A template for the railings. This is made into a non-solid
func_brush, combining all sections.
"""
move_dist = srctools.conv_int(inst.fixup['$travel_distance'])
if move_dist <= 2:
# There isn't room for a catwalk, so don't bother.
inst.remove()
return
move_dir = Vec(1, 0, 0).rotate_by_str(inst.fixup['$travel_direction'])
move_dir.rotate_by_str(inst['angles'])
start_offset = srctools.conv_float(inst.fixup['$starting_position'], 0)
teleport_to_start = res.bool('TrackTeleport', True)
segment_inst_file = res['SegmentInst', '']
rail_template = res['RailTemplate', None]
vmf = inst.map
if segment_inst_file:
segment_inst_file = conditions.resolve_inst(segment_inst_file)[0]
track_speed = res['speed', None]
start_pos = Vec.from_str(inst['origin'])
end_pos = start_pos + move_dist * move_dir
if start_offset > 0:
# If an oscillating platform, move to the closest side..
offset = start_offset * move_dir
# The instance is placed this far along, so move back to the end.
start_pos -= offset
end_pos -= offset
if start_offset > 0.5:
# Swap the direction of movement..
start_pos, end_pos = end_pos, start_pos
inst['origin'] = start_pos
# Find the angle which generates an instance pointing in the direction
# of movement, with the same normal.
norm = Vec(z=1).rotate_by_str(inst['angles'])
for roll in range(0, 360, 90):
angles = move_dir.to_angle(roll)
if Vec(z=1).rotate(*angles) == norm:
break
else:
raise ValueError(
"Can't find angles to give a"
' z={} and x={}!'.format(norm, move_dir)
)
if res.bool('rotateSegments', True):
inst['angles'] = angles
else:
angles = Vec.from_str(inst['angles'])
# Add the EnableMotion trigger_multiple seen in platform items.
# This wakes up cubes when it starts moving.
motion_filter = res['motionTrig', None]
# Disable on walls, or if the conveyor can't be turned on.
if norm != (0, 0, 1) or inst.fixup['$connectioncount'] == '0':
motion_filter = None
track_name = conditions.local_name(inst, 'segment_{}')
rail_temp_solids = []
last_track = None
# Place beams at the top, so they don't appear inside wall sections.
beam_start = start_pos + 48 * norm # type: Vec
beam_end = end_pos + 48 * norm # type: Vec
for index, pos in enumerate(beam_start.iter_line(beam_end, stride=128), start=1):
track = vmf.create_ent(
classname='path_track',
targetname=track_name.format(index) + '-track',
origin=pos,
spawnflags=0,
orientationtype=0, # Don't rotate
)
if track_speed is not None:
track['speed'] = track_speed
if last_track:
last_track['target'] = track['targetname']
if index == 1 and teleport_to_start:
track['spawnflags'] = 16 # Teleport here..
last_track = track
# Don't place at the last point - it doesn't teleport correctly,
# and would be one too many.
if segment_inst_file and pos != end_pos:
seg_inst = vmf.create_ent(
classname='func_instance',
targetname=track_name.format(index),
file=segment_inst_file,
origin=pos,
angles=angles,
)
seg_inst.fixup.update(inst.fixup)
if rail_template:
temp = conditions.import_template(
rail_template,
pos,
angles,
force_type=conditions.TEMP_TYPES.world,
add_to_map=False,
)
rail_temp_solids.extend(temp.world)
if rail_temp_solids:
vmf.create_ent(
classname='func_brush',
origin=beam_start,
spawnflags=1, # Ignore +USE
solidity=1, # Not solid
vrad_brush_cast_shadows=1,
drawinfastreflection=1,
).solids = rail_temp_solids
if teleport_to_start:
# Link back to the first track..
last_track['target'] = track_name.format(1) + '-track'
# Generate an env_beam pointing from the start to the end of the track.
beam_keys = res.find_key('BeamKeys', [])
if beam_keys.value:
beam = vmf.create_ent(classname='env_beam')
# 3 offsets - x = distance from walls, y = side, z = height
beam_off = beam_keys.vec('origin', 0, 63, 56)
for prop in beam_keys:
beam[prop.real_name] = prop.value
# Localise the targetname so it can be triggered..
beam['LightningStart'] = beam['targetname'] = conditions.local_name(
inst,
beam['targetname', 'beam']
)
del beam['LightningEnd']
beam['origin'] = start_pos + Vec(
-beam_off.x, beam_off.y, beam_off.z,
).rotate(*angles)
beam['TargetPoint'] = end_pos + Vec(
+beam_off.x, beam_off.y, beam_off.z,
).rotate(*angles)
# Allow adding outputs to the last path_track.
for prop in res.find_all('EndOutput'):
output = Output.parse(prop)
output.output = 'OnPass'
output.inst_out = None
output.comma_sep = False
output.target = conditions.local_name(inst, output.target)
last_track.add_out(output)
if motion_filter is not None:
motion_trig = vmf.create_ent(
classname='trigger_multiple',
targetname=conditions.local_name(inst, 'enable_motion_trig'),
origin=start_pos,
filtername=motion_filter,
startDisabled=1,
wait=0.1,
)
motion_trig.add_out(Output('OnStartTouch', '!activator', 'ExitDisabledState'))
# Match the size of the original...
motion_trig.solids.append(vmf.make_prism(
start_pos + Vec(72, -56, 58).rotate(*angles),
end_pos + Vec(-72, 56, 144).rotate(*angles),
mat='tools/toolstrigger',
).solid)
if res.bool('NoPortalFloor'):
# Block portals on the floor..
floor_noportal = vmf.create_ent(
classname='func_noportal_volume',
origin=beam_start,
)
floor_noportal.solids.append(vmf.make_prism(
start_pos + Vec(-60, -60, -66).rotate(*angles),
end_pos + Vec(60, 60, -60).rotate(*angles),
mat='tools/toolsinvisible',
).solid)
# A brush covering under the platform.
base_trig = vmf.make_prism(
start_pos + Vec(-64, -64, 48).rotate(*angles),
end_pos + Vec(64, 64, 56).rotate(*angles),
mat='tools/toolsinvisible',
).solid
vmf.add_brush(base_trig)
# Make a paint_cleanser under the belt..
if res.bool('PaintFizzler'):
pfizz = vmf.create_ent(
classname='trigger_paint_cleanser',
origin=start_pos,
)
pfizz.solids.append(base_trig.copy())
for face in pfizz.sides():
face.mat = 'tools/toolstrigger'
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_antlaser(vmf: VMF, res: Property):
"""The condition to generate AntLasers.
This is executed once to modify all instances.
"""
conf_inst = instanceLocs.resolve(res['instance'])
conf_glow_height = Vec(z=res.float('GlowHeight', 48) - 64)
conf_las_start = Vec(z=res.float('LasStart') - 64)
conf_rope_off = res.vec('RopePos')
conf_toggle_targ = res['toggleTarg', '']
beam_conf = res.find_key('BeamKeys', [])
glow_conf = res.find_key('GlowKeys', [])
cable_conf = res.find_key('CableKeys', [])
if beam_conf:
# Grab a copy of the beam spawnflags so we can set our own options.
conf_beam_flags = beam_conf.int('spawnflags')
# Mask out certain flags.
conf_beam_flags &= (
0
| 1 # Start On
| 2 # Toggle
| 4 # Random Strike
| 8 # Ring
| 16 # StartSparks
| 32 # EndSparks
| 64 # Decal End
#| 128 # Shade Start
#| 256 # Shade End
#| 512 # Taper Out
)
else:
conf_beam_flags = 0
conf_outputs = [
Output.parse(prop) for prop in res
if prop.name in ('onenabled', 'ondisabled')
]
# Find all the markers.
nodes: Dict[str, connections.Item] = {}
for inst in vmf.by_class['func_instance']:
if inst['file'].casefold() not in conf_inst:
continue
name = inst['targetname']
try:
# Remove the item - it's no longer going to exist after
# we're done.
nodes[name] = connections.ITEMS.pop(name)
except KeyError:
raise ValueError('No item for "{}"?'.format(name)) from None
if not nodes:
# None at all.
return conditions.RES_EXHAUSTED
# Now find every connected group, recording inputs, outputs and links.
todo = set(nodes.values())
groups = [] # type: List[Group]
# Node -> is grouped already.
node_pairing = dict.fromkeys(nodes.values(), False)
while todo:
start = todo.pop()
# Synthesise the Item used for logic.
# We use a random info_target to manage the IO data.
group = Group(start)
groups.append(group)
for node in group.nodes:
# If this node has no non-node outputs, destroy the antlines.
has_output = False
node_pairing[node] = True
for conn in list(node.outputs):
neighbour = conn.to_item
todo.discard(neighbour)
pair_state = node_pairing.get(neighbour, None)
if pair_state is None:
# Not a node, a target of our logic.
conn.from_item = group.item
has_output = True
continue
elif pair_state is False:
# Another node.
group.nodes.append(neighbour)
# else: True, node already added.
# For nodes, connect link.
conn.remove()
group.links.add(frozenset({node, neighbour}))
# If we have a real output, we need to transfer it.
# Otherwise we can just destroy it.
if has_output:
node.transfer_antlines(group.item)
else:
node.delete_antlines()
# Do the same for inputs, so we can catch that.
for conn in list(node.inputs):
neighbour = conn.from_item
todo.discard(neighbour)
pair_state = node_pairing.get(neighbour, None)
if pair_state is None:
# Not a node, an input to the group.
conn.to_item = group.item
continue
elif pair_state is False:
# Another node.
group.nodes.append(neighbour)
# else: True, node already added.
# For nodes, connect link.
conn.remove()
group.links.add(frozenset({neighbour, node}))
# Now every node is in a group. Generate the actual entities.
for group in groups:
# We generate two ent types. For each marker, we add a sprite
# and a beam pointing at it. Then for each connection
# another beam.
# Choose a random antlaser name to use for our group.
base_name = group.nodes[0].name
out_enable = [Output('', '', 'FireUser2')]
out_disable = [Output('', '', 'FireUser1')]
for output in conf_outputs:
if output.output.casefold() == 'onenabled':
out_enable.append(output.copy())
else:
out_disable.append(output.copy())
if conf_toggle_targ:
# Make the group info_target into a texturetoggle.
toggle = group.item.inst
toggle['classname'] = 'env_texturetoggle'
toggle['target'] = conditions.local_name(group.nodes[0].inst,
conf_toggle_targ)
group.item.enable_cmd = tuple(out_enable)
group.item.disable_cmd = tuple(out_disable)
# Node -> index for targetnames.
indexes: Dict[connections.Item, int] = {}
# For cables, it's a bit trickier than the beams.
# The cable ent itself is the one which decides what it links to,
# so we need to potentially make endpoint cables at locations with
# only "incoming" lines.
# So this dict is either a targetname to indicate cables with an
# outgoing connection, or the entity for endpoints without an outgoing
# connection.
cable_points: Dict[connections.Item, Union[Entity, str]] = {}
for i, node in enumerate(group.nodes, start=1):
indexes[node] = i
node.name = base_name
sprite_pos = conf_glow_height.copy()
sprite_pos.localise(
Vec.from_str(node.inst['origin']),
Vec.from_str(node.inst['angles']),
)
if glow_conf:
# First add the sprite at the right height.
sprite = vmf.create_ent('env_sprite')
for prop in glow_conf:
sprite[prop.name] = conditions.resolve_value(
node.inst, prop.value)
sprite['origin'] = sprite_pos
sprite['targetname'] = NAME_SPR(base_name, i)
elif beam_conf:
# If beams but not sprites, we need a target.
vmf.create_ent(
'info_target',
origin=sprite_pos,
targetname=NAME_SPR(base_name, i),
)
if beam_conf:
# Now the beam going from below up to the sprite.
beam_pos = conf_las_start.copy()
beam_pos.localise(
Vec.from_str(node.inst['origin']),
Vec.from_str(node.inst['angles']),
)
beam = vmf.create_ent('env_beam')
for prop in beam_conf:
beam[prop.name] = conditions.resolve_value(
node.inst, prop.value)
beam['origin'] = beam['targetpoint'] = beam_pos
beam['targetname'] = NAME_BEAM_LOW(base_name, i)
beam['LightningStart'] = beam['targetname']
beam['LightningEnd'] = NAME_SPR(base_name, i)
beam['spawnflags'] = conf_beam_flags | 128 # Shade Start
if beam_conf:
for i, (node_a, node_b) in enumerate(group.links):
beam = vmf.create_ent('env_beam')
conditions.set_ent_keys(beam, node_a.inst, res, 'BeamKeys')
beam['origin'] = beam['targetpoint'] = node_a.inst['origin']
beam['targetname'] = NAME_BEAM_CONN(base_name, i)
beam['LightningStart'] = NAME_SPR(base_name, indexes[node_a])
beam['LightningEnd'] = NAME_SPR(base_name, indexes[node_b])
beam['spawnflags'] = conf_beam_flags
# We have a couple different situations to deal with here.
# Either end could Not exist, be Unlinked, or be Linked = 8 combos.
# Always flip so we do A to B.
# AB |
# NN | Make 2 new ones, one is an endpoint.
# NU | Flip, do UN.
# NL | Make A, link A to B. Both are linked.
# UN | Make B, link A to B. B is unlinked.
# UU | Link A to B, A is now linked, B is unlinked.
# UL | Link A to B. Both are linked.
# LN | Flip, do NL.
# LU | Flip, do UL
# LL | Make A, link A to B. Both are linked.
if cable_conf:
rope_ind = 0 # Uniqueness value.
for node_a, node_b in group.links:
state_a, ent_a = RopeState.from_node(cable_points, node_a)
state_b, ent_b = RopeState.from_node(cable_points, node_b)
if (state_a is RopeState.LINKED
or (state_a is RopeState.NONE
and state_b is RopeState.UNLINKED)):
# Flip these, handle the opposite order.
state_a, state_b = state_b, state_a
ent_a, ent_b = ent_b, ent_a
node_a, node_b = node_b, node_a
pos_a = conf_rope_off.copy()
pos_a.localise(
Vec.from_str(node_a.inst['origin']),
Vec.from_str(node_a.inst['angles']),
)
pos_b = conf_rope_off.copy()
pos_b.localise(
Vec.from_str(node_b.inst['origin']),
Vec.from_str(node_b.inst['angles']),
)
# Need to make the A rope if we don't have one that's unlinked.
if state_a is not RopeState.UNLINKED:
rope_a = vmf.create_ent('move_rope')
for prop in beam_conf:
rope_a[prop.name] = conditions.resolve_value(
node_a.inst, prop.value)
rope_a['origin'] = pos_a
rope_ind += 1
rope_a['targetname'] = NAME_CABLE(base_name, rope_ind)
else:
# It is unlinked, so it's the rope to use.
rope_a = ent_a
# Only need to make the B rope if it doesn't have one.
if state_b is RopeState.NONE:
rope_b = vmf.create_ent('move_rope')
for prop in beam_conf:
rope_b[prop.name] = conditions.resolve_value(
node_b.inst, prop.value)
rope_b['origin'] = pos_b
rope_ind += 1
name_b = rope_b['targetname'] = NAME_CABLE(
base_name, rope_ind)
cable_points[node_b] = rope_b # Someone can use this.
elif state_b is RopeState.UNLINKED:
# Both must be unlinked, we aren't using this link though.
name_b = ent_b['targetname']
else: # Linked, we just have the name.
name_b = ent_b
# By here, rope_a should be an unlinked rope,
# and name_b should be a name to link to.
rope_a['nextkey'] = name_b
# Figure out how much slack to give.
# If on floor, we need to be taut to have clearance.
if on_floor(node_a) or on_floor(node_b):
rope_a['slack'] = 60
else:
rope_a['slack'] = 125
# We're always linking A to B, so A is always linked!
if state_a is not RopeState.LINKED:
cable_points[node_a] = rope_a['targetname']
return conditions.RES_EXHAUSTED
def res_cutout_tile(vmf: srctools.VMF, res: Property):
"""Generate random quarter tiles, like in Destroyed or Retro maps.
- `MarkerItem` is the instance file to look for (`<ITEM_BEE2_CUTOUT_TILE>`)
- `floor_chance`: The percentage change for a segment in the middle of the floor to be a normal tile.
- `floor_glue_chance`: The chance for any tile to be glue - this should be higher than the regular chance, as that overrides this.
- `rotateMax` is the maximum angle to rotate squarebeam models.
- `squarebeamsSkin` sets the skin to use for the squarebeams floor frame.
- `dispBase`, if true makes the floor a displacement with random alpha.
- `Materials` blocks specify the possible materials to use:
- `squarebeams` is the squarebeams variant to use.
- `ceilingwalls` are the sides of the ceiling section.
- `floorbase` is the texture under floor sections.
If `dispBase` is True this is a displacement material.
- `tile_glue` is used on top of a thinner tile segment.
- `clip` is the player_clip texture used over floor segments.
(This allows customising the surfaceprop.)
"""
marker_filenames = instanceLocs.resolve(res['markeritem'])
# TODO: Reimplement cutout tiles.
for inst in vmf.by_class['func_instance']:
if inst['file'].casefold() in marker_filenames:
inst.remove()
return
x: float
y: float
max_x: float
max_y: float
INST_LOCS = {} # Map targetnames -> surface loc
CEIL_IO = [] # Pairs of ceil inst corners to cut out.
FLOOR_IO = [] # Pairs of floor inst corners to cut out.
overlay_ids = {} # When we replace brushes, we need to fix any overlays
# on that surface.
MATS.clear()
floor_edges = [] # Values to pass to add_floor_sides() at the end
sign_locs = set()
# If any signage is present in the map, we need to force tiles to
# appear at that location!
for over in vmf.by_class['info_overlay']:
if (over['material'].casefold() in FORCE_TILE_MATS and
# Only check floor/ceiling overlays
over['basisnormal'] in ('0 0 1', '0 0 -1')):
add_signage_loc(sign_locs, Vec.from_str(over['origin']))
for item in connections.ITEMS.values():
for ind_pan in item.ind_panels:
loc = Vec(0, 0, -64)
loc.localise(
Vec.from_str(ind_pan['origin']),
Vec.from_str(ind_pan['angles']),
)
add_signage_loc(sign_locs, loc)
SETTINGS = {
'floor_chance':
srctools.conv_int(res['floorChance', '100'], 100),
'ceil_chance':
srctools.conv_int(res['ceilingChance', '100'], 100),
'floor_glue_chance':
srctools.conv_int(res['floorGlueChance', '0']),
'ceil_glue_chance':
srctools.conv_int(res['ceilingGlueChance', '0']),
'rotate_beams':
int(srctools.conv_float(res['rotateMax', '0']) * BEAM_ROT_PRECISION),
'beam_skin':
res['squarebeamsSkin', '0'],
'base_is_disp':
srctools.conv_bool(res['dispBase', '0']),
'quad_floor':
res['FloorSize', '4x4'].casefold() == '2x2',
'quad_ceil':
res['CeilingSize', '4x4'].casefold() == '2x2',
}
random.seed(vbsp.MAP_RAND_SEED + '_CUTOUT_TILE_NOISE')
noise = SimplexNoise(period=4 * 40) # 4 tiles/block, 50 blocks max
# We want to know the number of neighbouring tile cutouts before
# placing tiles - blocks away from the sides generate fewer tiles.
# all_floors[z][x,y] = count
floor_neighbours = defaultdict(
dict) # type: Dict[float, Dict[Tuple[float, float], int]]
for mat_prop in res.find_key('Materials', []):
MATS[mat_prop.name].append(mat_prop.value)
if SETTINGS['base_is_disp']:
# We want the normal brushes to become nodraw.
MATS['floorbase_disp'] = MATS['floorbase']
MATS['floorbase'] = ['tools/toolsnodraw']
# Since this uses random data for initialisation, the alpha and
# regular will use slightly different patterns.
alpha_noise = SimplexNoise(period=4 * 50)
else:
alpha_noise = None
for key, default in TEX_DEFAULT:
if key not in MATS:
MATS[key] = [default]
# Find our marker ents
for inst in vmf.by_class['func_instance']:
if inst['file'].casefold() not in marker_filenames:
continue
targ = inst['targetname']
normal = Vec(0, 0, 1).rotate_by_str(inst['angles', '0 0 0'])
# Check the orientation of the marker to figure out what to generate
if normal == (0, 0, 1):
io_list = FLOOR_IO
else:
io_list = CEIL_IO
# Reuse orient to calculate where the solid face will be.
loc = Vec.from_str(inst['origin']) - 64 * normal
INST_LOCS[targ] = loc
item = connections.ITEMS[targ]
item.delete_antlines()
if item.outputs:
for conn in list(item.outputs):
if conn.to_item.inst['file'].casefold() in marker_filenames:
io_list.append((targ, conn.to_item.name))
else:
LOGGER.warning('Cutout tile connected to non-cutout!')
conn.remove() # Delete the connection.
else:
# If the item doesn't have any connections, 'connect'
# it to itself so we'll generate a 128x128 tile segment.
io_list.append((targ, targ))
# Remove all traces of this item (other than in connections lists).
inst.remove()
del connections.ITEMS[targ]
for start_floor, end_floor in FLOOR_IO:
box_min = Vec(INST_LOCS[start_floor])
box_min.min(INST_LOCS[end_floor])
box_max = Vec(INST_LOCS[start_floor])
box_max.max(INST_LOCS[end_floor])
if box_min.z != box_max.z:
continue # They're not in the same level!
z = box_min.z
if SETTINGS['rotate_beams']:
# We have to generate 1 model per 64x64 block to do rotation...
gen_rotated_squarebeams(
vmf,
box_min - (64, 64, 0),
box_max + (64, 64, -8),
skin=SETTINGS['beam_skin'],
max_rot=SETTINGS['rotate_beams'],
)
else:
# Make the squarebeams props, using big models if possible
gen_squarebeams(vmf,
box_min + (-64, -64, 0),
box_max + (64, 64, -8),
skin=SETTINGS['beam_skin'])
# Add a player_clip brush across the whole area
vmf.add_brush(
vmf.make_prism(
p1=box_min - (64, 64, FLOOR_DEPTH),
p2=box_max + (64, 64, 0),
mat=MATS['clip'][0],
).solid)
# Add a noportal_volume covering the surface, in case there's
# room for a portal.
noportal_solid = vmf.make_prism(
# Don't go all the way to the sides, so it doesn't affect wall
# brushes.
p1=box_min - (63, 63, 9),
p2=box_max + (63, 63, 0),
mat='tools/toolsinvisible',
).solid
noportal_ent = vmf.create_ent(
classname='func_noportal_volume',
origin=box_min.join(' '),
)
noportal_ent.solids.append(noportal_solid)
if SETTINGS['base_is_disp']:
# Use displacements for the base instead.
make_alpha_base(
vmf,
box_min + (-64, -64, 0),
box_max + (64, 64, 0),
noise=alpha_noise,
)
for x, y in utils.iter_grid(
min_x=int(box_min.x),
max_x=int(box_max.x) + 1,
min_y=int(box_min.y),
max_y=int(box_max.y) + 1,
stride=128,
):
# Build the set of all positions..
floor_neighbours[z][x, y] = -1
# Mark borders we need to fill in, and the angle (for func_instance)
# The wall is the face pointing inwards towards the bottom brush,
# and the ceil is the ceiling of the block above the bordering grid
# points.
for x in range(int(box_min.x), int(box_max.x) + 1, 128):
# North
floor_edges.append(
BorderPoints(
wall=Vec(x, box_max.y + 64, z - 64),
ceil=Vec_tuple(x, box_max.y + 128, z),
rot=270,
))
# South
floor_edges.append(
BorderPoints(
wall=Vec(x, box_min.y - 64, z - 64),
ceil=Vec_tuple(x, box_min.y - 128, z),
rot=90,
))
for y in range(int(box_min.y), int(box_max.y) + 1, 128):
# East
floor_edges.append(
BorderPoints(
wall=Vec(box_max.x + 64, y, z - 64),
ceil=Vec_tuple(box_max.x + 128, y, z),
rot=180,
))
# West
floor_edges.append(
BorderPoints(
wall=Vec(box_min.x - 64, y, z - 64),
ceil=Vec_tuple(box_min.x - 128, y, z),
rot=0,
))
# Now count boundaries near tiles, then generate them.
# Do it separately for each z-level:
for z, xy_dict in floor_neighbours.items():
for x, y in xy_dict:
# We want to count where there aren't any tiles
xy_dict[x, y] = (((x - 128, y - 128) not in xy_dict) +
((x - 128, y + 128) not in xy_dict) +
((x + 128, y - 128) not in xy_dict) +
((x + 128, y + 128) not in xy_dict) +
((x - 128, y) not in xy_dict) +
((x + 128, y) not in xy_dict) +
((x, y - 128) not in xy_dict) +
((x, y + 128) not in xy_dict))
max_x = max_y = 0
weights = {}
# Now the counts are all correct, compute the weight to apply
# for tiles.
# Adding the neighbouring counts will make a 5x5 area needed to set
# the center to 0.
for (x, y), cur_count in xy_dict.items():
max_x = max(x, max_x)
max_y = max(y, max_y)
# Orthrogonal is worth 0.2, diagonal is worth 0.1.
# Not-present tiles would be 8 - the maximum
tile_count = (0.8 * cur_count + 0.1 * xy_dict.get(
(x - 128, y - 128), 8) + 0.1 * xy_dict.get(
(x - 128, y + 128), 8) + 0.1 * xy_dict.get(
(x + 128, y - 128), 8) + 0.1 * xy_dict.get(
(x + 128, y + 128), 8) + 0.2 * xy_dict.get(
(x - 128, y), 8) + 0.2 * xy_dict.get(
(x, y - 128), 8) + 0.2 * xy_dict.get(
(x, y + 128), 8) + 0.2 * xy_dict.get(
(x + 128, y), 8))
# The number ranges from 0 (all tiles) to 12.8 (no tiles).
# All tiles should still have a small chance to generate tiles.
weights[x, y] = min((tile_count + 0.5) / 8, 1)
# Share the detail entity among same-height tiles..
detail_ent = vmf.create_ent(classname='func_detail', )
for x, y in xy_dict:
convert_floor(
vmf,
Vec(x, y, z),
overlay_ids,
MATS,
SETTINGS,
sign_locs,
detail_ent,
noise_weight=weights[x, y],
noise_func=noise,
)
add_floor_sides(vmf, floor_edges)
return conditions.RES_EXHAUSTED
def res_antlaser(vmf: VMF, res: Property):
"""The condition to generate AntLasers.
This is executed once to modify all instances.
"""
conf_inst = instanceLocs.resolve(res['instance'])
conf_glow_height = Vec(z=res.float('GlowHeight', 48) - 64)
conf_las_start = Vec(z=res.float('LasStart') - 64)
conf_rope_off = res.vec('RopePos')
conf_toggle_targ = res['toggleTarg', '']
beam_conf = res.find_key('BeamKeys', [])
glow_conf = res.find_key('GlowKeys', [])
cable_conf = res.find_key('CableKeys', [])
if beam_conf:
# Grab a copy of the beam spawnflags so we can set our own options.
conf_beam_flags = beam_conf.int('spawnflags')
# Mask out certain flags.
conf_beam_flags &= (
0
| 1 # Start On
| 2 # Toggle
| 4 # Random Strike
| 8 # Ring
| 16 # StartSparks
| 32 # EndSparks
| 64 # Decal End
#| 128 # Shade Start
#| 256 # Shade End
#| 512 # Taper Out
)
else:
conf_beam_flags = 0
conf_outputs = [
Output.parse(prop)
for prop in res
if prop.name in ('onenabled', 'ondisabled')
]
# Find all the markers.
nodes = {} # type: Dict[str, Item]
for inst in vmf.by_class['func_instance']:
if inst['file'].casefold() not in conf_inst:
continue
name = inst['targetname']
try:
# Remove the item - it's no longer going to exist after
# we're done.
nodes[name] = connections.ITEMS.pop(name)
except KeyError:
raise ValueError('No item for "{}"?'.format(name)) from None
if not nodes:
# None at all.
return conditions.RES_EXHAUSTED
# Now find every connected group, recording inputs, outputs and links.
todo = set(nodes.values())
groups = [] # type: List[Group]
# Node -> is grouped already.
node_pairing = dict.fromkeys(nodes.values(), False)
while todo:
start = todo.pop()
# Synthesise the Item used for logic.
# We use a random info_target to manage the IO data.
group = Group(start)
groups.append(group)
for node in group.nodes:
# If this node has no non-node outputs, destroy the antlines.
has_output = False
node_pairing[node] = True
for conn in list(node.outputs):
neighbour = conn.to_item
todo.discard(neighbour)
pair_state = node_pairing.get(neighbour, None)
if pair_state is None:
# Not a node, a target of our logic.
conn.from_item = group.item
has_output = True
continue
elif pair_state is False:
# Another node.
group.nodes.append(neighbour)
# else: True, node already added.
# For nodes, connect link.
conn.remove()
group.links.add(frozenset({node, neighbour}))
# If we have a real output, we need to transfer it.
# Otherwise we can just destroy it.
if has_output:
node.transfer_antlines(group.item)
else:
node.delete_antlines()
# Do the same for inputs, so we can catch that.
for conn in list(node.inputs):
neighbour = conn.from_item
todo.discard(neighbour)
pair_state = node_pairing.get(neighbour, None)
if pair_state is None:
# Not a node, an input to the group.
conn.to_item = group.item
continue
elif pair_state is False:
# Another node.
group.nodes.append(neighbour)
# else: True, node already added.
# For nodes, connect link.
conn.remove()
group.links.add(frozenset({neighbour, node}))
# Now every node is in a group. Generate the actual entities.
for group in groups:
# We generate two ent types. For each marker, we add a sprite
# and a beam pointing at it. Then for each connection
# another beam.
# Choose a random antlaser name to use for our group.
base_name = group.nodes[0].name
out_enable = [Output('', '', 'FireUser2')]
out_disable = [Output('', '', 'FireUser1')]
for output in conf_outputs:
if output.output.casefold() == 'onenabled':
out_enable.append(output.copy())
else:
out_disable.append(output.copy())
if conf_toggle_targ:
# Make the group info_target into a texturetoggle.
toggle = group.item.inst
toggle['classname'] = 'env_texturetoggle'
toggle['target'] = conditions.local_name(group.nodes[0].inst, conf_toggle_targ)
group.item.enable_cmd = tuple(out_enable)
group.item.disable_cmd = tuple(out_disable)
# Node -> index for targetnames.
indexes = {} # type: Dict[Item, int]
# For cables, it's a bit trickier than the beams.
# The cable ent itself is the one which decides what it links to,
# so we need to potentially make endpoint cables at locations with
# only "incoming" lines.
# So this dict is either a targetname to indicate cables with an
# outgoing connection, or the entity for endpoints without an outgoing
# connection.
cable_points = {} # type: Dict[Item, Union[Entity, str]]
for i, node in enumerate(group.nodes, start=1):
indexes[node] = i
node.name = base_name
sprite_pos = conf_glow_height.copy()
sprite_pos.localise(
Vec.from_str(node.inst['origin']),
Vec.from_str(node.inst['angles']),
)
if glow_conf:
# First add the sprite at the right height.
sprite = vmf.create_ent('env_sprite')
for prop in glow_conf:
sprite[prop.name] = conditions.resolve_value(node.inst, prop.value)
sprite['origin'] = sprite_pos
sprite['targetname'] = NAME_SPR(base_name, i)
elif beam_conf:
# If beams but not sprites, we need a target.
vmf.create_ent(
'info_target',
origin=sprite_pos,
targetname=NAME_SPR(base_name, i),
)
if beam_conf:
# Now the beam going from below up to the sprite.
beam_pos = conf_las_start.copy()
beam_pos.localise(
Vec.from_str(node.inst['origin']),
Vec.from_str(node.inst['angles']),
)
beam = vmf.create_ent('env_beam')
for prop in beam_conf:
beam[prop.name] = conditions.resolve_value(node.inst, prop.value)
beam['origin'] = beam['targetpoint'] = beam_pos
beam['targetname'] = NAME_BEAM_LOW(base_name, i)
beam['LightningStart'] = beam['targetname']
beam['LightningEnd'] = NAME_SPR(base_name, i)
beam['spawnflags'] = conf_beam_flags | 128 # Shade Start
if beam_conf:
for i, (node_a, node_b) in enumerate(group.links):
beam = vmf.create_ent('env_beam')
conditions.set_ent_keys(beam, node_a.inst, res, 'BeamKeys')
beam['origin'] = beam['targetpoint'] = node_a.inst['origin']
beam['targetname'] = NAME_BEAM_CONN(base_name, i)
beam['LightningStart'] = NAME_SPR(base_name, indexes[node_a])
beam['LightningEnd'] = NAME_SPR(base_name, indexes[node_b])
beam['spawnflags'] = conf_beam_flags
# We have a couple different situations to deal with here.
# Either end could Not exist, be Unlinked, or be Linked = 8 combos.
# Always flip so we do A to B.
# AB |
# NN | Make 2 new ones, one is an endpoint.
# NU | Flip, do UN.
# NL | Make A, link A to B. Both are linked.
# UN | Make B, link A to B. B is unlinked.
# UU | Link A to B, A is now linked, B is unlinked.
# UL | Link A to B. Both are linked.
# LN | Flip, do NL.
# LU | Flip, do UL
# LL | Make A, link A to B. Both are linked.
if cable_conf:
rope_ind = 0 # Uniqueness value.
for node_a, node_b in group.links:
state_a, ent_a = RopeState.from_node(cable_points, node_a)
state_b, ent_b = RopeState.from_node(cable_points, node_b)
if (state_a is RopeState.LINKED
or (state_a is RopeState.NONE and
state_b is RopeState.UNLINKED)
):
# Flip these, handle the opposite order.
state_a, state_b = state_b, state_a
ent_a, ent_b = ent_b, ent_a
node_a, node_b = node_b, node_a
pos_a = conf_rope_off.copy()
pos_a.localise(
Vec.from_str(node_a.inst['origin']),
Vec.from_str(node_a.inst['angles']),
)
pos_b = conf_rope_off.copy()
pos_b.localise(
Vec.from_str(node_b.inst['origin']),
Vec.from_str(node_b.inst['angles']),
)
# Need to make the A rope if we don't have one that's unlinked.
if state_a is not RopeState.UNLINKED:
rope_a = vmf.create_ent('move_rope')
for prop in beam_conf:
rope_a[prop.name] = conditions.resolve_value(node_a.inst, prop.value)
rope_a['origin'] = pos_a
rope_ind += 1
rope_a['targetname'] = NAME_CABLE(base_name, rope_ind)
else:
# It is unlinked, so it's the rope to use.
rope_a = ent_a
# Only need to make the B rope if it doesn't have one.
if state_b is RopeState.NONE:
rope_b = vmf.create_ent('move_rope')
for prop in beam_conf:
rope_b[prop.name] = conditions.resolve_value(node_b.inst, prop.value)
rope_b['origin'] = pos_b
rope_ind += 1
name_b = rope_b['targetname'] = NAME_CABLE(base_name, rope_ind)
cable_points[node_b] = rope_b # Someone can use this.
elif state_b is RopeState.UNLINKED:
# Both must be unlinked, we aren't using this link though.
name_b = ent_b['targetname']
else: # Linked, we just have the name.
name_b = ent_b
# By here, rope_a should be an unlinked rope,
# and name_b should be a name to link to.
rope_a['nextkey'] = name_b
# Figure out how much slack to give.
# If on floor, we need to be taut to have clearance.
if on_floor(node_a) or on_floor(node_b):
rope_a['slack'] = 60
else:
rope_a['slack'] = 125
# We're always linking A to B, so A is always linked!
if state_a is not RopeState.LINKED:
cable_points[node_a] = rope_a['targetname']
return conditions.RES_EXHAUSTED
def res_make_tag_fizzler(vmf: VMF, res: Property):
"""Add an Aperture Tag Paint Gun activation fizzler.
These fizzlers are created via signs, and work very specially.
This must be before -250 so it runs before fizzlers and connections.
"""
if 'ioconf' in res:
fizz_conn_conf = Config.parse('<TAG_FIZZER>', res.find_key('ioconf'))
else:
fizz_conn_conf = None
# The distance from origin the double signs are seperated by.
sign_offset = res.int('signoffset', 16)
inst_frame_double = res['frame_double']
inst_frame_single = res['frame_single']
blue_sign_on = res['blue_sign', '']
blue_sign_off = res['blue_off_sign', '']
oran_sign_on = res['oran_sign', '']
oran_sign_off = res['oran_off_sign', '']
import vbsp
if options.get(str, 'game_id') != utils.STEAM_IDS['TAG']:
# Abort - TAG fizzlers shouldn't appear in any other game!
# So simply remove the fizzler.
return Entity.remove
def make_tag_fizz(inst: Entity) -> None:
"""Create the Tag fizzler."""
fizzler: Optional[Fizzler] = None
fizzler_item: Optional[Item] = None
# Look for the fizzler instance we want to replace.
sign_item = connections.ITEMS[inst['targetname']]
for conn in list(sign_item.outputs):
if conn.to_item.name in FIZZLERS:
if fizzler is None:
fizzler = FIZZLERS[conn.to_item.name]
fizzler_item = conn.to_item
else:
raise ValueError('Multiple fizzlers attached to a sign!')
conn.remove() # Regardless, remove the useless output.
sign_item.delete_antlines()
if fizzler is None:
# No fizzler - remove this sign
inst.remove()
return
if fizzler.fizz_type.id == TAG_FIZZ_ID:
LOGGER.warning('Two tag signs attached to one fizzler...')
inst.remove()
return
# Swap to the special Tag Fizzler type.
fizzler.fizz_type = FIZZ_TYPES[TAG_FIZZ_ID]
# And also swap the connection's type.
if fizz_conn_conf is not None:
fizzler_item.config = fizz_conn_conf
fizzler_item.enable_cmd = fizz_conn_conf.enable_cmd
fizzler_item.disable_cmd = fizz_conn_conf.disable_cmd
fizzler_item.sec_enable_cmd = fizz_conn_conf.sec_enable_cmd
fizzler_item.sec_disable_cmd = fizz_conn_conf.sec_disable_cmd
inst_orient = Matrix.from_angle(Angle.from_str(inst['angles']))
# The actual location of the sign - on the wall
sign_loc = Vec.from_str(inst['origin']) + Vec(0, 0, -64) @ inst_orient
fizz_norm_axis = round(fizzler.normal(), 3).axis()
# Now deal with the visual aspect:
# Blue signs should be on top.
blue_enabled = inst.fixup.bool('$start_enabled')
oran_enabled = inst.fixup.bool('$start_reversed')
# If True, single-color signs will also turn off the other color.
# This also means we always show both signs.
# If both are enabled or disabled, this has no effect.
disable_other = (not inst.fixup.bool('$disable_autorespawn', True)
and blue_enabled != oran_enabled)
# Delete fixups now, they aren't useful.
inst.fixup.clear()
if not blue_enabled and not oran_enabled:
# Hide the sign in this case!
inst.remove()
inst_normal = inst_orient.up()
loc = Vec.from_str(inst['origin'])
if disable_other or (blue_enabled and oran_enabled):
inst['file'] = inst_frame_double
conditions.ALL_INST.add(inst_frame_double.casefold())
# On a wall, and pointing vertically
if abs(inst_normal.z) < 0.01 and abs(inst_orient.left().z) > 0.01:
# They're vertical, make sure blue's on top!
blue_loc = Vec(loc.x, loc.y, loc.z + sign_offset)
oran_loc = Vec(loc.x, loc.y, loc.z - sign_offset)
# If orange is enabled, with two frames put that on top
# instead since it's more important
if disable_other and oran_enabled:
blue_loc, oran_loc = oran_loc, blue_loc
else:
offset = Vec(0, sign_offset, 0) @ inst_orient
blue_loc = loc + offset
oran_loc = loc - offset
else:
inst['file'] = inst_frame_single
conditions.ALL_INST.add(inst_frame_single.casefold())
# They're always centered
blue_loc = loc
oran_loc = loc
if inst_normal.z != 0:
# If on floors/ceilings, rotate to point at the fizzler!
sign_floor_loc = sign_loc.copy()
sign_floor_loc.z = 0 # We don't care about z-positions.
s, l = Vec.bbox(itertools.chain.from_iterable(fizzler.emitters))
if fizz_norm_axis == 'z':
# For z-axis, just compare to the center point of the emitters.
sign_dir = ((s.x + l.x) / 2,
(s.y + l.y) / 2, 0) - sign_floor_loc
else:
# For the other two, we compare to the line,
# or compare to the closest side (in line with the fizz)
if fizz_norm_axis == 'x': # Extends in Y direction
other_axis = 'y'
side_min = s.y
side_max = l.y
normal = s.x
else: # Extends in X direction
other_axis = 'x'
side_min = s.x
side_max = l.x
normal = s.y
# Right in line with the fizzler. Point at the closest emitter.
if abs(sign_floor_loc[other_axis] - normal) < 32:
# Compare to the closest side.
sign_dir = min([
sign_floor_loc - Vec.with_axes(
fizz_norm_axis,
side_min,
other_axis,
normal,
), sign_floor_loc - Vec.with_axes(
fizz_norm_axis,
side_max,
other_axis,
normal,
)
],
key=Vec.mag)
else:
# Align just based on whether we're in front or behind.
sign_dir = Vec.with_axes(
fizz_norm_axis,
normal - sign_floor_loc[fizz_norm_axis]).norm()
sign_yaw = math.degrees(math.atan2(sign_dir.y, sign_dir.x))
# Round to nearest 90 degrees
# Add 45 so the switchover point is at the diagonals
sign_yaw = (sign_yaw + 45) // 90 * 90
# Rotate to fit the instances - south is down
sign_yaw = int(sign_yaw - 90) % 360
if inst_normal.z > 0:
sign_angle = '0 {} 0'.format(sign_yaw)
elif inst_normal.z < 0:
# Flip upside-down for ceilings
sign_angle = '0 {} 180'.format(sign_yaw)
else:
raise AssertionError('Cannot be zero here!')
else:
# On a wall, face upright
sign_angle = conditions.PETI_INST_ANGLE[inst_normal.as_tuple()]
# If disable_other, we show off signs. Otherwise we don't use that sign.
blue_sign = blue_sign_on if blue_enabled else blue_sign_off if disable_other else None
oran_sign = oran_sign_on if oran_enabled else oran_sign_off if disable_other else None
if blue_sign:
conditions.add_inst(
vmf,
file=blue_sign,
targetname=inst['targetname'],
angles=sign_angle,
origin=blue_loc,
)
if oran_sign:
conditions.add_inst(
vmf,
file=oran_sign,
targetname=inst['targetname'],
angles=sign_angle,
origin=oran_loc,
)
# Now modify the fizzler...
# Subtract the sign from the list of connections, but don't go below
# zero
fizzler.base_inst.fixup['$connectioncount'] = max(
0,
fizzler.base_inst.fixup.int('$connectioncount') - 1)
# Find the direction the fizzler normal is.
# Signs will associate with the given side!
bbox_min, bbox_max = fizzler.emitters[0]
sign_center = (bbox_min[fizz_norm_axis] + bbox_max[fizz_norm_axis]) / 2
# Figure out what the sides will set values to...
pos_blue = pos_oran = False
neg_blue = neg_oran = False
if sign_loc[fizz_norm_axis] < sign_center:
pos_blue = blue_enabled
pos_oran = oran_enabled
else:
neg_blue = blue_enabled
neg_oran = oran_enabled
# If it activates the paint gun, use different textures
fizzler.tag_on_pos = pos_blue or pos_oran
fizzler.tag_on_neg = neg_blue or neg_oran
# Now make the trigger ents. We special-case these since they need to
# swap
# depending on the sign config and position.
if vbsp.GAME_MODE == 'COOP':
# We need ATLAS-specific triggers.
pos_trig = vmf.create_ent(classname='trigger_playerteam')
neg_trig = vmf.create_ent(classname='trigger_playerteam')
output = 'OnStartTouchBluePlayer'
else:
pos_trig = vmf.create_ent(classname='trigger_multiple')
neg_trig = vmf.create_ent(classname='trigger_multiple')
output = 'OnStartTouch'
pos_trig['origin'] = neg_trig['origin'] = fizzler.base_inst['origin']
pos_trig['spawnflags'] = neg_trig['spawnflags'] = '1' # Clients Only
pos_trig['targetname'] = conditions.local_name(fizzler.base_inst,
'trig_pos')
neg_trig['targetname'] = conditions.local_name(fizzler.base_inst,
'trig_neg')
pos_trig['startdisabled'] = neg_trig['startdisabled'] = (
not fizzler.base_inst.fixup.bool('start_enabled'))
pos_trig.outputs = [
Output(output, neg_trig, 'Enable'),
Output(output, pos_trig, 'Disable'),
]
neg_trig.outputs = [
Output(output, pos_trig, 'Enable'),
Output(output, neg_trig, 'Disable'),
]
voice_attr = vbsp.settings['has_attr']
if blue_enabled or disable_other:
# If this is blue/oran only, don't affect the other color
neg_trig.outputs.append(
Output(
output,
'@BlueIsEnabled',
'SetValue',
neg_blue,
))
pos_trig.outputs.append(
Output(
output,
'@BlueIsEnabled',
'SetValue',
pos_blue,
))
if blue_enabled:
# Add voice attributes - we have the gun and gel!
voice_attr['bluegelgun'] = True
voice_attr['bluegel'] = True
voice_attr['bouncegun'] = True
voice_attr['bouncegel'] = True
if oran_enabled or disable_other:
neg_trig.outputs.append(
Output(
output,
'@OrangeIsEnabled',
'SetValue',
param=srctools.bool_as_int(neg_oran),
))
pos_trig.outputs.append(
Output(
output,
'@OrangeIsEnabled',
'SetValue',
param=srctools.bool_as_int(pos_oran),
))
if oran_enabled:
voice_attr['orangegelgun'] = True
voice_attr['orangegel'] = True
voice_attr['speedgelgun'] = True
voice_attr['speedgel'] = True
if not oran_enabled and not blue_enabled:
# If both are disabled, we must shutdown the gun when touching
# either side - use neg_trig for that purpose!
# We want to get rid of pos_trig to save ents
vmf.remove_ent(pos_trig)
neg_trig['targetname'] = conditions.local_name(
fizzler.base_inst, 'trig_off')
neg_trig.outputs.clear()
neg_trig.add_out(
Output(output, '@BlueIsEnabled', 'SetValue', param='0'))
neg_trig.add_out(
Output(output, '@OrangeIsEnabled', 'SetValue', param='0'))
# Make the triggers.
for bbox_min, bbox_max in fizzler.emitters:
bbox_min = bbox_min.copy() - 64 * fizzler.up_axis
bbox_max = bbox_max.copy() + 64 * fizzler.up_axis
# The triggers are 8 units thick, with a 32-unit gap in the middle
neg_min, neg_max = Vec(bbox_min), Vec(bbox_max)
neg_min[fizz_norm_axis] -= 24
neg_max[fizz_norm_axis] -= 16
pos_min, pos_max = Vec(bbox_min), Vec(bbox_max)
pos_min[fizz_norm_axis] += 16
pos_max[fizz_norm_axis] += 24
if blue_enabled or oran_enabled:
neg_trig.solids.append(
vmf.make_prism(
neg_min,
neg_max,
mat='tools/toolstrigger',
).solid, )
pos_trig.solids.append(
vmf.make_prism(
pos_min,
pos_max,
mat='tools/toolstrigger',
).solid, )
else:
# If neither enabled, use one trigger
neg_trig.solids.append(
vmf.make_prism(
neg_min,
pos_max,
mat='tools/toolstrigger',
).solid, )
return make_tag_fizz
def res_conveyor_belt(vmf: VMF, inst: Entity, res: Property) -> None:
"""Create a conveyor belt.
* Options:
* `SegmentInst`: Generated at each square. (`track` is the name of the
path to attach to.)
* `TrackTeleport`: Set the track points so they teleport trains to the start.
* `Speed`: The fixup or number for the train speed.
* `MotionTrig`: If set, a trigger_multiple will be spawned that
`EnableMotion`s weighted cubes. The value is the name of the relevant filter.
* `EndOutput`: Adds an output to the last track. The value is the same as
outputs in VMFs.
`RotateSegments`: If true (default), force segments to face in the
direction of movement.
* `BeamKeys`: If set, a list of keyvalues to use to generate an env_beam
travelling from start to end. The origin is treated specially - X is
the distance from walls, y is the distance to the side, and z is the
height.
`RailTemplate`: A template for the track sections. This is made into a
non-solid func_brush, combining all sections.
* `NoPortalFloor`: If set, add a `func_noportal_volume` on the floor
under the track.
* `PaintFizzler`: If set, add a paint fizzler underneath the belt.
"""
move_dist = inst.fixup.int('$travel_distance')
if move_dist <= 2:
# There isn't room for a conveyor, so don't bother.
inst.remove()
return
orig_orient = Matrix.from_angle(Angle.from_str(inst['angles']))
move_dir = Vec(1, 0, 0) @ Angle.from_str(inst.fixup['$travel_direction'])
move_dir = move_dir @ orig_orient
start_offset = inst.fixup.float('$starting_position')
teleport_to_start = res.bool('TrackTeleport', True)
segment_inst_file = instanceLocs.resolve_one(res['SegmentInst', ''])
rail_template = res['RailTemplate', None]
track_speed = res['speed', None]
start_pos = Vec.from_str(inst['origin'])
end_pos = start_pos + move_dist * move_dir
if start_offset > 0:
# If an oscillating platform, move to the closest side..
offset = start_offset * move_dir
# The instance is placed this far along, so move back to the end.
start_pos -= offset
end_pos -= offset
if start_offset > 0.5:
# Swap the direction of movement..
start_pos, end_pos = end_pos, start_pos
inst['origin'] = start_pos
norm = orig_orient.up()
if res.bool('rotateSegments', True):
orient = Matrix.from_basis(x=move_dir, z=norm)
inst['angles'] = orient.to_angle()
else:
orient = orig_orient
# Add the EnableMotion trigger_multiple seen in platform items.
# This wakes up cubes when it starts moving.
motion_filter = res['motionTrig', None]
# Disable on walls, or if the conveyor can't be turned on.
if norm != (0, 0, 1) or inst.fixup['$connectioncount'] == '0':
motion_filter = None
track_name = conditions.local_name(inst, 'segment_{}')
rail_temp_solids = []
last_track = None
# Place tracks at the top, so they don't appear inside wall sections.
track_start: Vec = start_pos + 48 * norm
track_end: Vec = end_pos + 48 * norm
for index, pos in enumerate(track_start.iter_line(track_end, stride=128),
start=1):
track = vmf.create_ent(
classname='path_track',
targetname=track_name.format(index) + '-track',
origin=pos,
spawnflags=0,
orientationtype=0, # Don't rotate
)
if track_speed is not None:
track['speed'] = track_speed
if last_track:
last_track['target'] = track['targetname']
if index == 1 and teleport_to_start:
track['spawnflags'] = 16 # Teleport here..
last_track = track
# Don't place at the last point - it doesn't teleport correctly,
# and would be one too many.
if segment_inst_file and pos != track_end:
seg_inst = conditions.add_inst(
vmf,
targetname=track_name.format(index),
file=segment_inst_file,
origin=pos,
angles=orient,
)
seg_inst.fixup.update(inst.fixup)
if rail_template:
temp = template_brush.import_template(
vmf,
rail_template,
pos,
orient,
force_type=template_brush.TEMP_TYPES.world,
add_to_map=False,
)
rail_temp_solids.extend(temp.world)
if rail_temp_solids:
vmf.create_ent(
classname='func_brush',
origin=track_start,
spawnflags=1, # Ignore +USE
solidity=1, # Not solid
vrad_brush_cast_shadows=1,
drawinfastreflection=1,
).solids = rail_temp_solids
if teleport_to_start:
# Link back to the first track..
last_track['target'] = track_name.format(1) + '-track'
# Generate an env_beam pointing from the start to the end of the track.
try:
beam_keys = res.find_key('BeamKeys')
except LookupError:
pass
else:
beam = vmf.create_ent(classname='env_beam')
beam_off = beam_keys.vec('origin', 0, 63, 56)
for prop in beam_keys:
beam[prop.real_name] = prop.value
# Localise the targetname so it can be triggered..
beam['LightningStart'] = beam['targetname'] = conditions.local_name(
inst, beam['targetname', 'beam'])
del beam['LightningEnd']
beam['origin'] = start_pos + Vec(
-beam_off.x,
beam_off.y,
beam_off.z,
) @ orient
beam['TargetPoint'] = end_pos + Vec(
+beam_off.x,
beam_off.y,
beam_off.z,
) @ orient
# Allow adding outputs to the last path_track.
for prop in res.find_all('EndOutput'):
output = Output.parse(prop)
output.output = 'OnPass'
output.inst_out = None
output.comma_sep = False
output.target = conditions.local_name(inst, output.target)
last_track.add_out(output)
if motion_filter is not None:
motion_trig = vmf.create_ent(
classname='trigger_multiple',
targetname=conditions.local_name(inst, 'enable_motion_trig'),
origin=start_pos,
filtername=motion_filter,
startDisabled=1,
wait=0.1,
)
motion_trig.add_out(
Output('OnStartTouch', '!activator', 'ExitDisabledState'))
# Match the size of the original...
motion_trig.solids.append(
vmf.make_prism(
start_pos + Vec(72, -56, 58) @ orient,
end_pos + Vec(-72, 56, 144) @ orient,
mat=consts.Tools.TRIGGER,
).solid)
if res.bool('NoPortalFloor'):
# Block portals on the floor..
floor_noportal = vmf.create_ent(
classname='func_noportal_volume',
origin=track_start,
)
floor_noportal.solids.append(
vmf.make_prism(
start_pos + Vec(-60, -60, -66) @ orient,
end_pos + Vec(60, 60, -60) @ orient,
mat=consts.Tools.INVISIBLE,
).solid)
# A brush covering under the platform.
base_trig = vmf.make_prism(
start_pos + Vec(-64, -64, 48) @ orient,
end_pos + Vec(64, 64, 56) @ orient,
mat=consts.Tools.INVISIBLE,
).solid
vmf.add_brush(base_trig)
# Make a paint_cleanser under the belt..
if res.bool('PaintFizzler'):
pfizz = vmf.create_ent(
classname='trigger_paint_cleanser',
origin=start_pos,
)
pfizz.solids.append(base_trig.copy())
for face in pfizz.sides():
face.mat = consts.Tools.TRIGGER
def res_import_template_setup(res: Property):
temp_id = res['id']
force = res['force', ''].casefold().split()
if 'white' in force:
force_colour = template_brush.MAT_TYPES.white
elif 'black' in force:
force_colour = template_brush.MAT_TYPES.black
elif 'invert' in force:
force_colour = 'INVERT'
else:
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
for size in ('2x2', '4x4', 'wall', 'special'):
if size in force:
force_grid = size
break
else:
force_grid = None
invert_var = res['invertVar', '']
color_var = res['colorVar', '']
replace_tex = defaultdict(list)
for prop in res.find_key('replace', []):
replace_tex[prop.name].append(prop.value)
rem_replace_brush = True
additional_ids = set()
transfer_overlays = '1'
try:
replace_brush = res.find_key('replaceBrush')
except NoKeyError:
replace_brush_pos = None
else:
if replace_brush.has_children():
replace_brush_pos = replace_brush['Pos', '0 0 0']
additional_ids = set(
map(
srctools.conv_int,
replace_brush['additionalIDs', ''].split(),
))
rem_replace_brush = replace_brush.bool('removeBrush', True)
transfer_overlays = replace_brush['transferOverlay', '1']
else:
replace_brush_pos = replace_brush.value # type: str
replace_brush_pos = Vec.from_str(replace_brush_pos)
replace_brush_pos.z -= 64 # 0 0 0 defaults to the floor.
key_values = res.find_key("Keys", [])
if key_values:
keys = Property("", [
key_values,
res.find_key("LocalKeys", []),
])
# 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
else:
keys = None
visgroup_mode = res['visgroup', 'none'].casefold()
if visgroup_mode not in ('none', 'choose'):
visgroup_mode = srctools.conv_float(visgroup_mode.rstrip('%'), 0.00)
if visgroup_mode == 0:
visgroup_mode = 'none'
# Generate the function which picks which visgroups to add to the map.
if visgroup_mode == 'none':
def visgroup_func(_):
"""none = don't add any visgroups."""
return ()
elif visgroup_mode == 'choose':
def visgroup_func(groups):
"""choose = add one random group."""
return [random.choice(groups)]
else:
def visgroup_func(groups):
"""Number = percent chance for each to be added"""
for group in groups:
val = random.uniform(0, 100)
if val <= visgroup_mode:
yield group
# If true, force visgroups to all be used.
visgroup_force_var = res['forceVisVar', '']
return (
temp_id,
dict(replace_tex),
force_colour,
force_grid,
force_type,
replace_brush_pos,
rem_replace_brush,
transfer_overlays,
additional_ids,
invert_var,
color_var,
visgroup_func,
visgroup_force_var,
keys,
)
def parse(cls, info: Property, pack_id: str) -> SelitemData:
"""Parse from a property block."""
auth = sep_values(info['authors', ''])
short_name = info['shortName', None]
name = info['name']
group = info['group', '']
sort_key = info['sort_key', '']
desc = desc_parse(info, info['id'], pack_id)
if not group:
group = None
if not short_name:
short_name = name
try:
icon = img.Handle.parse(
info.find_key('icon'),
pack_id,
consts.SEL_ICON_SIZE,
consts.SEL_ICON_SIZE,
)
except LookupError:
icon = None
try:
large_key = info.find_key('iconLarge')
except LookupError:
large_icon = large_key = None
else:
large_icon = img.Handle.parse(
large_key,
pack_id,
*consts.SEL_ICON_SIZE_LRG,
)
try:
preview_block = info.find_block('previews')
except LookupError:
# Use the large icon, if present.
if large_key is not None:
previews = [img.Handle.parse(
large_key,
pack_id,
0,
0,
)]
else:
previews = []
else:
previews = [
img.Handle.parse(
prop,
pack_id,
0,
0,
) for prop in preview_block
]
return cls(
name,
short_name,
auth,
icon,
large_icon,
previews,
desc,
group,
sort_key,
frozenset({pack_id}),
)
