tools: add FP_ANGLE support to flags_fp_conv, FP rounding improvement

There's still a minor issue with certain floats, where python outputs as
something like 34.0000000001 instead of just 34
Not sure of a good way to fix it yet, easy enough to just remove
manually

Author: emoose

tools/bin2c.py

@@ -32,16 +32,25 @@
 def round_fp(val, scale):
     float_val = val / scale;
 
-    # Try to find the shortest rounded representation that still matches
-    for digits in range(1, 12):  # up to 12 decimal places
+    # Find shortest decimal that round-trips correctly
+    found = False
+
+    for digits in range(1, 12):
         rounded = round(float_val, digits)
-        if float_val < 0:
-            reconverted = int(math.ceil(rounded * scale))
-        else:
-            reconverted = int(math.floor(rounded * scale))
-        if reconverted == val:
-            # Good enough – this rounded value still maps to the same fixed integer
-            float_val = rounded
+        increment = 10 ** (-digits)
+
+        # Test the rounded value and its nearest neighbor
+        candidates = [rounded, rounded + (increment if float_val >= 0 else -increment)]
+
+        for candidate in candidates:
+            scaled = candidate * scale
+            reconverted = int(math.floor(scaled)) if candidate >= 0 else int(math.ceil(scaled))
+            if reconverted == val:
+                float_val = candidate
+                found = True
+                break
+
+        if found:
             break
 
     return f"{float_val}f"
@@ -53,7 +62,10 @@ def process_fp(val, qval = 12):
     return f"Q{qval}({float_val})"
 
 def process_fp_angle_packed(val):
-    return round_fp(val, 0.711111);    
+    return f"FP_ANGLE_PACKED({round_fp(val, 0.711111)})"
+
+def process_fp_angle(val):
+    return f"FP_ANGLE({round_fp(val, 11.377778)})"
 
 class StructParser:
     def __init__(self, alignment=4, verbose=False, union_choices=None):
@@ -589,20 +601,9 @@ def parse_sym_addrs(self, content):
 
     def parse_definitions(self, c_code):
         """Parse C code and build construct definitions."""
-        fake_includes = """
-        typedef unsigned char u8;
-        typedef unsigned short u16;
-        typedef unsigned int u32;
-        typedef unsigned long long u64;
-        typedef signed char s8;
-        typedef signed short s16;
-        typedef signed int s32;
-        typedef signed long long s64;
-        """
 
         cleaned_code = self.preprocess_code(c_code)
-        full_code = fake_includes + cleaned_code
-        ast = self.parser.parse(full_code)
+        ast = self.parser.parse(cleaned_code)
 
         for node in ast.ext:
             # Handle Typedefs
@@ -1070,7 +1071,7 @@ def format_value(self, value, field_type, field_key):
                 elif value == -1 and (field_key == "s_AnimInfo.startKeyframeIdx_C" or field_key == "s_AnimInfo.endKeyframeIdx_E"):
                     return "NO_VALUE"
                 elif field_key == "VC_ROAD_DATA.fix_ang_x_16" or field_key == "VC_ROAD_DATA.fix_ang_y_17":
-                    return f"FP_ANGLE_PACKED({process_fp_angle_packed(value & 0xFF)})"
+                    return process_fp_angle_packed(value & 0xFF)
                 elif field_key == "VC_ROAD_DATA.mv_y_type_11":
                     enum_val = self.lookup_enum_name("VC_CAM_MV_TYPE", value)
                     if enum_val is not None:

tools/flags_fp_conv.py

@@ -10,6 +10,7 @@
 import readline
 import math
 import os
+import sys
 import pyperclip
 
 # ---------- EventFlags converter ----------
@@ -161,6 +162,44 @@ def to_signed(val, bits=32):
         val -= 1 << bits
     return val
 
+def round_fp(val, scale):
+    float_val = val / scale;
+
+    # Find shortest decimal that round-trips correctly
+    found = False
+
+    for digits in range(1, 12):
+        rounded = round(float_val, digits)
+        increment = 10 ** (-digits)
+
+        # Test the rounded value and its nearest neighbor
+        candidates = [rounded, rounded + (increment if float_val >= 0 else -increment)]
+
+        for candidate in candidates:
+            scaled = candidate * scale
+            reconverted = int(math.floor(scaled)) if candidate >= 0 else int(math.ceil(scaled))
+            if reconverted == val:
+                float_val = candidate
+                found = True
+                break
+
+        if found:
+            break
+
+    return f"{float_val}f"
+
+def process_fp(val, qval = 12):
+    scale = (1 << qval)
+    float_val = round_fp(val, scale)
+
+    return f"Q{qval}({float_val})"
+
+def process_fp_angle_packed(val):
+    return f"FP_ANGLE_PACKED({round_fp(val, 0.711111)})"
+
+def process_fp_angle(val):
+    return f"FP_ANGLE({round_fp(val, 11.377778)})"
+
 def process_fp_text(text):
     qval = 12  # default Q-format is Q12
 
@@ -170,7 +209,14 @@ def process_fp_text(text):
         qval = int(match.group(1))
         text = re.sub(r'\bQ\d+\b', '', text, count=1)
 
-    scale = (1 << qval)
+    is_fp_angle_packed = False
+    is_fp_angle = False
+    if "FP_ANGLE_PACKED" in text:
+        is_fp_angle_packed = True
+        text = text.replace("FP_ANGLE_PACKED", "")
+    elif "FP_ANGLE" in text:
+        is_fp_angle = True
+        text = text.replace("FP_ANGLE", "")
 
     def convert_value(match):
         prefix = match.group(1) or ""   # may be None if start-of-string
@@ -187,28 +233,31 @@ def convert_value(match):
         else:
             val = int(value_str, 10)
 
-        float_val = val / scale;
-
-        # Try to find the shortest rounded representation that still matches
-        for digits in range(1, 12):  # up to 12 decimal places
-            rounded = round(float_val, digits)
-            if float_val < 0:
-                reconverted = int(math.ceil(rounded * scale))
-            else:
-                reconverted = int(math.floor(rounded * scale))
-            if reconverted == val:
-                # Good enough — this rounded value still maps to the same fixed integer
-                float_val = rounded
-                break
-
-        return f"{prefix}Q{qval}({float_val}f)"
+        if is_fp_angle:
+            return f"{prefix}{process_fp_angle(val)}"
+        if is_fp_angle_packed:
+            return f"{prefix}{process_fp_angle_packed(val)}"
+        return f"{prefix}{process_fp(val, qval)}"
 
     # prefix can be: start-of-string, space, or a punctuation
     pattern = re.compile(r'(^|[\s,(=:{\[])([-+]?0x[0-9A-Fa-f]+|[-+]?\d+)')
     return pattern.sub(convert_value, text)
 
 # ---------- Unified REPL ----------
 if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        # Join all arguments into a single input string
+        line = " ".join(sys.argv[1:]).strip()
+
+        result = convert_flag_expression(line)
+        if result is None:
+            result = process_fp_text(line)
+
+        if result is not None:
+            print(result)
+            pyperclip.copy(result)
+        sys.exit(0)
+
     print("Enter expressions like 'g_SavegamePtr->eventFlags_168[2] & 8' or 'g_SavegamePtr->eventFlags_168[2] |= (1 << 3))'.")
     print("Or enter a line containing decimal/hexadecimal Q12 numbers (0x7CCC, -0x1444, 4096, 0xFFFE0DDD) to convert to float")
     print("(change to other Q** formats by including Q format in the text, 'chara.field_48 = Q8(-0x1999)'")