def pose(f, rot): global FRAME # Calculate the piston's rotation. # First find the real position of the piston hinge. hinge_pos = Vec(-43, 0, 10.5) hinge_pos.x -= 64 hinge_pos.rotate(float(rot), 0, 0) hinge_pos.x += 64 # Where we want the end of the piston to be. anchor_point = Vec(z=-96, x=rot*1.5 + 96) piston_off = hinge_pos - anchor_point print(piston_off) piston_rot = math.degrees(math.atan2(piston_off.z, -piston_off.x)) f.write(frame_temp.format( time=FRAME, rot=-round(math.radians(rot), 6), # Cancel the effect of rot on pist_rot pist_rot=round(math.radians((piston_rot + rot) % 360), 6), len=-piston_off.mag(), marker=Vec(z=anchor_point.z, y=-anchor_point.x), )) FRAME += 1
def _texture_fit( self, side: Side, tex_size: float, field_length: float, fizz: Fizzler, neg: Vec, pos: Vec, is_laserfield=False, ) -> None: """Calculate the texture offsets required for fitting a texture.""" if side.vaxis.vec() != -fizz.up_axis: # Rotate it rot_angle = side.normal().rotation_around() for _ in range(4): side.uaxis = side.uaxis.rotate(rot_angle) side.vaxis = side.vaxis.rotate(rot_angle) if side.vaxis.vec() == -fizz.up_axis: break else: LOGGER.warning("Can't fix rotation for {} -> {}", side.vaxis, fizz.up_axis) side.uaxis.offset = -(tex_size / field_length) * neg.dot(side.uaxis.vec()) side.vaxis.offset = -(tex_size / 128) * neg.dot(side.vaxis.vec()) # The above fits it correctly, except it's vertically half-offset. # For laserfields that's what we want, for fizzlers we want it normal. if not is_laserfield: side.vaxis.offset += tex_size / 2 side.uaxis.scale = field_length / tex_size side.vaxis.scale = 128 / tex_size side.uaxis.offset %= tex_size side.vaxis.offset %= tex_size
def find_glass_items(config, vmf: VMF) -> Iterator[Tuple[str, Vec, Vec, Vec, dict]]: """Find the bounding boxes for all the glass items matching a config. This yields (targetname, min, max, normal, config) tuples. """ # targetname -> min, max, normal, config glass_items = {} for inst in vmf.by_class['func_instance']: # type: Entity try: conf = config[inst['file'].casefold()] except KeyError: continue targ = inst['targetname'] norm = Vec(x=1).rotate_by_str(inst['angles']) origin = Vec.from_str(inst['origin']) - 64 * norm try: bbox_min, bbox_max, group_norm, group_conf = glass_items[targ] except KeyError: # First of this group.. bbox_min, bbox_max = origin.copy(), origin.copy() group_norm = norm.copy() glass_items[targ] = bbox_min, bbox_max, group_norm, conf else: bbox_min.min(origin) bbox_max.max(origin) assert group_norm == norm, '"{}" is inconsistently rotated!'.format(targ) assert group_conf is conf, '"{}" has multiple configs!'.format(targ) inst.remove() for targ, (bbox_min, bbox_max, norm, conf) in glass_items.items(): yield targ, bbox_min, bbox_max, norm, conf
def res_replace_instance(inst: Entity, res: Property): """Replace an instance with another entity. `keys` and `localkeys` defines the new keyvalues used. `targetname` and `angles` are preset, and `origin` will be used to offset the given amount from the current location. If `keep_instance` is true, the instance entity will be kept instead of removed. """ import vbsp origin = Vec.from_str(inst['origin']) angles = inst['angles'] if not srctools.conv_bool(res['keep_instance', '0'], False): inst.remove() # Do this first to free the ent ID, so the new ent has # the same one. # We copy to allow us to still access the $fixups and other values. new_ent = inst.copy(des_id=inst.id) new_ent.clear_keys() # Ensure there's a classname, just in case. new_ent['classname'] = 'info_null' vbsp.VMF.add_ent(new_ent) conditions.set_ent_keys(new_ent, inst, res) origin += Vec.from_str(new_ent['origin']).rotate_by_str(angles) new_ent['origin'] = origin new_ent['angles'] = angles new_ent['targetname'] = inst['targetname']
def res_glass_hole(inst: Entity, res: Property): """Add Glass/grating holes. The value should be 'large' or 'small'.""" hole_type = HoleType(res.value) normal = Vec(z=-1).rotate_by_str(inst['angles']) origin = Vec.from_str(inst['origin']) // 128 * 128 + 64 if test_hole_spot(origin, normal, hole_type): HOLES[origin.as_tuple(), normal.as_tuple()] = hole_type inst['origin'] = origin inst['angles'] = normal.to_angle() return # Test the opposite side of the glass too. inv_origin = origin + 128 * normal inv_normal = -normal if test_hole_spot(inv_origin, inv_normal, hole_type): HOLES[inv_origin.as_tuple(), inv_normal.as_tuple()] = hole_type inst['origin'] = inv_origin inst['angles'] = inv_normal.to_angle() else: # Remove the instance, so this does nothing. inst.remove()
def res_rand_vec(inst: Entity, res: Property) -> None: """A modification to RandomNum which generates a random vector instead. 'decimal', 'seed' and 'ResultVar' work like RandomNum. min/max x/y/z are for each section. If the min and max are equal that number will be used instead. """ is_float = srctools.conv_bool(res['decimal']) var = res['resultvar', '$random'] set_random_seed(inst, 'e' + res['seed', 'random']) if is_float: func = random.uniform else: func = random.randint value = Vec() for axis in 'xyz': max_val = srctools.conv_float(res['max_' + axis, 0.0]) min_val = srctools.conv_float(res['min_' + axis, 0.0]) if min_val == max_val: value[axis] = min_val else: value[axis] = func(min_val, max_val) inst.fixup[var] = value.join(' ')
def res_sendificator(vmf: VMF, inst: Entity): """Implement Sendificators.""" # For our version, we know which sendtor connects to what laser, # so we can couple the logic together (avoiding @sendtor_mutex). sendtor_name = inst['targetname'] sendtor = connections.ITEMS[sendtor_name] sendtor.enable_cmd += (Output( '', '@{}_las_relay_*'.format(sendtor_name), 'Trigger', delay=0.01, ), ) for ind, conn in enumerate(list(sendtor.outputs), start=1): las_item = conn.to_item conn.remove() try: targ_offset, targ_normal = SENDTOR_TARGETS[las_item.name] except KeyError: LOGGER.warning('"{}" is not a Sendificator target!', las_item.name) continue angles = Vec.from_str(las_item.inst['angles']) targ_offset = targ_offset.copy() targ_normal = targ_normal.copy().rotate(*angles) targ_offset.localise( Vec.from_str(las_item.inst['origin']), angles, ) relay_name = '@{}_las_relay_{}'.format(sendtor_name, ind) relay = vmf.create_ent( 'logic_relay', targetname=relay_name, origin=targ_offset, angles=targ_normal.to_angle(), ) relay.add_out( Output('OnTrigger', '!self', 'RunScriptCode', '::sendtor_source <- self;'), Output('OnTrigger', '@sendtor_fire', 'Trigger'), ) if not las_item.inputs: # No other inputs, make it on always. PeTI automatically turns # it off when inputs are connected, which is annoying. las_item.inst.fixup['$start_enabled'] = '1' is_on = True else: is_on = las_item.inst.fixup.bool('$start_enabled') relay['StartDisabled'] = not is_on las_item.enable_cmd += (Output('', relay_name, 'Enable'),) las_item.disable_cmd += (Output('', relay_name, 'Disable'),) LOGGER.info('Relay: {}', relay)
def make_straight( origin: Vec, normal: Vec, dist: int, config: dict, is_start=False, ): """Make a straight line of instances from one point to another.""" # 32 added to the other directions, plus extended dist in the direction # of the normal - 1 p1 = origin + (normal * ((dist // 128 * 128) - 96)) # The starting brush needs to # stick out a bit further, to cover the # point_push entity. p2 = origin - (normal * (96 if is_start else 32)) # bbox before +- 32 to ensure the above doesn't wipe it out p1, p2 = Vec.bbox(p1, p2) solid = vbsp.VMF.make_prism( # Expand to 64x64 in the other two directions p1 - 32, p2 + 32, mat='tools/toolstrigger', ).solid motion_trigger(solid.copy()) push_trigger(origin, normal, [solid]) angles = normal.to_angle() support_file = config['support'] straight_file = config['straight'] support_positions = ( SUPPORT_POS[normal.as_tuple()] if support_file else [] ) for off in range(0, int(dist), 128): position = origin + off * normal vbsp.VMF.create_ent( classname='func_instance', origin=position, angles=angles, file=straight_file, ) for supp_ang, supp_off in support_positions: if (position + supp_off).as_tuple() in SOLIDS: vbsp.VMF.create_ent( classname='func_instance', origin=position, angles=supp_ang, file=support_file, )
def res_unst_scaffold_setup(res: Property): group = res['group', 'DEFAULT_GROUP'] if group not in SCAFFOLD_CONFIGS: # Store our values in the CONFIGS dictionary targ_inst, links = SCAFFOLD_CONFIGS[group] = {}, {} else: # Grab the already-filled values, and add to them targ_inst, links = SCAFFOLD_CONFIGS[group] for block in res.find_all("Instance"): conf = { # If set, adjusts the offset appropriately 'is_piston': srctools.conv_bool(block['isPiston', '0']), 'rotate_logic': srctools.conv_bool(block['AlterAng', '1'], True), 'off_floor': Vec.from_str(block['FloorOff', '0 0 0']), 'off_wall': Vec.from_str(block['WallOff', '0 0 0']), 'logic_start': block['startlogic', ''], 'logic_end': block['endLogic', ''], 'logic_mid': block['midLogic', ''], 'logic_start_rev': block['StartLogicRev', None], 'logic_end_rev': block['EndLogicRev', None], 'logic_mid_rev': block['EndLogicRev', None], 'inst_wall': block['wallInst', ''], 'inst_floor': block['floorInst', ''], 'inst_offset': block['offsetInst', None], # Specially rotated to face the next track! 'inst_end': block['endInst', None], } for logic_type in ('logic_start', 'logic_mid', 'logic_end'): if conf[logic_type + '_rev'] is None: conf[logic_type + '_rev'] = conf[logic_type] for inst in instanceLocs.resolve(block['file']): targ_inst[inst] = conf # We need to provide vars to link the tracks and beams. for block in res.find_all('LinkEnt'): # The name for this set of entities. # It must be a '@' name, or the name will be fixed-up incorrectly! loc_name = block['name'] if not loc_name.startswith('@'): loc_name = '@' + loc_name links[block['nameVar']] = { 'name': loc_name, # The next entity (not set in end logic) 'next': block['nextVar'], # A '*' name to reference all the ents (set on the start logic) 'all': block['allVar', None], } return group # We look up the group name to find the values.
def flag_blockpos_type(inst: Entity, flag: Property): """Determine the type of a grid position. If the value is single value, that should be the type. Otherwise, the value should be a block with 'offset' and 'type' values. The offset is in block increments, with 0 0 0 equal to the mounting surface. If 'offset2' is also provided, all positions in the bounding box will be checked. The type should be a space-seperated list of locations: * `VOID` (Outside the map) * `SOLID` (Full wall cube) * `EMBED` (Hollow wall cube) * `AIR` (Inside the map, may be occupied by items) * `OCCUPIED` (Known to be occupied by items) * `PIT` (Bottomless pits, any) * `PIT_SINGLE` (one-high) * `PIT_TOP` * `PIT_MID` * `PIT_BOTTOM` * `GOO` * `GOO_SINGLE` (one-deep goo) * `GOO_TOP` (goo surface) * `GOO_MID` * `GOO_BOTTOM` (floor) """ pos2 = None if flag.has_children(): pos1 = resolve_offset(inst, flag['offset', '0 0 0'], scale=128, zoff=-128) types = flag['type'].split() if 'offset2' in flag: pos2 = resolve_offset(inst, flag.value, scale=128, zoff=-128) else: types = flag.value.split() pos1 = Vec() if pos2 is not None: bbox = Vec.iter_grid(*Vec.bbox(pos1, pos2), stride=128) else: bbox = [pos1] for pos in bbox: block = brushLoc.POS['world': pos] for block_type in types: try: allowed = brushLoc.BLOCK_LOOKUP[block_type.casefold()] except KeyError: raise ValueError('"{}" is not a valid block type!'.format(block_type)) if block in allowed: break # To next position else: return False # Didn't match any in this list. return True # Matched all positions.
def res_camera_setup(res: Property): return { 'cam_off': Vec.from_str(res['CamOff', '']), 'yaw_off': Vec.from_str(res['YawOff', '']), 'pitch_off': Vec.from_str(res['PitchOff', '']), 'yaw_inst': instanceLocs.resolve_one(res['yawInst', '']), 'pitch_inst': instanceLocs.resolve_one(res['pitchInst', '']), 'yaw_range': srctools.conv_int(res['YawRange', ''], 90), 'pitch_range': srctools.conv_int(res['YawRange', ''], 90), }
def res_unst_scaffold_setup(res: Property): group = res["group", "DEFAULT_GROUP"] if group not in SCAFFOLD_CONFIGS: # Store our values in the CONFIGS dictionary targ_inst, links = SCAFFOLD_CONFIGS[group] = {}, {} else: # Grab the already-filled values, and add to them targ_inst, links = SCAFFOLD_CONFIGS[group] for block in res.find_all("Instance"): conf = { # If set, adjusts the offset appropriately "is_piston": srctools.conv_bool(block["isPiston", "0"]), "rotate_logic": srctools.conv_bool(block["AlterAng", "1"], True), "off_floor": Vec.from_str(block["FloorOff", "0 0 0"]), "off_wall": Vec.from_str(block["WallOff", "0 0 0"]), "logic_start": block["startlogic", ""], "logic_end": block["endLogic", ""], "logic_mid": block["midLogic", ""], "logic_start_rev": block["StartLogicRev", None], "logic_end_rev": block["EndLogicRev", None], "logic_mid_rev": block["EndLogicRev", None], "inst_wall": block["wallInst", ""], "inst_floor": block["floorInst", ""], "inst_offset": block["offsetInst", None], # Specially rotated to face the next track! "inst_end": block["endInst", None], } for logic_type in ("logic_start", "logic_mid", "logic_end"): if conf[logic_type + "_rev"] is None: conf[logic_type + "_rev"] = conf[logic_type] for inst in resolve_inst(block["file"]): targ_inst[inst] = conf # We need to provide vars to link the tracks and beams. for block in res.find_all("LinkEnt"): # The name for this set of entities. # It must be a '@' name, or the name will be fixed-up incorrectly! loc_name = block["name"] if not loc_name.startswith("@"): loc_name = "@" + loc_name links[block["nameVar"]] = { "name": loc_name, # The next entity (not set in end logic) "next": block["nextVar"], # A '*' name to reference all the ents (set on the start logic) "all": block["allVar", None], } return group # We look up the group name to find the values.
def flag_goo_at_loc(inst: Entity, flag: Property): """Check to see if a given location is submerged in goo. 0 0 0 is the origin of the instance, values are in 128 increments. """ pos = Vec.from_str(flag.value).rotate_by_str(inst['angles', '0 0 0']) pos *= 128 pos += Vec.from_str(inst['origin']) # Round to 128 units, then offset to the center pos = pos // 128 * 128 + 64 # type: Vec val = pos.as_tuple() in GOO_LOCS return val
def res_make_funnel_light(inst: Entity): """Place a light for Funnel items.""" oran_on = inst.fixup.bool('$start_reversed') need_blue = need_oran = False name = '' if inst.fixup['$connectioncount_polarity'] != '0': import vbsp if not vbsp.settings['style_vars']['funnelallowswitchedlights']: # Allow disabling adding switchable lights. return name = conditions.local_name(inst, 'light') need_blue = need_oran = True else: if oran_on: need_oran = True else: need_blue = True loc = Vec(0, 0, -56) loc.localise(Vec.from_str(inst['origin']), Vec.from_str(inst['angles'])) if need_blue: inst.map.create_ent( classname='light', targetname=name + '_b' if name else '', spawnflags=int(oran_on), # 1 = Initially Dark origin=loc, _light='50 120 250 50', _lightHDR='-1 -1 -1 1', _lightscaleHDR=2, _fifty_percent_distance=48, _zero_percent_distance=96, _hardfalloff=1, _distance=0, style=0, ) if need_oran: inst.map.create_ent( classname='light', targetname=name + '_o' if name else '', spawnflags=int(not oran_on), origin=loc, _light='250 120 50 50', _lightHDR='-1 -1 -1 1', _lightscaleHDR=2, _fifty_percent_distance=48, _zero_percent_distance=96, _hardfalloff=1, _distance=0, style=0, )
def _calc_fizz_angles() -> None: """Generate FIZZ_ANGLES.""" it = itertools.product('xyz', (-1, 1), 'xyz', (-1, 1)) for norm_axis, norm_mag, roll_axis, roll_mag in it: if norm_axis == roll_axis: # They can't both be the same... continue norm = Vec.with_axes(norm_axis, norm_mag) roll = Vec.with_axes(roll_axis, roll_mag) # Norm is Z, roll is X, we want y. angle = roll.to_angle_roll(norm) up_dir = norm.cross(roll) FIZZ_ANGLES[norm.as_tuple(), up_dir.as_tuple()] = angle
def res_monitor(inst: Entity, res: Property) -> None: """Result for the monitor component. """ import vbsp ( break_inst, bullseye_name, bullseye_loc, bullseye_parent, ) = res.value ALL_MONITORS.append(Monitor(inst)) has_laser = vbsp.settings['has_attr']['laser'] # Allow turrets if the monitor is setup to allow it, and the actor should # be shot. needs_turret = bullseye_name and vbsp_options.get(bool, 'voice_studio_should_shoot') inst.fixup['$is_breakable'] = has_laser or needs_turret # We need to generate an ai_relationship, which makes turrets hate # a bullseye. if needs_turret: loc = Vec(bullseye_loc) loc.localise( Vec.from_str(inst['origin']), Vec.from_str(inst['angles']), ) bullseye_name = local_name(inst, bullseye_name) inst.map.create_ent( classname='npc_bullseye', targetname=bullseye_name, parentname=local_name(inst, bullseye_parent), spawnflags=221186, # Non-solid, invisible, etc.. origin=loc, ) relation = inst.map.create_ent( classname='ai_relationship', targetname='@monitor_turr_hate', spawnflags=2, # Notify turrets about monitor locations disposition=1, # Hate origin=loc, subject='npc_portal_turret_floor', target=bullseye_name, ) MONITOR_RELATIONSHIP_ENTS.append(relation)
def get_config( node: item_chain.Node, ) -> Tuple[str, Vec]: """Compute the config values for a node.""" orient = ( 'floor' if Vec(0, 0, 1).rotate_by_str(node.inst['angles']) == (0, 0, 1) else 'wall' ) # Find the offset used for the platform. offset = (node.conf['off_' + orient]).copy() # type: Vec if node.conf['is_piston']: # Adjust based on the piston position offset.z += 128 * srctools.conv_int( node.inst.fixup[ '$top_level' if node.inst.fixup[ '$start_up'] == '1' else '$bottom_level' ] ) offset.rotate_by_str(node.inst['angles']) offset += Vec.from_str(node.inst['origin']) return orient, offset
def track_scan( tr_set: Set[Entity], track_inst: Dict[Tuple[float, float, float], Entity], start_track: Entity, middle_file: str, x_dir: int, ): """Build a set of track instances extending from a point. :param track_inst: A dictionary mapping origins to track instances :param start_track: The instance we start on :param middle_file: The file for the center track piece :param x_dir: The direction to look (-1 or 1) """ track = start_track move_dir = Vec(x_dir*128, 0, 0).rotate_by_str(track['angles']) while track: tr_set.add(track) next_pos = Vec.from_str(track['origin']) + move_dir track = track_inst.get(next_pos.as_tuple(), None) if track is None: return if track['file'].casefold() != middle_file: # If the next piece is an end section, add it then quit tr_set.add(track) return
def calc_fizzler_orient(fizzler: Fizzler): # Figure out how to compare for this fizzler. s, l = Vec.bbox(itertools.chain.from_iterable(fizzler.emitters)) # If it's horizontal, signs should point to the center: if abs(s.z - l.z) == 2: return ( 'z', s.x + l.x / 2, s.y + l.y / 2, s.z + 1, ) # For the vertical directions, we want to compare based on the line segment. if abs(s.x - l.x) == 2: # Y direction return ( 'y', s.y, l.y, s.x + 1, ) else: # Extends in X direction return ( 'x', s.x, l.x, s.y + 1, )
def res_make_tag_coop_spawn(vmf: VMF, inst: Entity, res: Property): """Create the spawn point for ATLAS in the entry corridor. It produces either an instance or the normal spawn entity. This is required since ATLAS may need to have the paint gun logic. The two parameters `origin` and `facing` must be set to determine the required position. If `global` is set, the spawn point will be absolute instead of relative to the current instance. """ if vbsp.GAME_MODE != 'COOP': return RES_EXHAUSTED is_tag = vbsp_options.get(str, 'game_id') == utils.STEAM_IDS['TAG'] origin = res.vec('origin') normal = res.vec('facing', z=1) # Some styles might want to ignore the instance we're running on. if not res.bool('global'): origin = origin.rotate_by_str(inst['angles']) normal = normal.rotate_by_str(inst['angles']) origin += Vec.from_str(inst['origin']) angles = normal.to_angle() if is_tag: vmf.create_ent( classname='func_instance', targetname='paint_gun', origin=origin - (0, 0, 16), angles=angles, # Generated by the BEE2 app. file='instances/bee2/tag_coop_gun.vmf', ) # Blocks ATLAS from having a gun vmf.create_ent( classname='info_target', targetname='supress_blue_portalgun_spawn', origin=origin, angles='0 0 0', ) # Allows info_target to work vmf.create_ent( classname='env_global', targetname='no_spawns', globalstate='portalgun_nospawn', initialstate=1, spawnflags=1, # Use initial state origin=origin, ) vmf.create_ent( classname='info_coop_spawn', targetname='@coop_spawn_blue', ForceGunOnSpawn=int(not is_tag), origin=origin, angles=angles, enabled=1, StartingTeam=3, # ATLAS ) return RES_EXHAUSTED
def res_water_splash_setup(res: Property): parent = res['parent'] name = res['name'] scale = srctools.conv_float(res['scale', ''], 8.0) pos1 = Vec.from_str(res['position', '']) calc_type = res['type', ''] pos2 = res['position2', ''] fast_check = srctools.conv_bool(res['fast_check', '']) return name, parent, scale, pos1, pos2, calc_type, fast_check
def gen_rotated_squarebeams(p1: Vec, p2: Vec, skin, max_rot: int): """Generate broken/rotated squarebeams in a region. They will be rotated around their centers, not the model origin. """ z = min(p1.z, p2.z) + 3 # The center of the beams for x, y in utils.iter_grid(min_x=int(p1.x), min_y=int(p1.y), max_x=int(p2.x), max_y=int(p2.y), stride=64): rand_x = random.randint(-max_rot, max_rot) / BEAM_ROT_PRECISION rand_z = random.randint(-max_rot, max_rot) / BEAM_ROT_PRECISION # Don't rotate around yaw - the vertical axis. # Squarebeams are offset 5 units from their real center offset = Vec(0, 0, 5).rotate(rand_x, 0, rand_z) prop = _make_squarebeam(Vec(x + 32, y + 32, z) + offset, skin=skin) prop['angles'] = '{} 0 {}'.format(rand_x, rand_z)
def res_create_entity(vmf: VMF, inst: Entity, res: Property): """Create an entity. * `keys` and `localkeys` defines the new keyvalues used. * `Origin` will be used to offset the given amount from the current location. """ origin = Vec.from_str(inst['origin']) new_ent = vmf.create_ent( # Ensure there's a classname, just in case. classname='info_null') conditions.set_ent_keys(new_ent, inst, res) origin += Vec.from_str(new_ent['origin']).rotate_by_str(inst['angles']) new_ent['origin'] = origin new_ent['angles'] = inst['angles']
def res_cube_coloriser(inst: Entity): """Allows recoloring cubes placed at a position.""" origin = Vec.from_str(inst['origin']) timer_delay = inst.fixup.int('$timer_delay') if 3 <= timer_delay <= 30: COLOR_POS[origin.as_tuple()] = COLORS[timer_delay - 3] else: LOGGER.warning('Unknown timer value "{}"!', timer_delay) inst.remove() # If pointing up, copy the value to the ceiling, so droppers # can find a coloriser placed on the illusory cube item under them. if Vec(z=1).rotate_by_str(inst['angles']) == (0, 0, 1): pos = brushLoc.POS.raycast_world( origin, direction=(0, 0, 1), ) COLOR_SEC_POS[pos.as_tuple()] = COLORS[timer_delay - 3]
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 mode_handle(comp_ent: Entity, ent: Entity) -> str: """Compute and return a handle to tis entity.""" if ent['targetname']: return 'Entities.FindByName(null, "{}")'.format(ent['targetname']) else: # No name, use classname and position. return 'Entities.FindByClassnameWithin(null, "{}", {}, 1)'.format( ent['classname'], vs_vec(Vec.from_str(ent['origin'])) )
def _fill_norm_rotations() -> Dict[ Tuple[Tuple[float, float, float], Tuple[float, float, float]], Tuple[float, float, float] ]: """Given a norm->norm rotation, return the angles producing that.""" rotations = {} for norm_ax in 'xyz': for norm_mag in [-1, +1]: norm = Vec.with_axes(norm_ax, norm_mag) for angle_ax in 'xyz': for angle_mag in (-90, 90): angle = Vec.with_axes(angle_ax, angle_mag) new_norm = norm.copy().rotate(*angle) if new_norm != norm: rotations[tuple(norm), tuple(new_norm)] = angle.as_tuple() # Assign a null rotation as well. rotations[tuple(norm), tuple(norm)] = (0.0, 0.0, 0.0) rotations[tuple(norm), tuple(-norm)] = (0.0, 0.0, 0.0) return rotations
def res_hollow_brush(inst: Entity, res: Property): """Hollow out the attached brush, as if EmbeddedVoxel was set. This just removes the surface if it's already an embeddedVoxel. This allows multiple items to embed thinly in the same block without affecting each other. """ loc = Vec(0, 0, -64).rotate_by_str(inst['angles']) loc += Vec.from_str(inst['origin']) try: group = SOLIDS[loc.as_tuple()] except KeyError: LOGGER.warning('No brush for hollowing at ({})', loc) return # No brush here? conditions.hollow_block(group, remove_orig_face=srctools.conv_bool( res['RemoveFace', False]))
def res_water_splash_setup(res: Property): parent = res['parent'] name = res['name'] scale = srctools.conv_float(res['scale', ''], 8.0) pos1 = Vec.from_str(res['position', '']) calc_type = res['type', ''] pos2 = res['position2', ''] fast_check = srctools.conv_bool(res['fast_check', '']) return name, parent, scale, pos1, pos2, calc_type, fast_check
def load(opt_blocks: Iterator[Property]) -> None: """Read settings from the given property block.""" SETTINGS.clear() set_vals = {} for opt_block in opt_blocks: for prop in opt_block: set_vals[prop.name] = prop.value options = {opt.id: opt for opt in DEFAULTS} if len(options) != len(DEFAULTS): from collections import Counter # Find ids used more than once.. raise Exception('Duplicate option(s)! ({})'.format(', '.join( k for k, v in Counter(opt.id for opt in DEFAULTS).items() if v > 1 ))) fallback_opts = [] for opt in DEFAULTS: try: val = set_vals.pop(opt.id) except KeyError: if opt.fallback is not None: fallback_opts.append(opt) assert opt.fallback in options, 'Invalid fallback in ' + opt.id else: SETTINGS[opt.id] = opt.default continue if opt.type is TYPE.VEC: # Pass nones so we can check if it failed.. parsed_vals = parse_vec_str(val, x=None) if parsed_vals[0] is None: SETTINGS[opt.id] = opt.default else: SETTINGS[opt.id] = Vec(*parsed_vals) elif opt.type is TYPE.BOOL: SETTINGS[opt.id] = srctools.conv_bool(val, opt.default) else: # int, float, str - no special handling... try: SETTINGS[opt.id] = opt.type.convert(val) except (ValueError, TypeError): SETTINGS[opt.id] = opt.default for opt in fallback_opts: try: SETTINGS[opt.id] = SETTINGS[opt.fallback] except KeyError: raise Exception('Bad fallback for "{}"!'.format(opt.id)) # Check they have the same type. assert opt.type is options[opt.fallback].type if set_vals: LOGGER.warning('Extra config options: {}', set_vals)
def res_make_tag_coop_spawn(vmf: VMF, inst: Entity, res: Property): """Create the spawn point for ATLAS, in Aperture Tag. This creates an instance with the desired orientation. The two parameters 'origin' and 'angles' must be set. """ if vbsp.GAME_MODE != 'COOP': return RES_EXHAUSTED is_tag = vbsp_options.get(str, 'game_id') == utils.STEAM_IDS['TAG'] offset = res.vec('origin').rotate_by_str(inst['angles']) normal = res.vec('facing', z=1).rotate_by_str( inst['angles'], ) origin = Vec.from_str(inst['origin']) origin += offset angles = normal.to_angle() if is_tag: vmf.create_ent( classname='func_instance', targetname='paint_gun', origin=origin - (0, 0, 16), angles=angles, # Generated by the BEE2 app. file='instances/bee2/tag_coop_gun.vmf', ) # Blocks ATLAS from having a gun vmf.create_ent( classname='info_target', targetname='supress_blue_portalgun_spawn', origin=origin, angles='0 0 0', ) # Allows info_target to work vmf.create_ent( classname='env_global', targetname='no_spawns', globalstate='portalgun_nospawn', initialstate=1, spawnflags=1, # Use initial state origin=origin, ) vmf.create_ent( classname='info_coop_spawn', targetname='@coop_spawn_blue', ForceGunOnSpawn=int(not is_tag), origin=origin, angles=angles, enabled=1, StartingTeam=3, # ATLAS ) return RES_EXHAUSTED
def res_set_block(inst: Entity, res: Property) -> None: """Set a block to the given value, overwriting the existing value. - `type` is the type of block to set: * `VOID` (Outside the map) * `SOLID` (Full wall cube) * `EMBED` (Hollow wall cube) * `AIR` (Inside the map, may be occupied by items) * `OCCUPIED` (Known to be occupied by items) * `PIT_SINGLE` (one-high) * `PIT_TOP` * `PIT_MID` * `PIT_BOTTOM` * `GOO_SINGLE` (one-deep goo) * `GOO_TOP` (goo surface) * `GOO_MID` * `GOO_BOTTOM` (floor) - `offset` is in block increments, with `0 0 0` equal to the mounting surface. - If 'offset2' is also provided, all positions in the bounding box will be set. """ try: new_vals = brushLoc.BLOCK_LOOKUP[res['type'].casefold()] except KeyError: raise ValueError('"{}" is not a valid block type!'.format(res['type'])) try: [new_val] = new_vals except ValueError: # TODO: This could spread top/mid/bottom through the bbox... raise ValueError( f'Can\'t use compound block type "{res["type"]}", specify ' "_SINGLE/TOP/MID/BOTTOM" ) pos1 = resolve_offset(inst, res['offset', '0 0 0'], scale=128, zoff=-128) if 'offset2' in res: pos2 = resolve_offset(inst, res['offset2', '0 0 0'], scale=128, zoff=-128) for pos in Vec.iter_grid(*Vec.bbox(pos1, pos2), stride=128): brushLoc.POS['world': pos] = new_val else: brushLoc.POS['world': pos1] = new_val
def test_ang_matrix_roundtrip(py_c_vec): """Check converting to and from a Matrix does not change values.""" Vec, Angle, Matrix, parse_vec_str = py_c_vec for p, y, r in iter_vec(range(0, 360, 90)): vert = Vec(x=1).rotate(p, y, r).z if vert < 0.99 or vert > 0.99: # If nearly vertical, gimbal lock prevents roundtrips. continue mat = Matrix.from_angle(Angle(p, y, r)) assert_ang(mat.to_angle(), p, y, r)
def res_create_entity(vmf: VMF, inst: Entity, res: Property): """Create an entity. 'keys' and 'localkeys' defines the new keyvalues used. 'Origin' will be used to offset the given amount from the current location. """ origin = Vec.from_str(inst['origin']) new_ent = vmf.create_ent( # Ensure there's a classname, just in case. classname='info_null' ) conditions.set_ent_keys(new_ent, inst, res) origin += Vec.from_str(new_ent['origin']).rotate_by_str(inst['angles']) new_ent['origin'] = origin new_ent['angles'] = inst['angles']
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 push_trigger(vmf: VMF, loc: Vec, normal: Vec, solids: list[Solid]) -> None: """Generate the push trigger for these solids.""" # We only need one trigger per direction, for now. try: ent = PUSH_TRIGS[normal.as_tuple()] except KeyError: ent = PUSH_TRIGS[normal.as_tuple()] = vmf.create_ent( classname='trigger_push', origin=loc, # The z-direction is reversed.. pushdir=normal.to_angle(), speed=( UP_PUSH_SPEED if normal.z > 1e-6 else DN_PUSH_SPEED if normal.z < -1e-6 else PUSH_SPEED ), spawnflags='1103', # Clients, Physics, Everything ) ent.solids.extend(solids)
def __init__(self, ent: Entity): """Convert the entity to have the right logic.""" self.scanner = None self.persist_tv = conv_bool(ent.keys.pop('persist_tv', False)) pos = Vec.from_str(ent['origin']) for prop in ent.map.by_class['prop_dynamic']: if (Vec.from_str(prop['origin']) - pos).mag_sq() > 64**2: continue model = prop['model'].casefold().replace('\\', '/') # Allow spelling this correctly, if you're not Valve. if 'vacum_scanner_tv' in model or 'vacuum_scanner_tv' in model: self.scanner = prop prop.make_unique('_vac_scanner') elif 'vacum_scanner_motion' in model or 'vacuum_scanner_motion' in model: prop.make_unique('_vac_scanner') ent.add_out(Output(self.pass_out_name, prop, "SetAnimation", "scan01")) super(Straight, self).__init__(ent)
def res_hollow_brush(inst: Entity, res: Property): """Hollow out the attached brush, as if EmbeddedVoxel was set. This just removes the surface if it's already an embeddedVoxel. This allows multiple items to embed thinly in the same block without affecting each other. """ loc = Vec(0, 0, -64).rotate_by_str(inst['angles']) loc += Vec.from_str(inst['origin']) try: group = SOLIDS[loc.as_tuple()] except KeyError: LOGGER.warning('No brush for hollowing at ({})', loc) return # No brush here? conditions.hollow_block( group, remove_orig_face=srctools.conv_bool(res['RemoveFace', False]) )
def res_force_upright(inst: Entity): """Position an instance to orient upwards while keeping the normal. The result angle will have pitch and roll set to 0. Vertical instances are unaffected. """ normal = Vec(0, 0, 1).rotate_by_str(inst['angles']) if normal.z != 0: return ang = math.degrees(math.atan2(normal.y, normal.x)) inst['angles'] = '0 {:g} 0'.format(ang % 360) # Don't use negatives
def _conv_key(pos: _grid_keys) -> Vec_tuple: """Convert the key given in [] to a grid-position, as a x,y,z tuple.""" if isinstance(pos, slice): system, pos = pos.start, pos.stop pos = Grid._conv_key(pos) if system == 'world': return tuple(world_to_grid(Vec(pos))) else: return pos x, y, z = pos return x, y, z
def res_sendificator(vmf: VMF, inst: Entity): """Implement Sendificators.""" # For our version, we know which sendtor connects to what laser, # so we can couple the logic together (avoiding @sendtor_mutex). sendtor_name = inst['targetname'] sendtor = connections.ITEMS[sendtor_name] sendtor.enable_cmd += (Output( '', f'@{sendtor_name}_las_relay_*', 'Trigger', delay=0.01, ), ) for ind, conn in enumerate(list(sendtor.outputs), start=1): las_item = conn.to_item conn.remove() try: targ_offset, targ_normal = SENDTOR_TARGETS[las_item.name] except KeyError: LOGGER.warning('"{}" is not a Sendificator target!', las_item.name) continue orient = Matrix.from_angle(Angle.from_str(las_item.inst['angles'])) targ_offset = Vec.from_str( las_item.inst['origin']) + targ_offset @ orient targ_normal = targ_normal @ orient relay_name = f'@{sendtor_name}_las_relay_{ind}' relay = vmf.create_ent( 'logic_relay', targetname=relay_name, origin=targ_offset, angles=targ_normal.to_angle(), ) relay.add_out( Output('OnTrigger', '!self', 'RunScriptCode', '::sendtor_source <- self;'), Output('OnTrigger', '@sendtor_fire', 'Trigger'), ) if not las_item.inputs: # No other inputs, make it on always. PeTI automatically turns # it off when inputs are connected, which is annoying. las_item.inst.fixup['$start_enabled'] = '1' is_on = True else: is_on = las_item.inst.fixup.bool('$start_enabled') relay['StartDisabled'] = not is_on las_item.enable_cmd += (Output('', relay_name, 'Enable'), ) las_item.disable_cmd += (Output('', relay_name, 'Disable'), )
def raycast( self, pos: _grid_keys, direction: Vec, collide: Iterable[Block]=frozenset({ Block.SOLID, Block.EMBED, Block.PIT_BOTTOM, Block.PIT_SINGLE, }), ) -> Vec: """Move in a direction until hitting a block of a certain type. This returns the position just before hitting a block (which might be the start position.) The direction vector should be integer numbers (1/0 usually). collide is the set of position types to stop at. The default is all "solid" walls. ValueError is raised if VOID is encountered, or this moves outside the map. """ start_pos = pos = Vec(*_conv_key(pos)) direction = Vec(direction) collide_set = frozenset(collide) # 50x50x50 diagonal = 86, so that's the largest distance # you could possibly move. for i in range(90): next_pos = pos + direction block = super().get(next_pos.as_tuple(), Block.VOID) if block is Block.VOID: raise ValueError( 'Reached VOID at ({}) when ' 'raycasting from {} with direction {}!'.format( next_pos, start_pos, direction ) ) if block in collide_set: return pos pos = next_pos else: raise ValueError('Moved too far! (> 90)')
def make_color_swatch(parent: tk.Frame, var: tk.StringVar, size=16) -> ttk.Label: """Make a single swatch.""" # Note: tkinter requires RGB as ints, not float! color = var.get() if color.startswith('#'): try: r, g, b = int(var[0:2], base=16), int(var[2:4], base=16), int(var[4:], base=16) except ValueError: LOGGER.warning('Invalid RGB value: "{}"!', color) r = g = b = 128 else: r, g, b = map(int, Vec.from_str(color, 128, 128, 128)) def open_win(e): """Display the color selection window.""" nonlocal r, g, b widget_sfx() new_color, tk_color = askcolor( color=(r, g, b), parent=parent.winfo_toplevel(), title=_('Choose a Color'), ) if new_color is not None: r, g, b = map(int, new_color) # Returned as floats, which is wrong. var.set('{} {} {}'.format(int(r), int(g), int(b))) swatch['image'] = img.color_square(round(Vec(r, g, b)), size) swatch = ttk.Label( parent, relief='raised', image=img.color_square(Vec(r, g, b), size), ) utils.bind_leftclick(swatch, open_win) return swatch
def save_occupiedvoxel(item: Item, vmf: VMF) -> None: """Save occupied voxel volumes.""" for voxel in item.occupy_voxels: pos = Vec(voxel.pos) * 128 if voxel.subpos is not None: pos += Vec(voxel.subpos) * 32 - (48, 48, 48) p1 = pos - (16.0, 16.0, 16.0) p2 = pos + (16.0, 16.0, 16.0) norm_dist = 32.0 - 4.0 else: p1 = pos - (64.0, 64.0, 64.0) p2 = pos + (64.0, 64.0, 64.0) norm_dist = 128.0 - 4.0 if voxel.normal is not None: for axis in ['x', 'y', 'z']: val = getattr(voxel.normal, axis) if val == +1: p2[axis] -= norm_dist elif val == -1: p1[axis] += norm_dist if voxel.against is not None: against = str(voxel.against).replace('COLLIDE_', '') else: against = '' vmf.create_ent( 'bee2_editor_occupiedvoxel', coll_type=str(voxel.type).replace('COLLIDE_', ''), coll_against=against, ).solids.append( vmf.make_prism( p1, p2, # Use clip for voxels, invisible for normals. # Entirely ignored, but makes it easier to use. 'tools/toolsclip' if voxel.normal is None else 'tools/toolsinvisible', ).solid)
def flag_angles(inst: Entity, flag: Property): """Check that a instance is pointed in a direction. The value should be either just the angle to check, or a block of options: - `Angle`: A unit vector (XYZ value) pointing in a direction, or some keywords: `+z`, `-y`, `N`/`S`/`E`/`W`, `up`/`down`, `floor`/`ceiling`, or `walls` for any wall side. - `From_dir`: The direction the unrotated instance is pointed in. This lets the flag check multiple directions - `Allow_inverse`: If true, this also returns True if the instance is pointed the opposite direction . """ angle = inst['angles', '0 0 0'] if flag.has_children(): targ_angle = flag['direction', '0 0 0'] from_dir = flag['from_dir', '0 0 1'] if from_dir.casefold() in DIRECTIONS: from_dir = Vec(DIRECTIONS[from_dir.casefold()]) else: from_dir = Vec.from_str(from_dir, 0, 0, 1) allow_inverse = srctools.conv_bool(flag['allow_inverse', '0']) else: targ_angle = flag.value from_dir = Vec(0, 0, 1) allow_inverse = False normal = DIRECTIONS.get(targ_angle.casefold(), None) if normal is None: return False # If it's not a special angle, # so it failed the exact match inst_normal = from_dir.rotate_by_str(angle) if normal == 'WALL': # Special case - it's not on the floor or ceiling return not (inst_normal == (0, 0, 1) or inst_normal == (0, 0, -1)) else: return inst_normal == normal or ( allow_inverse and -inst_normal == normal )
def res_make_tag_coop_spawn(vmf: VMF, inst: Entity, res: Property): """Create the spawn point for ATLAS, in Aperture Tag. This creates an instance with the desired orientation. The two parameters 'origin' and 'angles' must be set. """ if vbsp.GAME_MODE != 'COOP': return RES_EXHAUSTED is_tag = vbsp_options.get(str, 'game_id') == utils.STEAM_IDS['TAG'] offset = res.vec('origin').rotate_by_str(inst['angles']) normal = res.vec('facing', z=1).rotate_by_str(inst['angles'], ) origin = Vec.from_str(inst['origin']) origin += offset angles = normal.to_angle() if is_tag: vmf.create_ent( classname='func_instance', targetname='paint_gun', origin=origin - (0, 0, 16), angles=angles, # Generated by the BEE2 app. file='instances/bee2/tag_coop_gun.vmf', ) # Blocks ATLAS from having a gun vmf.create_ent( classname='info_target', targetname='supress_blue_portalgun_spawn', origin=origin, angles='0 0 0', ) # Allows info_target to work vmf.create_ent( classname='env_global', targetname='no_spawns', globalstate='portalgun_nospawn', initialstate=1, spawnflags=1, # Use initial state origin=origin, ) vmf.create_ent( classname='info_coop_spawn', targetname='@coop_spawn_blue', ForceGunOnSpawn=int(not is_tag), origin=origin, angles=angles, enabled=1, StartingTeam=3, # ATLAS ) return RES_EXHAUSTED
def _conv_key(pos: _grid_keys) -> Tuple[float, float, float]: """Convert the key given in [] to a grid-position, as a x,y,z tuple.""" # TODO: Slices are assumed to be int by typeshed. # type: ignore if isinstance(pos, slice): system, slice_pos = pos.start, pos.stop if system == 'world': return tuple(world_to_grid(Vec(slice_pos))) else: return tuple(slice_pos) x, y, z = pos return x, y, z
def gen_faithplates(vmf: VMF) -> None: """Place the targets and catapults into the map.""" # Target positions -> list of triggers wanting to aim there. pos_to_trigs: Dict[Union[Tuple[float, float, float], tiling.TileDef], List[Entity]] = collections.defaultdict(list) for plate in PLATES.values(): if isinstance(plate, (AngledPlate, PaintDropper)): targ_pos: Union[Tuple[float, float, float], tiling.TileDef] if isinstance(plate.target, tiling.TileDef): targ_pos = plate.target # Use the ID directly. else: targ_pos = plate.target.as_tuple() pos_to_trigs[targ_pos].append(plate.trig) if isinstance(plate, StraightPlate): trigs = [plate.trig, plate.helper_trig] else: trigs = [plate.trig] for trig in trigs: trig_origin = trig.get_origin() if plate.template is not None: trig.solids = template_brush.import_template( vmf, plate.template, trig_origin + plate.trig_offset, Angle.from_str(plate.inst['angles']), force_type=template_brush.TEMP_TYPES.world, add_to_map=False, ).world elif plate.trig_offset: for solid in trig.solids: solid.translate(plate.trig_offset) # Now, generate each target needed. for pos_or_tile, trigs in pos_to_trigs.items(): target = vmf.create_ent( 'info_target', angles='0 0 0', spawnflags='3', # Transmit to PVS and always transmit. ) if isinstance(pos_or_tile, tiling.TileDef): pos_or_tile.position_bullseye(target) else: # Static target. target['origin'] = Vec(pos_or_tile) target.make_unique('faith_target') for trig in trigs: trig['launchTarget'] = target['targetname']
def test_bbox_rotation( pitch: float, yaw: float, roll: float, ) -> None: """Test the rotation logic against the slow direct approach.""" ang = Angle(pitch, yaw, roll) bb_start = BBox(100, 200, 300, 300, 450, 600, contents=CollideType.ANTLINES, tags='blah') # Directly compute, by rotating all the angles, points = [ Vec(x, y, z) for x in [100, 300] for y in [200, 450] for z in [300, 600] ] result_ang = bb_start @ ang result_mat = bb_start @ Matrix.from_angle(ang) assert result_ang == result_mat bb_min, bb_max = Vec.bbox( point @ ang for point in points ) assert_bbox(result_mat, round(bb_min, 0), round(bb_max, 0), CollideType.ANTLINES, {'blah'})
def contains(self, point: Vec) -> bool: """Check if the given position is inside the volume.""" for convex in self.collision: for pos, norm in convex: off = pos - point # This is the actual distance, so we'll use a rather large # "epsilon" to catch objects close to the edges. if Vec.dot(off, norm) < -0.1: break # Outside a plane, it doesn't match this convex. else: # Inside all these planes, it's inside. return True return False # All failed, not present.
def res_create_entity(vmf: VMF, inst: Entity, res: Property): """Create an entity. * `keys` and `localkeys` defines the new keyvalues used. * `origin` and `angles` are local to the instance. """ origin = Vec.from_str(inst['origin']) orient = Angle.from_str(inst['angles']) new_ent = vmf.create_ent( # Ensure there's these critical values. classname='info_null', origin='0 0 0', angles='0 0 0', ) conditions.set_ent_keys(new_ent, inst, res) new_ent['origin'] = Vec.from_str(new_ent['origin']) @ orient + origin new_ent['angles'] = Angle.from_str(new_ent['angles']) @ orient
def test_minmax(): """Test Vec.min() and Vec.max().""" vec_a = Vec() vec_b = Vec() for a, b in MINMAX_VALUES: max_val = max(a, b) min_val = min(a, b) for axis in 'xyz': vec_a.x = vec_a.y = vec_a.z = 0 vec_b.x = vec_b.y = vec_b.z = 0 vec_a[axis] = a vec_b[axis] = b assert vec_a.min(vec_b) is None, (a, b, axis, min_val) assert vec_a[axis] == min_val, (a, b, axis, min_val) vec_a[axis] = a vec_b[axis] = b assert vec_a.max(vec_b) is None, (a, b, axis, max_val) assert vec_a[axis] == max_val, (a, b, axis, max_val)
def test_bad_from_basis(py_c_vec) -> None: """Test invalid arguments to Matrix.from_basis()""" Vec, Angle, Matrix, parse_vec_str = py_c_vec v = Vec(0, 1, 0) with pytest.raises(TypeError): Matrix.from_basis() with pytest.raises(TypeError): Matrix.from_basis(x=v) with pytest.raises(TypeError): Matrix.from_basis(y=v) with pytest.raises(TypeError): Matrix.from_basis(z=v)
def vactube_gen(vmf: VMF) -> None: """Generate the vactubes, after most conditions have run.""" if not VAC_TRACKS: return LOGGER.info('Generating vactubes...') for start, all_markers in VAC_TRACKS: start_normal = Vec(-1, 0, 0).rotate_by_str(start.ent['angles']) # First create the start section.. start_logic = start.ent.copy() vbsp.VMF.add_ent(start_logic) start_logic['file'] = start.conf['entry', ('ceiling' if (start_normal.z > 0) else 'floor' if (start_normal.z < 0) else 'wall')] end = start for inst, end in start.follow_path(all_markers): join_markers(inst, end, inst is start) end_loc = Vec.from_str(end.ent['origin']) end_norm = Vec(-1, 0, 0).rotate_by_str(end.ent['angles']) # join_markers creates straight parts up-to the marker, but not at it's # location - create the last one. make_straight( end_loc, end_norm, 128, end.conf, ) # If the end is placed in goo, don't add logic - it isn't visible, and # the object is on a one-way trip anyway. if BLOCK_POS['world':end_loc].is_goo and end_norm == (0, 0, -1): end_logic = end.ent.copy() vbsp.VMF.add_ent(end_logic) end_logic['file'] = end.conf['exit']
def test_old_rotation(py_c_vec) -> None: """Verify that the code matches the results from the earlier Vec.rotate code.""" Vec, Angle, Matrix, parse_vec_str = py_c_vec for pitch in range(0, 360, 15): for yaw in range(0, 360, 15): for roll in range(0, 360, 15): ang = Angle(pitch, yaw, roll) mat = Matrix.from_angle(ang) # Construct a matrix directly from 3 vector rotations. old_mat = Matrix() old_mat[0, 0], old_mat[0, 1], old_mat[0, 2] = old_rotate( Vec(x=1), pitch, yaw, roll) old_mat[1, 0], old_mat[1, 1], old_mat[1, 2] = old_rotate( Vec(y=1), pitch, yaw, roll) old_mat[2, 0], old_mat[2, 1], old_mat[2, 2] = old_rotate( Vec(z=1), pitch, yaw, roll) assert_rot(mat, old_mat, ang) old = old_rotate(Vec(128, 0, 0), pitch, yaw, roll) by_ang = Vec(128, 0, 0) @ ang by_mat = Vec(128, 0, 0) @ mat assert_vec(by_ang, old.x, old.y, old.z, ang, tol=1e-1) assert_vec(by_mat, old.x, old.y, old.z, ang, tol=1e-1)
def beam_hole_split(axis: str, min_pos: Vec, max_pos: Vec): """Break up floor beams to fit around holes.""" # Go along the shape. For each point, check if a hole is present, # and split at that. # Our positions are centered, but we return ones at the ends. # Inset in 4 units from each end to not overlap with the frames. start_pos = min_pos - Vec.with_axes(axis, 60) if HOLES: hole_size_large = vbsp_options.get(float, 'glass_hole_size_large') / 2 hole_size_small = vbsp_options.get(float, 'glass_hole_size_small') / 2 # Extract normal from the z-axis. grid_height = min_pos.z // 128 * 128 + 64 if grid_height < min_pos.z: normal = (0, 0, 1) else: normal = (0, 0, -1) import vbsp for pos in min_pos.iter_line(max_pos, 128): try: hole_type = HOLES[(pos.x, pos.y, grid_height), normal] except KeyError: continue else: if hole_type is HoleType.SMALL: size = hole_size_small elif hole_type is HoleType.LARGE: size = hole_size_large else: raise AssertionError(hole_type) yield start_pos, pos - Vec.with_axes(axis, size) start_pos = pos + Vec.with_axes(axis, size) # Last segment, or all if no holes. yield start_pos, max_pos + Vec.with_axes(axis, 60)
def join_markers(inst_a, inst_b, is_start=False): """Join two marker ents together with corners. This returns a list of solids used for the vphysics_motion trigger. """ origin_a = Vec.from_str(inst_a['ent']['origin']) origin_b = Vec.from_str(inst_b['ent']['origin']) norm_a = Vec(-1, 0, 0).rotate_by_str(inst_a['ent']['angles']) norm_b = Vec(-1, 0, 0).rotate_by_str(inst_b['ent']['angles']) config = inst_a['conf'] if norm_a == norm_b: # Either straight-line, or s-bend. dist = (origin_a - origin_b).mag() if origin_a + (norm_a * dist) == origin_b: make_straight( origin_a, norm_a, dist, config, is_start, ) # else: S-bend, we don't do the geometry for this.. return if norm_a == -norm_b: # U-shape bend.. make_ubend( origin_a, origin_b, norm_a, config, max_size=inst_a['size'], ) return try: corner_ang, flat_angle = CORNER_ANG[norm_a.as_tuple(), norm_b.as_tuple()] if origin_a[flat_angle] != origin_b[flat_angle]: # It needs to be flat in this angle! raise ValueError except ValueError: # The tubes need two corners to join together - abort for that. return else: make_bend( origin_a, origin_b, norm_a, norm_b, corner_ang, config, max_size=inst_a['size'], )
def get_color(): """Parse out the color.""" color = var.get() if color.startswith('#'): try: r = int(color[1:3], base=16) g = int(color[3:5], base=16) b = int(color[5:], base=16) except ValueError: LOGGER.warning('Invalid RGB value: "{}"!', color) r = g = b = 128 else: r, g, b = map(int, Vec.from_str(color, 128, 128, 128)) return r, g, b
def test_hole_spot(origin: Vec, normal: Vec, hole_type: HoleType): """Check if the given position is valid for holes. We need to check that it's actually placed on glass/grating, and that all the parts are the same. Otherwise it'd collide with the borders. """ try: center_type = BARRIERS[origin.as_tuple(), normal.as_tuple()] except KeyError: LOGGER.warning('No center barrier at {}, {}', origin, normal) return False if hole_type is HoleType.SMALL: return True u, v = Vec.INV_AXIS[normal.axis()] # The corners don't matter, but all 4 neighbours must be there. for u_off, v_off in [ (-128, 0), (0, -128), (128, 0), (0, 128), ]: pos = origin + Vec.with_axes(u, u_off, v, v_off) try: off_type = BARRIERS[pos.as_tuple(), normal.as_tuple()] except KeyError: # No side LOGGER.warning('No offset barrier at {}, {}', pos, normal) return False if off_type is not center_type: # Different type. LOGGER.warning('Wrong barrier type at {}, {}', pos, normal) return False return True