flaremc 0.1.0__py3-none-any.whl

flare/__init__.py

@@ -0,0 +1,11 @@
+from .compiler import _flatten_and, _eval_to_bool_score, _compile_relational
+from .context import namespace, export, tick, push_context, runcommand, files, temp_obj, constant_obj, vars_obj, \
+    constants, _flare_assign, _flare_print, dbg
+from .control_flow import _flare_if, _flare_while, _flare_for
+from .types import NBTType, byte, boolean, short, long, double
+from .variables import score, nbt, fixed, ref, getscore, nbtbyte, nbtbool, nbtshort, nbtint, nbtlong, nbtfloat, \
+    nbtdouble, nbtstr, nbtlist, nbtdict, nbtbytearray, nbtintarray, nbtlongarray
+
+__all__ = ["namespace", "export", "tick", "score", "nbt", "fixed", "ref", "getscore", "_flare_print", "dbg", "nbtbyte", "nbtbool",
+    "nbtshort", "nbtint", "nbtlong", "nbtfloat", "nbtdouble", "nbtstr", "nbtlist", "nbtdict", "nbtbytearray",
+    "nbtintarray", "nbtlongarray"]

flare/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

flare/cli.py

@@ -0,0 +1,311 @@
+import argparse
+import ast
+import json
+import os
+import shutil
+import sys
+import time
+from pathlib import Path
+
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+from flare import context
+from flare.preprocessor import FlareTransformer, preprocess_minecraft_commands
+
+
+def init_project(path: str):
+    p = Path(path)
+    p.mkdir(parents=True, exist_ok=True)
+    json_path = p / "flare.json"
+
+    if json_path.exists():
+        print(f"Project already initialized at {p.absolute()}")
+        return
+
+    print("Initializing Flare project...")
+    try:
+        namespace = input("Namespace [flare]: ").strip() or "flare"
+        pack_format = input("Pack format [15]: ").strip() or "15"
+        description = input("Description [A Flare datapack]: ").strip() or "A Flare datapack"
+    except (KeyboardInterrupt, EOFError):
+        print("\nInitialization cancelled.")
+        return
+
+    config = {"namespace": namespace, "pack_format": int(pack_format), "description": description, "build_dir": "dist"}
+
+    with open(json_path, "w") as f:
+        json.dump(config, f, indent=4)
+    print(f"Created {json_path.absolute()}")
+
+
+def build_datapack(file_path: str):
+    p = Path(file_path).parent
+    json_path = p / "flare.json"
+
+    if json_path.exists():
+        with open(json_path, "r") as f:
+            config = json.load(f)
+    else:
+        config = {"namespace": "flare", "pack_format": 15, "description": "A Flare datapack", "build_dir": "dist"}
+
+    namespace = config.get("namespace", "flare")
+    build_dir = Path(config.get("build_dir", "dist"))
+    if not build_dir.is_absolute():
+        build_dir = p / build_dir
+
+    context.reset_context()
+    context._current_namespace = namespace
+
+    print(f"Compiling {file_path}...")
+
+    old_modules = set(sys.modules.keys())
+
+    try:
+        abs_path = os.path.abspath(file_path)
+        sys.path.insert(0, os.path.dirname(abs_path))
+
+        with open(abs_path, "r") as f:
+            source = f.read()
+
+        source = preprocess_minecraft_commands(source)
+
+        tree = ast.parse(source, abs_path)
+        transformer = FlareTransformer()
+        tree = transformer.visit(tree)
+        ast.fix_missing_locations(tree)
+
+        global_env = {"__name__": "__main__", "__file__": abs_path}
+        exec("from flare import _flare_assign, _flare_if, _flare_while, _flare_for, runcommand", global_env)
+
+        exec(compile(tree, abs_path, "exec"), global_env)
+        sys.path.pop(0)
+    except Exception as e:
+        print(f"Build failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False, set(), None
+
+    new_modules = set(sys.modules.keys()) - old_modules
+    watch_files = {os.path.abspath(file_path)}
+    for mod_name in new_modules:
+        mod = sys.modules.get(mod_name)
+        if mod and getattr(mod, "__file__", None):
+            mod_file = os.path.abspath(mod.__file__)
+            if (mod_file.endswith(".fl") or mod_file.endswith(
+                    ".py")) and "site-packages" not in mod_file and "lib/python" not in mod_file:
+                watch_files.add(mod_file)
+
+    if build_dir.exists():
+        shutil.rmtree(build_dir)
+
+    build_dir.mkdir(parents=True, exist_ok=True)
+
+    with open(build_dir / "pack.mcmeta", "w") as f:
+        json.dump({"pack": {"pack_format": config.get("pack_format", 15),
+                            "description": config.get("description", "A Flare datapack")}}, f, indent=4)
+
+    tags = {"tick": [], "load": []}
+
+    load_key = f"{context._current_namespace}:load"
+    if "main" in context.files:
+        if load_key not in context.files:
+            context.files[load_key] = []
+        context.files[load_key].extend(context.files.pop("main"))
+
+    for filename, lines in context.files.items():
+        if not lines and filename != "main":
+            continue
+
+        if filename.endswith(":tick"):
+            tags["tick"].append(filename)
+        elif filename.endswith(":load"):
+            tags["load"].append(filename)
+
+        if ":" in filename:
+            ns, name = filename.split(":", 1)
+            file_p = build_dir / "data" / ns / "functions" / f"{name}.mcfunction"
+        else:
+            file_p = build_dir / "data" / context._current_namespace / "functions" / f"{filename}.mcfunction"
+
+        file_p.parent.mkdir(parents=True, exist_ok=True)
+        with open(file_p, "w") as f:
+            for line in lines:
+                f.write(f"{line}\n")
+
+    tag_dir = build_dir / "data" / "minecraft" / "tags" / "functions"
+    for tag_name, tag_funcs in tags.items():
+        if tag_funcs:
+            tag_dir.mkdir(parents=True, exist_ok=True)
+            tag_path = tag_dir / f"{tag_name}.json"
+            with open(tag_path, "w") as f:
+                json.dump({"values": tag_funcs}, f, indent=4)
+
+    print(f"Successfully built datapack to {build_dir.absolute()}")
+    return True, watch_files, build_dir
+
+
+class WatcherHandler(FileSystemEventHandler):
+    def __init__(self, cli_args, watch_files):
+        self.cli_args = cli_args
+        self.watch_files = watch_files
+        self.rebuild_pending = False
+
+    def on_modified(self, event):
+        if not event.is_directory and event.src_path in self.watch_files:
+            self.rebuild_pending = True
+
+
+def get_tags(build_dir: Path, tag_type: str, tag_name: str) -> list[str]:
+    tag_path = build_dir / "data" / "minecraft" / "tags" / tag_type / f"{tag_name}.json"
+    if tag_path.exists():
+        try:
+            with open(tag_path, "r") as f:
+                data = json.load(f)
+                return data.get("values", [])
+        except Exception:
+            pass
+    return []
+
+
+def run_emulator(build_dir: Path):
+    try:
+        import mcemu
+    except ImportError:
+        print("mcemu is not installed. Run `pip install mcemu` to use the --run feature.")
+        return None
+    print("\n--- Starting mcemu ---")
+    try:
+        import mcemu.commands
+    except ImportError:
+        pass
+
+    emu = mcemu.Emulator()
+    emu.load_datapack(str(build_dir.absolute()))
+
+    return emu
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Flare CLI Datapack Compiler")
+    parser.add_argument("target", nargs="?", default=".",
+                        help="File to build or directory to init. Use 'init' to initialize in current directory.")
+    parser.add_argument("--watch", action="store_true", help="Watch for file changes and rebuild")
+    parser.add_argument("--run", nargs="?", const="-1", default=None,
+                        help="Run the compiled datapack in mcemu. Optionally specify a timeout in seconds.")
+
+    args = parser.parse_args()
+
+    is_init = args.target == "init"
+    if is_init:
+        init_project(".")
+        if not args.watch and not args.run:
+            return
+
+    if os.path.isdir(args.target):
+        file_path = os.path.join(args.target, "main.fl")
+        if not os.path.exists(file_path) and os.path.exists(os.path.join(args.target, "main.py")):
+            file_path = os.path.join(args.target, "main.py")
+    else:
+        if args.target.endswith(".fl") or args.target.endswith(".py"):
+            file_path = args.target
+        else:
+            file_path = f"{args.target}.fl"
+            if not os.path.exists(file_path) and os.path.exists(f"{args.target}.py"):
+                file_path = f"{args.target}.py"
+
+    if not os.path.exists(file_path) and not is_init:
+        print(f"Error: Target file {file_path} not found.")
+        return
+
+    success, watch_files, build_dir = build_datapack(file_path)
+
+    emu_thread = None
+    running = True
+
+    def run_loop(emu, timeout):
+        try:
+            start_time = time.time()
+            while running:
+                if timeout is not None and timeout >= 0:
+                    if time.time() - start_time >= timeout:
+                        break
+                if emu:
+                    emu.tick()
+                time.sleep(0.05)
+        except KeyboardInterrupt:
+            pass
+
+    import threading
+    if success and args.run is not None:
+        try:
+            timeout = float(args.run) if args.run != "-1" else None
+        except ValueError:
+            timeout = None
+        emu = run_emulator(build_dir)
+        if emu:
+            emu_thread = threading.Thread(target=run_loop, args=(emu, timeout))
+            emu_thread.daemon = True
+            emu_thread.start()
+
+    if args.watch:
+        print(f"Watching for changes in {len(watch_files)} files...")
+        handler = WatcherHandler(args, watch_files)
+        observer = Observer()
+
+        watch_dirs = set(os.path.dirname(f) for f in watch_files)
+        for d in watch_dirs:
+            observer.schedule(handler, d, recursive=False)
+
+        observer.start()
+
+        try:
+            while True:
+                time.sleep(0.5)
+                if handler.rebuild_pending:
+                    print("\nChange detected. Rebuilding...")
+                    handler.rebuild_pending = False
+
+                    if emu_thread:
+                        running = False
+                        emu_thread.join()
+
+                    success, new_watch_files, build_dir = build_datapack(file_path)
+
+                    if success and new_watch_files != watch_files:
+                        observer.unschedule_all()
+                        watch_files = new_watch_files
+                        handler.watch_files = watch_files
+                        watch_dirs = set(os.path.dirname(f) for f in watch_files)
+                        for d in watch_dirs:
+                            observer.schedule(handler, d, recursive=False)
+
+                    if success and args.run is not None:
+                        running = True
+                        try:
+                            timeout = float(args.run) if args.run != "-1" else None
+                        except ValueError:
+                            timeout = None
+                        emu = run_emulator(build_dir)
+                        if emu:
+                            emu_thread = threading.Thread(target=run_loop, args=(emu, timeout))
+                            emu_thread.daemon = True
+                            emu_thread.start()
+
+        except KeyboardInterrupt:
+            observer.stop()
+            running = False
+            print("\nStopped watching.")
+        observer.join()
+    else:
+        if emu_thread:
+            try:
+                while emu_thread.is_alive():
+                    time.sleep(0.1)
+            except KeyboardInterrupt:
+                running = False
+                print("\nStopped emulator.")
+
+
+if __name__ == "__main__":
+    main()

flare/compiler.py

@@ -0,0 +1,102 @@
+from . import context as ctx
+from .context import runcommand, temp_obj
+from .types import NBTType
+from .variables import score, nbt, BinaryOp, UnaryOp, getscore
+
+
+def _compile_relational(node, invert=False):
+    op_map = {"eq": ("if", "="), "ne": ("unless", "="), "lt": ("if", "<"), "le": ("if", "<="), "gt": ("if", ">"),
+              "ge": ("if", ">=")}
+    if node.op not in op_map:
+        raise ValueError(f"Not a relational op: {node.op}")
+
+    keyword, mcop = op_map[node.op]
+    if invert:
+        keyword = "unless" if keyword == "if" else "if"
+
+    left, right = node.left, node.right
+
+    if not isinstance(left, score):
+        if isinstance(left, (int, float)):
+            left = getscore(left)
+        else:
+            t = score(addr=f"!c{ctx._temp_id} {temp_obj}")
+            ctx._temp_id += 1
+            if isinstance(left, (BinaryOp, UnaryOp)):
+                left._eval_into(t)
+            else:
+                t.__iset__(left)
+            left = t
+
+    if not isinstance(right, score):
+        if isinstance(right, (int, float)):
+            right = getscore(right, left.multiplier)
+        else:
+            t = score(addr=f"!c{ctx._temp_id} {temp_obj}", multiplier=left.multiplier)
+            ctx._temp_id += 1
+            if isinstance(right, (BinaryOp, UnaryOp)):
+                right._eval_into(t)
+            else:
+                t.__iset__(right)
+            right = t
+
+    if left.multiplier != right.multiplier:
+        t = score(addr=f"!c{ctx._temp_id} {temp_obj}", multiplier=left.multiplier)
+        ctx._temp_id += 1
+        t.__iset__(right)
+        right = t
+
+    return f"{keyword} score {left.addr} {mcop} {right.addr}"
+
+
+def _eval_to_bool_score(node):
+    dest = score(addr=f"!b{ctx._temp_id} {temp_obj}")
+    ctx._temp_id += 1
+    runcommand(f"scoreboard players set {dest.addr} 0")
+
+    if isinstance(node, BinaryOp) and node.op == "or":
+        left_conds = _flatten_and(node.left)
+        runcommand(f"execute {' '.join(left_conds)} run scoreboard players set {dest.addr} 1")
+        right_conds = _flatten_and(node.right)
+        runcommand(
+            f"execute if score {dest.addr} matches 0 {' '.join(right_conds)} run scoreboard players set {dest.addr} 1")
+        return dest
+
+    if isinstance(node, UnaryOp) and node.op == "not":
+        sub_dest = _eval_to_bool_score(node.operand)
+        runcommand(f"execute if score {sub_dest.addr} matches 0 run scoreboard players set {dest.addr} 1")
+        return dest
+
+    if isinstance(node, (BinaryOp, UnaryOp)):
+        t = score(addr=f"!b{ctx._temp_id} {temp_obj}")
+        ctx._temp_id += 1
+        node._eval_into(t)
+        runcommand(f"execute unless score {t.addr} matches 0 run scoreboard players set {dest.addr} 1")
+        return dest
+
+    if node:
+        runcommand(f"scoreboard players set {dest.addr} 1")
+    return dest
+
+
+def _flatten_and(node, invert=False):
+    if not isinstance(node, (BinaryOp, UnaryOp)):
+        if isinstance(node, nbt) and (node.is_sequence() or node.type == NBTType.String):
+            node = BinaryOp(node.length(), 0, "ne")
+        else:
+            node = BinaryOp(node, 0, "ne")
+    if isinstance(node, UnaryOp) and node.op == "neg":
+        node = BinaryOp(node, 0, "ne")
+    if isinstance(node, UnaryOp) and node.op == "not":
+        return _flatten_and(node.operand, not invert)
+    if isinstance(node, BinaryOp):
+        if node.op == "and" and not invert:
+            return _flatten_and(node.left, invert) + _flatten_and(node.right, invert)
+        if node.op == "or" and invert:
+            return _flatten_and(node.left, invert) + _flatten_and(node.right, invert)
+        if node.op in ("eq", "ne", "lt", "le", "gt", "ge"):
+            return [_compile_relational(node, invert)]
+
+    dest = _eval_to_bool_score(node)
+    keyword = "unless" if invert else "if"
+    return [f"{keyword} score {dest.addr} matches 1"]

flare/context.py

@@ -0,0 +1,191 @@
+import json
+
+files = {"main": []}
+current_file = "main"
+_current_namespace = "flare"
+functions = {}
+constants = {}
+constant_obj = "__flare__constant__"
+vars_obj = "__flare__vars__"
+temp_obj = "__flare__temp__"
+_temp_id = 0
+_func_id = 0
+_objective_offset = 0
+_constant_offset = 0
+
+
+def reset_context():
+    global files, current_file, _current_namespace, functions, constants, _temp_id, _func_id, _objective_offset, _constant_offset
+    files = {"main": []}
+    current_file = "main"
+    _current_namespace = "flare"
+    functions = {}
+    constants = {}
+    _temp_id = 0
+    _func_id = 0
+    _objective_offset = 0
+    _constant_offset = 0
+
+
+def ensure_objective(obj: str):
+    global _objective_offset, _constant_offset
+    if not obj:
+        return
+
+    load_file = f"{_current_namespace}:load"
+    if load_file not in files:
+        files[load_file] = []
+
+    cmd = f"scoreboard objectives add {obj} dummy"
+    if cmd not in files[load_file]:
+        files[load_file].insert(_objective_offset, cmd)
+        _objective_offset += 1
+        _constant_offset += 1
+
+
+def ensure_constant(name: str, obj: str, val: int):
+    global _constant_offset
+    ensure_objective(obj)
+
+    load_file = f"{_current_namespace}:load"
+    cmd = f"scoreboard players set {name} {obj} {val}"
+    if cmd not in files[load_file]:
+        files[load_file].insert(_constant_offset, cmd)
+        _constant_offset += 1
+
+
+class _ContextManager:
+    def __init__(self, new_file: str):
+        self.new_file = new_file
+        self.old_file = None
+
+    def __enter__(self):
+        global current_file
+        self.old_file = current_file
+        current_file = self.new_file
+        if self.new_file not in files:
+            files[self.new_file] = []
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        global current_file
+        current_file = self.old_file
+
+
+def push_context(name: str):
+    return _ContextManager(name)
+
+
+def namespace(name: str):
+    global _current_namespace
+    _current_namespace = name
+
+
+def __float_prec(x: float) -> int:
+    return len(str(x).split(".")[-1])
+
+
+def runcommand(command: str):
+    files[current_file].append(command)
+
+import builtins
+
+def dbg(*args):
+    processed_str = " ".join(str(arg) for arg in args)
+    builtins.print(processed_str)
+    _flare_print(processed_str)
+
+def _flare_print(*args):
+    from .variables import score, nbt  # to avoid circular import
+    components = []
+    for i, arg in enumerate(args):
+        if i > 0:
+            components.append({"text": " "})
+
+        if isinstance(arg, score):
+            if getattr(arg, 'multiplier', 1.0) != 1.0:
+                scale_str = f"{arg.multiplier:.15f}".rstrip("0")
+                if scale_str.endswith("."):
+                    scale_str += "0"
+                runcommand(
+                    f"execute store result storage flare:temp __flare_debug_{i} double {scale_str} run scoreboard players get {arg.addr}")
+                components.append({"nbt": f"__flare_debug_{i}", "storage": "flare:temp"})
+            else:
+                name, obj = arg.addr.split(" ", 1)
+                components.append({"score": {"name": name, "objective": obj}})
+        elif isinstance(arg, nbt):
+            nbt_comp = {"nbt": arg.path or "{}"}
+            if arg.path == "":
+                nbt_comp["nbt"] = "{}"
+
+            if arg.target_type == "storage":
+                nbt_comp["storage"] = arg.target
+            elif arg.target_type == "entity":
+                nbt_comp["entity"] = arg.target
+            elif arg.target_type == "block":
+                nbt_comp["block"] = arg.target
+
+            if arg.path == "":
+                nbt_comp["nbt"] = "{}"
+
+            components.append(nbt_comp)
+        else:
+            components.append({"text": str(arg)})
+
+    if len(components) == 1:
+        comp = components[0]
+        if "text" in comp and len(comp) == 1:
+            cmd_text = json.dumps(comp["text"])
+        else:
+            cmd_text = json.dumps(comp)
+    else:
+        cmd_text = json.dumps(components)
+
+    runcommand(f"tellraw @a {cmd_text}")
+
+
+def export(func=None, *, append=False):
+    if func is None:
+        def wrapper(f):
+            return export(f, append=append)
+
+        return wrapper
+
+    func_name = f"{_current_namespace}:{func.__name__}"
+    if func_name in files and not append:
+        raise ValueError(f"Function {func_name} already exists. Use @export(append=True) to append.")
+
+    with push_context(func_name):
+        func()
+
+    return func
+
+
+def _flare_assign(var_name, value, local_env, global_env):
+    if var_name in local_env:
+        target = local_env[var_name]
+    elif var_name in global_env:
+        target = global_env[var_name]
+    else:
+        target = None
+
+    if target is not None and hasattr(target, "__iset__"):
+        target.__iset__(value)
+        return target
+
+    if target is None and hasattr(value, "__icopy__"):
+        return value.__icopy__(varid=f"{_current_namespace}_{var_name}")
+
+    return value
+
+
+def tick(func=None):
+    if func is None:
+        def wrapper(f):
+            return tick(f)
+
+        return wrapper
+
+    func_name = f"{_current_namespace}:tick"
+    with push_context(func_name):
+        func()
+    return func