def flag_and(inst, flag):
"""The AND group evaluates True if all sub-flags are True."""
for sub_flag in flag:
if not check_flag(sub_flag, inst):
return False
# If the AND block is empty, return True
return len(flag.value) == 0
def find_group_quotes(group, mid_quotes, conf):
"""Scan through a group, looking for applicable quote options."""
is_mid = group.name == 'midinst'
group_id = group['name']
for quote in group.find_all('quote'):
valid_quote = True
for flag in quote:
name = flag.name
if name in ('priority', 'name', 'line', 'line_sp', 'line_coop'):
# Not flags!
continue
if not conditions.check_flag(flag, fake_inst):
valid_quote = False
break
quote_id = quote['id', quote['name', '']]
utils.con_log(quote_id, valid_quote)
if valid_quote:
# Check if the ID is enabled!
if conf.get_bool(group_id, quote_id, True):
if ALLOW_MID_VOICES and is_mid:
mid_quotes.extend(mode_quotes(quote))
else:
inst_list = list(mode_quotes(quote))
if inst_list:
yield (
quote['priority', '0'],
inst_list,
)
def find_group_quotes(group, mid_quotes, use_dings, conf, mid_name):
"""Scan through a group, looking for applicable quote options."""
is_mid = (group.name == 'midchamber')
if is_mid:
group_id = 'MIDCHAMBER'
else:
group_id = group['name'].upper()
for quote in group.find_all('quote'):
valid_quote = True
for flag in quote:
name = flag.name
if name in ('priority', 'name', 'id', 'line', 'line_sp', 'line_coop'):
# Not flags!
continue
if not conditions.check_flag(flag, fake_inst):
valid_quote = False
break
if not valid_quote:
continue
poss_quotes = []
for line in mode_quotes(quote):
line_id = line['id', line['name', '']].casefold()
# Check if the ID is enabled!
if conf.get_bool(group_id, line_id, True):
if ALLOW_MID_VOICES and is_mid:
mid_quotes.append((line, use_dings, mid_name))
else:
poss_quotes.append(line)
else:
LOGGER.info(
'Line "{}" is disabled..',
line['name', '??'],
)
if poss_quotes:
yield PossibleQuote(
quote['priority', '0'],
poss_quotes,
)
def flag_and(inst: Entity, flag: Property):
"""The AND group evaluates True if all sub-flags are True."""
for sub_flag in flag:
if not check_flag(sub_flag, inst):
return False
return True
def flag_not(inst: Entity, flag: Property):
"""The NOT group inverts the value of it's one sub-flag."""
if len(flag.value) == 1:
return not check_flag(flag[0], inst)
return False
def flag_or(inst: Entity, flag: Property):
"""The OR group evaluates True if any sub-flags are True."""
for sub_flag in flag:
if check_flag(sub_flag, inst):
return True
return False
def res_import_template(inst: Entity, 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`.
- `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.
- `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.
"""
(
orig_temp_id,
replace_tex,
force_colour,
force_grid,
force_type,
surf_cat,
bind_tile_pos,
invert_var,
color_var,
visgroup_func,
visgroup_force_var,
visgroup_instvars,
key_block,
picker_vars,
outputs,
sense_offset,
) = res.value
if ':' in orig_temp_id:
# Split, resolve each part, then recombine.
temp_id, visgroup = orig_temp_id.split(':', 1)
temp_id = (
conditions.resolve_value(inst, temp_id) + ':' +
conditions.resolve_value(inst, visgroup)
)
else:
temp_id = conditions.resolve_value(inst, orig_temp_id)
if srctools.conv_bool(conditions.resolve_value(inst, visgroup_force_var)):
def visgroup_func(group):
"""Use all the groups."""
yield from group
# 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, inst) for flag in vis_flag_block):
visgroups.add(vis_flag_block.real_name)
if color_var.casefold() == '<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[force_colour]
# else: False value, no invert.
origin = Vec.from_str(inst['origin'])
angles = Vec.from_str(inst['angles', '0 0 0'])
temp_data = template_brush.import_template(
template,
origin,
angles,
targetname=inst['targetname', ''],
force_type=force_type,
visgroup_choose=visgroup_func,
add_to_map=True,
additional_visgroups=visgroups,
bind_tile_pos=bind_tile_pos,
)
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, angles)
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).rotate(*angles)
temp_data.detail['movedir'] = move_dir.to_angle()
for out in outputs: # type: Output
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,
) # type: Optional[texturing.Portalable]
if picker_val is not None:
inst.fixup[picker_var] = picker_val.value
else:
inst.fixup[picker_var] = ''
def flag_xor(inst: Entity, flag:Property):
"""The XOR group returns True if the number of true sub-flags is odd."""
return sum([check_flag(sub_flag, inst) for sub_flag in flag]) % 2 == 1
def flag_xor(inst: Entity, flag: Property):
"""The XOR group returns True if the number of true sub-flags is odd."""
return sum([check_flag(sub_flag, inst) for sub_flag in flag]) % 2 == 1
