def res_add_variant(inst: Entity, res: Property):
"""This allows using a random instance from a weighted group.
A suffix will be added in the form "_var4".
Two properties should be given:
Number: The number of random instances.
Weights: A comma-separated list of weights for each instance.
Any variant has a chance of weight/sum(weights) of being chosen:
A weight of "2, 1, 1" means the first instance has a 2/4 chance of
being chosen, and the other 2 have a 1/4 chance of being chosen.
The chosen variant depends on the position, direction and name of
the instance.
Alternatively, you can use "variant" "number" to choose from equally-weighted
options.
"""
import vbsp
if inst['targetname', ''] == '':
# some instances don't get names, so use the global
# seed instead for stuff like elevators.
random.seed(vbsp.MAP_RAND_SEED + inst['origin'] + inst['angles'])
else:
# We still need to use angles and origin, since things like
# fizzlers might not get unique names.
random.seed(inst['targetname'] + inst['origin'] + inst['angles'])
conditions.add_suffix(inst, "_var" + str(random.choice(res.value) + 1))
def res_add_inst_var(inst: Entity, res: Property):
"""Append the value of an instance variable to the filename.
Pass either the variable name, or a set of value->suffix pairs for a
lookup.
"""
if res.has_children():
val = inst.fixup[res['variable', '']]
for rep in res: # lookup the number to determine the appending value
if rep.name == 'variable':
continue # this isn't a lookup command!
if rep.name == val:
conditions.add_suffix(inst, '_' + rep.value)
break
else: # append the value
conditions.add_suffix(inst, '_' + inst.fixup[res.value, ''])
def res_add_inst_var(inst: Entity, res: Property):
"""Append the value of an instance variable to the filename.
Pass either the variable name, or a set of value->suffix pairs for a
lookup.
"""
if res.has_children():
val = inst.fixup[res['variable', '']]
for rep in res: # lookup the number to determine the appending value
if rep.name == 'variable':
continue # this isn't a lookup command!
if rep.name == val:
conditions.add_suffix(inst, '_' + rep.value)
break
else: # append the value
conditions.add_suffix(inst, '_' + inst.fixup[res.value, ''])
def res_add_variant(inst: Entity, res: Property) -> None:
"""This allows using a random instance from a weighted group.
A suffix will be added in the form `_var4`.
Two properties should be given:
Number: The number of random instances.
Weights: A comma-separated list of weights for each instance.
Any variant has a chance of weight/sum(weights) of being chosen:
A weight of `2, 1, 1` means the first instance has a 2/4 chance of
being chosen, and the other 2 have a 1/4 chance of being chosen.
The chosen variant depends on the position, direction and name of
the instance.
Alternatively, you can use `"variant" "number"` to choose from equally-weighted
options.
"""
set_random_seed(inst, 'variant')
conditions.add_suffix(inst, "_var" + str(random.choice(res.value) + 1))
def res_add_variant(inst: Entity, res: Property) -> None:
"""This allows using a random instance from a weighted group.
A suffix will be added in the form `_var4`.
Two properties should be given:
- `Number`: The number of random instances.
- `Weights`: A comma-separated list of weights for each instance.
Any variant has a chance of weight/sum(weights) of being chosen:
A weight of `2, 1, 1` means the first instance has a 2/4 chance of
being chosen, and the other 2 have a 1/4 chance of being chosen.
The chosen variant depends on the position, direction and name of
the instance.
Alternatively, you can use `"variant" "number"` to choose from equally-weighted
options.
"""
set_random_seed(inst, 'variant')
conditions.add_suffix(inst, "_var" + str(random.choice(res.value) + 1))
def res_add_variant(inst, res):
"""This allows using a random instance from a weighted group.
A suffix will be added in the form "_var4".
Two properties should be given:
Number: The number of random instances.
Weights: A comma-separated list of weights for each instance.
Any variant has a chance of weight/sum(weights) of being chosen:
A weight of "2, 1, 1" means the first instance has a 2/4 chance of
being chosen, and the other 2 have a 1/4 chance of being chosen.
The chosen variant depends on the position, direction and name of
the instance.
"""
import vbsp
if inst['targetname', ''] == '':
# some instances don't get names, so use the global
# seed instead for stuff like elevators.
random.seed(vbsp.MAP_RAND_SEED + inst['origin'] + inst['angles'])
else:
# We still need to use angles and origin, since things like
# fizzlers might not get unique names.
random.seed(inst['targetname'] + inst['origin'] + inst['angles'])
conditions.add_suffix(inst, "_var" + str(random.choice(res.value) + 1))
def res_track_plat(res: Property):
"""Logic specific to Track Platforms.
This allows switching the instances used depending on if the track
is horizontal or vertical and sets the track
targetnames to a useful value.
Values:
- Orig_item: The "<ITEM_ID>" for the track platform, with angle brackets
- Single_plat: An instance used for platform with 1 rail
- Track_name: The name to give to the tracks.
- Vert_suffix: Add suffixes to vertical tracks
(_vert)
- Horiz_suffix: Add suffixes to horizontal tracks
(_horiz, _horiz_mirrored)
- plat_suffix: Also add the above _vert or _horiz suffixes to
the platform.
- vert_bottom_suffix: Add '_bottom' / '_vert_bottom' to the track at the
bottom of vertical platforms.
- plat_var: If set, save the orientation to the given $fixup variable
"""
# Get the instances from editoritems
(inst_bot_grate, inst_bottom, inst_middle, inst_top, inst_plat,
inst_plat_oscil, inst_single) = resolve_inst(res['orig_item'])
# If invalid, [] = false so ''[0] = ''.
single_plat_inst = (resolve_inst(res['single_plat', '']) or '')[0]
track_targets = res['track_name', '']
track_files = [inst_bottom, inst_middle, inst_top, inst_single]
platforms = [inst_plat, inst_plat_oscil]
# All the track_set in the map, indexed by origin
track_instances = {
Vec.from_str(inst['origin']).as_tuple(): inst
for inst in vbsp.VMF.by_class['func_instance']
if inst['file'].casefold() in track_files
}
LOGGER.debug('Track instances:')
LOGGER.debug('\n'.join('{!s}: {}'.format(k, v['file'])
for k, v in track_instances.items()))
if not track_instances:
return RES_EXHAUSTED
# Now we loop through all platforms in the map, and then locate their
# track_set
for plat_inst in vbsp.VMF.by_class['func_instance']:
if plat_inst['file'].casefold() not in platforms:
continue # Not a platform!
LOGGER.debug('Modifying "' + plat_inst['targetname'] + '"!')
plat_loc = Vec.from_str(plat_inst['origin'])
# The direction away from the wall/floor/ceil
normal = Vec(0, 0, 1).rotate_by_str(plat_inst['angles'])
for tr_origin, first_track in track_instances.items():
if plat_loc == tr_origin:
# Check direction
if normal == Vec(
0, 0, 1).rotate(*Vec.from_str(first_track['angles'])):
break
else:
raise Exception('Platform "{}" has no track!'.format(
plat_inst['targetname']))
track_type = first_track['file'].casefold()
if track_type == inst_single:
# Track is one block long, use a single-only instance and
# remove track!
plat_inst['file'] = single_plat_inst
first_track.remove()
continue # Next platform
track_set = set()
if track_type == inst_top or track_type == inst_middle:
# search left
track_scan(
track_set,
track_instances,
first_track,
middle_file=inst_middle,
x_dir=-1,
)
if track_type == inst_bottom or track_type == inst_middle:
# search right
track_scan(
track_set,
track_instances,
first_track,
middle_file=inst_middle,
x_dir=+1,
)
# Give every track a targetname matching the platform
for ind, track in enumerate(track_set, start=1):
if track_targets == '':
track['targetname'] = plat_inst['targetname']
else:
track['targetname'] = (plat_inst['targetname'] + '-' +
track_targets + str(ind))
# Now figure out which way the track faces:
# The direction horizontal track is offset
side_dir = Vec(0, 1, 0).rotate_by_str(first_track['angles'])
# The direction of the platform surface
facing = Vec(-1, 0, 0).rotate_by_str(plat_inst['angles'])
if side_dir == facing:
track_facing = 'HORIZ'
elif side_dir == -facing:
track_facing = 'HORIZ_MIRR'
else:
track_facing = 'VERT'
# Now add the suffixes
if track_facing == 'VERT':
if srctools.conv_bool(res['vert_suffix', '']):
for inst in track_set:
conditions.add_suffix(inst, '_vert')
if srctools.conv_bool(res['plat_suffix', '']):
conditions.add_suffix(plat_inst, '_vert')
if srctools.conv_bool(res['vert_bottom_suffix', '']):
# We want to find the bottom/top track which is facing the
# same direction as the platform.
track_dirs = {
inst_top: Vec(-1, 0, 0),
inst_bottom: Vec(1, 0, 0)
}
for inst in track_set:
try:
norm_off = track_dirs[inst['file'].casefold()]
except KeyError:
continue
if norm_off.rotate_by_str(inst['angles']) == facing:
conditions.add_suffix(inst, '_bottom')
elif track_facing == 'HORIZ_MIRR':
if srctools.conv_bool(res['horiz_suffix', '']):
for inst in track_set:
conditions.add_suffix(inst, '_horiz_mirrored')
if srctools.conv_bool(res['plat_suffix', '']):
conditions.add_suffix(plat_inst, '_horiz')
else: # == 'HORIZ'
if srctools.conv_bool(res['horiz_suffix', '']):
for inst in track_set:
conditions.add_suffix(inst, '_horiz')
if srctools.conv_bool(res['plat_suffix', '']):
conditions.add_suffix(plat_inst, '_horiz')
plat_var = res['plat_var', '']
if plat_var != '':
# Skip the '_mirrored' section if needed
plat_inst.fixup[plat_var] = track_facing[:5].lower()
return RES_EXHAUSTED # Don't re-run
def res_track_plat(_, res):
"""Logic specific to Track Platforms.
This allows switching the instances used depending on if the track
is horizontal or vertical and sets the track
targetnames to a useful value.
Values:
- Orig_item: The "<ITEM_ID>" for the track platform, with angle brackets
- Single_plat: An instance used for platform with 1 rail
- Track_name: The name to give to the tracks.
- Vert_suffix: Add suffixes to vertical tracks
(_vert)
- Horiz_suffix: Add suffixes to horizontal tracks
(_horiz, _horiz_mirrored)
- plat_suffix: Also add the above _vert or _horiz suffixes to
the platform.
- plat_var: If set, save the orientation to the given $fixup variable
"""
# Get the instances from editoritems
(
inst_bot_grate, inst_bottom, inst_middle,
inst_top, inst_plat, inst_plat_oscil, inst_single
) = resolve_inst(res['orig_item'])
single_plat_inst = res['single_plat', '']
track_targets = res['track_name', '']
track_files = [inst_bottom, inst_middle, inst_top, inst_single]
platforms = [inst_plat, inst_plat_oscil]
# All the track_set in the map, indexed by origin
track_instances = {
Vec.from_str(inst['origin']).as_tuple(): inst
for inst in
vbsp.VMF.by_class['func_instance']
if inst['file'].casefold() in track_files
}
LOGGER.debug('Track instances:')
LOGGER.debug('\n'.join(
'{!s}: {}'.format(k, v['file'])
for k, v in
track_instances.items()
))
if not track_instances:
return RES_EXHAUSTED
# Now we loop through all platforms in the map, and then locate their
# track_set
for plat_inst in vbsp.VMF.by_class['func_instance']:
if plat_inst['file'].casefold() not in platforms:
continue # Not a platform!
LOGGER.debug('Modifying "' + plat_inst['targetname'] + '"!')
plat_loc = Vec.from_str(plat_inst['origin'])
# The direction away from the wall/floor/ceil
normal = Vec(0, 0, 1).rotate_by_str(
plat_inst['angles']
)
for tr_origin, first_track in track_instances.items():
if plat_loc == tr_origin:
# Check direction
if normal == Vec(0, 0, 1).rotate(
*Vec.from_str(first_track['angles'])
):
break
else:
raise Exception('Platform "{}" has no track!'.format(
plat_inst['targetname']
))
track_type = first_track['file'].casefold()
if track_type == inst_single:
# Track is one block long, use a single-only instance and
# remove track!
plat_inst['file'] = single_plat_inst
first_track.remove()
continue # Next platform
track_set = set()
if track_type == inst_top or track_type == inst_middle:
# search left
track_scan(
track_set,
track_instances,
first_track,
middle_file=inst_middle,
x_dir=-1,
)
if track_type == inst_bottom or track_type == inst_middle:
# search right
track_scan(
track_set,
track_instances,
first_track,
middle_file=inst_middle,
x_dir=+1,
)
# Give every track a targetname matching the platform
for ind, track in enumerate(track_set, start=1):
if track_targets == '':
track['targetname'] = plat_inst['targetname']
else:
track['targetname'] = (
plat_inst['targetname'] +
'-' +
track_targets + str(ind)
)
# Now figure out which way the track faces:
# The direction horizontal track is offset
side_dir = Vec(0, 1, 0).rotate_by_str(first_track['angles'])
# The direction of the platform surface
facing = Vec(-1, 0, 0).rotate_by_str(plat_inst['angles'])
if side_dir == facing:
track_facing = 'HORIZ'
elif side_dir == -facing:
track_facing = 'HORIZ_MIRR'
else:
track_facing = 'VERT'
# Now add the suffixes
if track_facing == 'VERT':
if utils.conv_bool(res['vert_suffix', '']):
for inst in track_set:
conditions.add_suffix(inst, '_vert')
if utils.conv_bool(res['plat_suffix', '']):
conditions.add_suffix(plat_inst, '_vert')
elif track_facing == 'HORIZ_MIRR':
if utils.conv_bool(res['horiz_suffix', '']):
for inst in track_set:
conditions.add_suffix(inst, '_horiz_mirrored')
if utils.conv_bool(res['plat_suffix', '']):
conditions.add_suffix(plat_inst, '_horiz')
else: # == 'HORIZ'
if utils.conv_bool(res['horiz_suffix', '']):
for inst in track_set:
conditions.add_suffix(inst, '_horiz')
if utils.conv_bool(res['plat_suffix', '']):
conditions.add_suffix(plat_inst, '_horiz')
plat_var = res['plat_var', '']
if plat_var != '':
# Skip the '_mirrored' section if needed
plat_inst.fixup[plat_var] = track_facing[:5].lower()
return RES_EXHAUSTED # Don't re-run
def res_add_suffix(inst: Entity, res: Property):
"""Add the specified suffix to the filename."""
conditions.add_suffix(inst, '_' + res.value)
def res_add_suffix(inst, res):
"""Add the specified suffix to the filename."""
conditions.add_suffix(inst, '_' + res.value)
def res_add_suffix(inst: Entity, res: Property):
"""Add the specified suffix to the filename."""
conditions.add_suffix(inst, '_' + res.value)
def res_track_plat(vmf: VMF, res: Property):
"""Logic specific to Track Platforms.
This allows switching the instances used depending on if the track
is horizontal or vertical and sets the track
targetnames to a useful value. This should be run unconditionally, not
once per item.
Values:
* `orig_item`: The "<ITEM_ID>" for the track platform, with angle brackets.
This is used to determine all the instance filenames.
* `single_plat`: An instance used for the entire platform, if it's
one rail long (and therefore can't move).
* `track_name`: If set, rename track instances following the pattern
`plat_name-track_nameXX`. Otherwise all tracks will receive the name
of the platform.
* `plat_suffix`: If set, add a `_vert` or `_horiz` suffix
to the platform.
* `plat_var`: If set, save the orientation (`vert`/`horiz`) to the
provided $fixup variable.
* `track_var`: If set, save `N`, `S`, `E`, or `W` to the provided $fixup
variable to indicate the relative direction the top faces.
"""
# Get the instances from editoritems
(inst_bot_grate, inst_bottom, inst_middle, inst_top, inst_plat,
inst_plat_oscil, inst_single) = instanceLocs.resolve(res['orig_item'])
single_plat_inst = instanceLocs.resolve_one(res['single_plat', ''])
track_targets = res['track_name', '']
track_files = [inst_bottom, inst_middle, inst_top, inst_single]
platforms = [inst_plat, inst_plat_oscil]
# All the track_set in the map, indexed by origin
track_instances = {
Vec.from_str(inst['origin']).as_tuple(): inst
for inst in vmf.by_class['func_instance']
if inst['file'].casefold() in track_files
}
LOGGER.debug('Track instances:')
LOGGER.debug('\n'.join('{!s}: {}'.format(k, v['file'])
for k, v in track_instances.items()))
if not track_instances:
return RES_EXHAUSTED
# Now we loop through all platforms in the map, and then locate their
# track_set
for plat_inst in vmf.by_class['func_instance']:
if plat_inst['file'].casefold() not in platforms:
continue # Not a platform!
LOGGER.debug('Modifying "' + plat_inst['targetname'] + '"!')
plat_loc = Vec.from_str(plat_inst['origin'])
# The direction away from the wall/floor/ceil
normal = Vec(0, 0, 1).rotate_by_str(plat_inst['angles'])
for tr_origin, first_track in track_instances.items():
if plat_loc == tr_origin:
# Check direction
if normal == Vec(
0, 0, 1).rotate(*Vec.from_str(first_track['angles'])):
break
else:
raise Exception('Platform "{}" has no track!'.format(
plat_inst['targetname']))
track_type = first_track['file'].casefold()
if track_type == inst_single:
# Track is one block long, use a single-only instance and
# remove track!
plat_inst['file'] = single_plat_inst
first_track.remove()
continue # Next platform
track_set = set() # type: Set[Entity]
if track_type == inst_top or track_type == inst_middle:
# search left
track_scan(
track_set,
track_instances,
first_track,
middle_file=inst_middle,
x_dir=-1,
)
if track_type == inst_bottom or track_type == inst_middle:
# search right
track_scan(
track_set,
track_instances,
first_track,
middle_file=inst_middle,
x_dir=+1,
)
# Give every track a targetname matching the platform
for ind, track in enumerate(track_set, start=1):
if track_targets == '':
track['targetname'] = plat_inst['targetname']
else:
track['targetname'] = (plat_inst['targetname'] + '-' +
track_targets + str(ind))
# Now figure out which way the track faces:
# The direction of the platform surface
facing = Vec(-1, 0, 0).rotate_by_str(plat_inst['angles'])
# The direction horizontal track is offset
uaxis = Vec(x=1).rotate_by_str(first_track['angles'])
vaxis = Vec(y=1).rotate_by_str(first_track['angles'])
if uaxis == facing:
plat_facing = 'vert'
track_facing = 'E'
elif uaxis == -facing:
plat_facing = 'vert'
track_facing = 'W'
elif vaxis == facing:
plat_facing = 'horiz'
track_facing = 'N'
elif vaxis == -facing:
plat_facing = 'horiz'
track_facing = 'S'
else:
raise ValueError('Facing {} is not U({}) or V({})!'.format(
facing,
uaxis,
vaxis,
))
if res.bool('plat_suffix'):
conditions.add_suffix(plat_inst, '_' + plat_facing)
plat_var = res['plat_var', '']
if plat_var:
plat_inst.fixup[plat_var] = plat_facing
track_var = res['track_var', '']
if track_var:
plat_inst.fixup[track_var] = track_facing
for track in track_set:
track.fixup.update(plat_inst.fixup)
return RES_EXHAUSTED # Don't re-run
def res_track_plat(vmf: VMF, res: Property):
"""Logic specific to Track Platforms.
This allows switching the instances used depending on if the track
is horizontal or vertical and sets the track
targetnames to a useful value. This should be run unconditionally, not
once per item.
Values:
* `orig_item`: The "<ITEM_ID>" for the track platform, with angle brackets.
This is used to determine all the instance filenames.
* `single_plat`: An instance used for the entire platform, if it's
one rail long (and therefore can't move).
* `track_name`: If set, rename track instances following the pattern
`plat_name-track_nameXX`. Otherwise all tracks will receive the name
of the platform.
* `plat_suffix`: If set, add a `_vert` or `_horiz` suffix
to the platform.
* `plat_var`: If set, save the orientation (`vert`/`horiz`) to the
provided $fixup variable.
* `track_var`: If set, save `N`, `S`, `E`, or `W` to the provided $fixup
variable to indicate the relative direction the top faces.
"""
# Get the instances from editoritems
(
inst_bot_grate, inst_bottom, inst_middle,
inst_top, inst_plat, inst_plat_oscil, inst_single
) = instanceLocs.resolve(res['orig_item'])
single_plat_inst = instanceLocs.resolve_one(res['single_plat', ''])
track_targets = res['track_name', '']
track_files = [inst_bottom, inst_middle, inst_top, inst_single]
platforms = [inst_plat, inst_plat_oscil]
# All the track_set in the map, indexed by origin
track_instances = {
Vec.from_str(inst['origin']).as_tuple(): inst
for inst in
vmf.by_class['func_instance']
if inst['file'].casefold() in track_files
}
LOGGER.debug('Track instances:')
LOGGER.debug('\n'.join(
'{!s}: {}'.format(k, v['file'])
for k, v in
track_instances.items()
))
if not track_instances:
return RES_EXHAUSTED
# Now we loop through all platforms in the map, and then locate their
# track_set
for plat_inst in vmf.by_class['func_instance']:
if plat_inst['file'].casefold() not in platforms:
continue # Not a platform!
LOGGER.debug('Modifying "' + plat_inst['targetname'] + '"!')
plat_loc = Vec.from_str(plat_inst['origin'])
# The direction away from the wall/floor/ceil
normal = Vec(0, 0, 1).rotate_by_str(
plat_inst['angles']
)
for tr_origin, first_track in track_instances.items():
if plat_loc == tr_origin:
# Check direction
if normal == Vec(0, 0, 1).rotate(
*Vec.from_str(first_track['angles'])
):
break
else:
raise Exception('Platform "{}" has no track!'.format(
plat_inst['targetname']
))
track_type = first_track['file'].casefold()
if track_type == inst_single:
# Track is one block long, use a single-only instance and
# remove track!
plat_inst['file'] = single_plat_inst
first_track.remove()
continue # Next platform
track_set = set() # type: Set[Entity]
if track_type == inst_top or track_type == inst_middle:
# search left
track_scan(
track_set,
track_instances,
first_track,
middle_file=inst_middle,
x_dir=-1,
)
if track_type == inst_bottom or track_type == inst_middle:
# search right
track_scan(
track_set,
track_instances,
first_track,
middle_file=inst_middle,
x_dir=+1,
)
# Give every track a targetname matching the platform
for ind, track in enumerate(track_set, start=1):
if track_targets == '':
track['targetname'] = plat_inst['targetname']
else:
track['targetname'] = (
plat_inst['targetname'] +
'-' +
track_targets + str(ind)
)
# Now figure out which way the track faces:
# The direction of the platform surface
facing = Vec(-1, 0, 0).rotate_by_str(plat_inst['angles'])
# The direction horizontal track is offset
uaxis = Vec(x=1).rotate_by_str(first_track['angles'])
vaxis = Vec(y=1).rotate_by_str(first_track['angles'])
if uaxis == facing:
plat_facing = 'vert'
track_facing = 'E'
elif uaxis == -facing:
plat_facing = 'vert'
track_facing = 'W'
elif vaxis == facing:
plat_facing = 'horiz'
track_facing = 'N'
elif vaxis == -facing:
plat_facing = 'horiz'
track_facing = 'S'
else:
raise ValueError('Facing {} is not U({}) or V({})!'.format(
facing,
uaxis,
vaxis,
))
if res.bool('plat_suffix'):
conditions.add_suffix(plat_inst, '_' + plat_facing)
plat_var = res['plat_var', '']
if plat_var:
plat_inst.fixup[plat_var] = plat_facing
track_var = res['track_var', '']
if track_var:
plat_inst.fixup[track_var] = track_facing
for track in track_set:
track.fixup.update(plat_inst.fixup)
return RES_EXHAUSTED # Don't re-run
