add first version of hijackcompiler

Author: TheEnderek0

src/hijackcompiler.py

@@ -0,0 +1,69 @@
+from sys import argv, stdout, exit
+from pathlib import Path
+import logging
+from logging import FileHandler
+from transformations import run_transforms, load_transforms
+
+import argparse
+
+from srctools.bsp import BSP
+
+
+OUR_PATH = Path(argv[0]).parent
+TRANSFORMS_PATH = OUR_PATH / "transforms"
+
+def main():
+    parser = argparse.ArgumentParser("HijackCompiler", description="A simple tool used to run postcompiler-like transforms in each compilation step.")
+
+    parser.add_argument("map")
+
+    parser.add_argument(
+        "tags",
+        action="extend",
+        nargs=argparse.REMAINDER,
+        default=[]
+        )
+
+    
+    result = parser.parse_args(argv[1:])
+
+    map_file = Path(result.map)
+    
+    handlers = [logging.StreamHandler(stdout), 
+                FileHandler(map_file.with_suffix(".log"))]
+    
+    logging.basicConfig(handlers=handlers, level=logging.INFO)
+    LOGGER = logging.getLogger("[Main]")
+
+    LOGGER.info("HijackCompiler started.")
+
+    LOGGER.info(f"Loading map file: {map_file}")
+
+    if not map_file.suffix == ".bsp":
+        LOGGER.error(f"Unsupported file type: {map_file.suffix}")
+        exit(1)
+
+
+    loaded_map = BSP(map_file)
+
+    LOGGER.info("Loaded!")
+    LOGGER.info(f"Loading transforms from {TRANSFORMS_PATH}")
+
+    load_transforms(TRANSFORMS_PATH)
+
+    tags = [x.casefold() for x in result.tags]
+
+    LOGGER.info(f"Running transforms with tags: {tags}")
+
+    run_transforms(loaded_map, tags)
+
+    LOGGER.info("Finished! Saving map...")
+    loaded_map.save()
+
+
+
+    
+
+
+if __name__ == "__main__":
+    main()

src/transformations.py

@@ -0,0 +1,55 @@
+"""Handles the transformations"""
+
+from srctools.bsp import BSP
+from pathlib import Path
+import importlib
+import logging
+import pkgutil
+
+TRANSFORMATIONS: dict[str, list] = {}
+LOGGER = logging.getLogger("[Transformations]")
+
+def Transform(name: str, tags: list[str] = []):
+    """Add a function to the transformations list"""
+    
+    if type(tags) == str:
+        tags = [tags]
+
+    def dec(func):
+        func = (name, func)
+        global TRANSFORMATIONS
+        
+
+        for tag in tags:
+            try:
+                l = TRANSFORMATIONS[tag]
+                l.append(func)
+            except KeyError:
+                TRANSFORMATIONS[tag] = [func]
+        
+        return func
+
+    LOGGER.info(f"Loading module '{name}'")
+
+    return dec
+
+
+
+
+def load_transforms(transforms_path: Path):
+    for item in pkgutil.iter_modules([transforms_path]):
+        importlib.import_module(transforms_path.name + "." + item.name)
+
+def run_transforms(bsp_file: BSP, tags:list[str]):
+
+    already_ran = set()
+    for tag in tags:
+        if not tag in TRANSFORMATIONS.keys():
+            continue
+
+        for name, func in TRANSFORMATIONS[tag]:
+            if not name in already_ran:
+                LOGGER.info(f"Running transform |{name}|")
+                func(bsp_file)
+                already_ran.add(name)
+    

src/transforms/dynamic_priority.py

@@ -0,0 +1,20 @@
+from transformations import Transform
+
+from srctools import Entity, conv_int, Vec
+from srctools.bsp import BSP
+import logging
+
+LOGGER = logging.getLogger("[Transform][Dynamic Priority]")
+
+@Transform("Dynamic Priority - Part 2", ["after_vrad"])
+def dynamic_priority(bsp: BSP):
+
+    light: Entity
+
+    # These lights are changed so that VRAD doesn't assign lightmap pages for them.
+
+    for light in bsp.ents.by_class["_dynpr_rt_spot"]:
+        light["classname"] = "light_rt_spot"
+
+    for light in bsp.ents.by_class["_dynpr_rt"]:
+        light["classname"] = "light_rt"