translator parser and mapper created

app.py

@@ -1,8 +1,7 @@
 import os
 import gradio as gr
-#from translator.agent import TranslationAgent
+from translator.agent import TranslationAgent
 
-'''
 #Initialize agent (will load mapping table)
 agent = TranslationAgent()
 
@@ -14,11 +13,24 @@ def do_translate(csharp_code, target_format, model_choice):
 title = "Unity -> Unreal Code Translator"
 description = "Paste a Unity C# script and get suggested Unreal C++ (.h/.cpp) and an Unreal Python Blueprint-generator script."
 
-'''
-
-
-def greet(name):
-    return "Hello " + name + "!!"
-
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+gradioInterface = gr.Interface(
+    #function
+    fn=do_translate,
+    #input field
+    inputs=[
+        gr.Textbox(lines=25, lable="Unity C# Code"),
+        gr.Radio(["cpp", "Blueprint","Both"], value="Both", lable="Target Code"),
+        gr.Radio(["hf_inference", "openai"], value="openai", lable="Model Backend")
+    ],
+    #Output field
+    outputs=[
+        gr.Textbox(lines=20, lable="Unreal C++ (.h/.cpp"),
+        gr.Textbox(lines=20, lable="Unreal Blueprint generator (Python for Editor)")
+    ],
+    title=title,
+    description=description,
+    allow_flagging="never",
+)
+
+if __name__ == "__main__":
+    gradioInterface.launch(share=True)

translator/mapper.py

@@ -0,0 +1,21 @@
+import json
+from pathlib import Path
+
+DEFAULT_MAPPING = {
+    "MonoBehaviour": {"target_parent": "AActor"},
+    "Start": {"target": "BeginPlay"},
+    "Update": {"target": "Tick", "delta_time_arg": True},
+    "transform.position": {"target": "GetActorLocation()"},
+    "transform.Rotate": {"target": "AddActorLocalRotation"},
+    "Instantiate": {"target": "GetWorld()->SpawnActor"},
+    "Time.deltaTime": {"target": "DeltaTime"},
+    "Input.GetAxis": {"target": "GetInputAxisValue"},
+    "OnCollisionEnter": {"target": "NotifyHit / OnActorHit"}
+}
+
+def load_mapping(path="mapping_table.json"):
+    p = Path(path)
+    if p.exists():
+        return json.loads(p.read_text())
+    else:
+        return DEFAULT_MAPPING

translator/parse.py

@@ -0,0 +1,74 @@
+from tree_sitter import Parser
+# tree-sitter-c-sharp pip package provides the C# language.
+from tree_sitter_languages import get_language  # helper wrapper (optional)
+import re
+
+def parse_csharp(code: str) -> dict:
+    """
+    Returns a simple AST-like dict:
+      {
+        "classes": [
+          {"name": "Foo", "fields": [...], "methods": [{"name": "Update", "body": "..."}]}
+        ]
+      }
+    """
+    result = {"classes":[]}
+    try:
+        # try tree-sitter approach
+        from tree_sitter import Parser
+        from tree_sitter_c_sharp import CSHARP_LANGUAGE
+        parser = Parser()
+        parser.set_language(CSHARP_LANGUAGE)
+        tree = parser.parse(bytes(code, "utf8"))
+        root = tree.root_node
+
+        #find class declarations and method declarations
+        for node in root.walk():
+            if node.type == "class_declaration":
+                class_name = None
+                for child in node.children:
+                    if child.type == "identifier":
+                        class_name = code[child.start_byte:child.end_byte].decode("utf8") if isinstance(child.start_byte, bytes) else code[child.start_byte:child.end_byte]
+                methods = []
+                for child in node.children:
+                    if child.type == "method_declaration":
+                        #find identifier and body text
+                        name = None
+                        body = ""
+                        for grand in child.children:
+                            if grand.type == "identifier":
+                                name = code[grand.start_byte:grand.end_byte]
+                            if grand.type == "block":
+                                body = code[grand.start_byte:grand.end_byte]
+                        methods.append({"name": name, "body":body})
+                result["classes"].append({"name": class_name, "methods": methods})
+        return result
+    
+
+    except Exception:
+        # Regex fallback (works for simple files)
+        classes = []
+        class_matches = re.finditer(r'class\s+(\w+)\s*:\s*MonoBehaviour\s*{', code)
+        for m in class_matches:
+            cls = m.group(1)
+            # find Update / Start blocks
+            methods = []
+            for mm in re.finditer(r'(void|public)\s+(Start|Update|FixedUpdate)\s*\([^\)]*\)\s*{', code):
+                method_name = mm.group(2)
+                # crudely extract method body until balancing braces (simple approach)
+                start = mm.end()
+                depth = 1
+                i = start
+                while i < len(code) and depth > 0:
+                    if code[i] == '{':
+                        depth += 1
+                    elif code[i] == '}':
+                        depth -= 1
+                    i += 1
+                body = code[start:i-1].strip()
+                methods.append({"name": method_name, "body": body})
+            classes.append({"name": cls, "methods": methods})
+        result["classes"] = classes
+        return result
+
+