Update utils/block_relation_builder.py

utils/block_relation_builder.py

@@ -2508,8 +2508,8 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
 
     # Initialize dictionaries to store and reuse generated unique IDs
     # This prevents creating multiple unique IDs for the same variable/broadcast across different blocks
-    variable_id_map = defaultdict(lambda: generate_secure_token())
-    broadcast_id_map = defaultdict(lambda: generate_secure_token())
+    variable_id_map = defaultdict(lambda: generate_secure_token(20))
+    broadcast_id_map = defaultdict(lambda: generate_secure_token(20))
 
     # Define the mapping for input field names to their required integer types for shadows
     input_type_mapping = {
@@ -2534,6 +2534,31 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
         "VALUE_STRING": 10 # Used internally for VALUE when it should be type 10
     }
 
+    # Explicit mapping of opcodes -> expected menu inputs that MUST be simple menu/shadow links ([1, block_id])
+    explicit_menu_links = {
+        "motion_goto": [("TO", "motion_goto_menu")],
+        "motion_glideto": [("TO", "motion_glideto_menu")],
+        "motion_pointtowards": [("TOWARDS", "motion_pointtowards_menu")],
+        "sensing_keypressed": [("KEY_OPTION", "sensing_keyoptions")],
+        "sensing_of": [("OBJECT", "sensing_of_object_menu")],
+        "sensing_touchingobject": [("TOUCHINGOBJECTMENU", "sensing_touchingobjectmenu")],
+        "control_create_clone_of": [("CLONE_OPTION", "control_create_clone_of_menu")],
+        "sound_play": [("SOUND_MENU", "sound_sounds_menu")],
+        "sound_playuntildone": [("SOUND_MENU", "sound_sounds_menu")],
+        "looks_switchcostumeto": [("COSTUME", "looks_costume")],
+        "looks_switchbackdropto": [("BACKDROP", "looks_backdrops")],
+    }
+
+    # helper to check if this opcode+input_name is an explicit menu link
+    def is_explicit_menu_opcode_input(opcode, input_name):
+        if not opcode:
+            return False
+        pairs = explicit_menu_links.get(opcode, [])
+        for inp, _menu in pairs:
+            if inp == input_name:
+                return True
+        return False
+
     for block_id, gen_block_data in generated_output_json.items():
         processed_block = {}
         all_gen_block_data = all_generated_blocks.get(block_id, {})
@@ -2549,13 +2574,14 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
         if "mutation" in all_gen_block_data:
             processed_block["mutation"] = all_gen_block_data["mutation"]
 
+        opcode = processed_block["opcode"]  # convenience
+
         # Process inputs
         if "inputs" in all_gen_block_data:
             for input_name, input_data in all_gen_block_data["inputs"].items():
+                # --- BROADCAST INPUT special handling (type 11) ---
                 if input_name == "BROADCAST_INPUT":
-                    # Special handling for BROADCAST_INPUT (type 11)
                     if isinstance(input_data, dict) and input_data.get("kind") == "value":
-                        # This is the new logic to handle a direct value for broadcast
                         menu_option = input_data.get("value", "message1")
                         broadcast_id = broadcast_id_map[menu_option]
                         processed_block["inputs"][input_name] = [
@@ -2567,23 +2593,26 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                             ]
                         ]
                     elif isinstance(input_data, list) and len(input_data) == 2 and isinstance(input_data[1], list) and len(input_data[1]) == 3 and input_data[1][0] == 11:
-                        # Preserve existing well-formed type 11 structure
+                        # Preserve well-formed existing type 11 structure
                         processed_block["inputs"][input_name] = input_data
                     else:
-                        # Fallback for unexpected formats, try to use the original if possible
-                        processed_block["inputs"][input_name] = gen_block_data["inputs"].get(input_name, [1, [11, "message1", generate_secure_token()]])
-
-                elif isinstance(input_data, dict):
-                    if input_data.get("kind") == "value":
+                        # Fallback: try original generated_output_json value if present, else synthesize
+                        fallback = gen_block_data.get("inputs", {}).get(input_name,
+                                                                       [1, [11, "message1", generate_secure_token(20)]])
+                        processed_block["inputs"][input_name] = fallback
+                    continue
+
+                # --- Input described as a dict (value, block, menu) ---
+                if isinstance(input_data, dict):
+                    kind = input_data.get("kind")
+                    if kind == "value":
                         # Determine the correct shadow type based on the input_name and opcode
-                        shadow_type = input_type_mapping.get(input_name, 4) # Default to 4
-                        
-                        # Specific override for "NUM" in "looks_goforwardbackwardlayers"
-                        if input_name == "NUM" and processed_block["opcode"] == "looks_goforwardbackwardlayers":
+                        shadow_type = input_type_mapping.get(input_name, 4)  # default 4
+
+                        # Specific overrides
+                        if input_name == "NUM" and opcode == "looks_goforwardbackwardlayers":
                             shadow_type = 7
-                        
-                        # Specific override for "VALUE" in "data_setvariableto"
-                        if input_name == "VALUE" and processed_block["opcode"] == "data_setvariableto":
+                        if input_name == "VALUE" and opcode == "data_setvariableto":
                             shadow_type = 10
 
                         processed_block["inputs"][input_name] = [
@@ -2593,119 +2622,142 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                                 str(input_data.get("value", ""))
                             ]
                         ]
-                    elif input_data.get("kind") == "block":
-                        # Case 3: Nested block input
+                        continue
+
+                    if kind == "block":
+                        # nested block reference via dict
                         nested_block_id = input_data.get("block", "")
-                        
                         if nested_block_id in all_generated_blocks:
+                            # If this opcode+input_name is explicitly a menu -> force [1, nested_block_id]
+                            if is_explicit_menu_opcode_input(opcode, input_name):
+                                processed_block["inputs"][input_name] = [1, nested_block_id]
+                                continue
+
                             nested_block_opcode = all_generated_blocks[nested_block_id].get("op_code")
-                            
+
                             if input_name in ["SUBSTACK", "CONDITION", "SUBSTACK2"]:
-                                # These are control flow blocks, should always be type 2
                                 processed_block["inputs"][input_name] = [2, nested_block_id]
                             elif nested_block_opcode in ["data_variable", "data_listcontents"]:
-                                # It's a variable/list reporter, should be type 12 inside type 1
+                                # variable/list reporter inside a reporter -> [1, [12, name, id]]
                                 variable_name = all_generated_blocks[nested_block_id].get("fields", {}).get("VARIABLE", ["", ""])[0]
                                 variable_id = all_generated_blocks[nested_block_id].get("fields", {}).get("VARIABLE", ["", ""])[1]
                                 if not variable_id:
                                     variable_id = variable_id_map[variable_name]
                                 processed_block["inputs"][input_name] = [1, [12, variable_name, variable_id]]
                             elif input_name in ["TOUCHINGOBJECTMENU", "TO", "TOWARDS", "CLONE_OPTION", "SOUND_MENU", "KEY_OPTION", "OBJECT"]:
-                                # These are menu/dropdown inputs that refer to another block/menu,
-                                # and should be type 1, referring to a shadow block.
+                                # menu/dropdown inputs that refer to another block/menu -> type 1, refer to block id
                                 processed_block["inputs"][input_name] = [1, nested_block_id]
                             else:
-                                # For other reporter blocks (like motion_xposition, operators),
-                                # they should be type 3 when nested.
-                                shadow_type_for_nested = input_type_mapping.get(input_name, 10) # Default to 10 for nested shadows
-                                processed_block["inputs"][input_name] = [3, nested_block_id, [shadow_type_for_nested, ""]] # Empty shadow value
+                                # other reporter blocks (like motion_xposition, operators) -> nested type 3
+                                shadow_type_for_nested = input_type_mapping.get(input_name, 10)
+                                processed_block["inputs"][input_name] = [3, nested_block_id, [shadow_type_for_nested, ""]]
                         else:
-                            # If the referenced block doesn't exist, treat as a broken reference for now
-                            # or try to use original if available.
-                            processed_block["inputs"][input_name] = gen_block_data["inputs"].get(input_name, [3, nested_block_id, [10, ""]]) # Fallback
-
-                    elif input_data.get("kind") == "menu":
-                        # This handles menu inputs from all_gen_block_data that are not BROADCAST_INPUT
-                        menu_option = input_data.get("option", "")
-                        # These should typically be type 1 referring to a shadow block, or a direct value if no shadow block
-                        # For simplicity, we'll try to get the block ID if it's a menu block.
+                            # referenced block missing: fallback to original input format if available, else a safe fallback
+                            processed_block["inputs"][input_name] = gen_block_data.get("inputs", {}).get(input_name, [3, nested_block_id, [10, ""]])
+                        continue
+
+                    if kind == "menu":
+                        # menu kind: either references a block or a direct value
                         if "block" in input_data:
-                            processed_block["inputs"][input_name] = [1, input_data["block"]]
+                            # If explicit menu, ensure we store as [1, block_id]
+                            if is_explicit_menu_opcode_input(opcode, input_name):
+                                processed_block["inputs"][input_name] = [1, input_data["block"]]
+                            else:
+                                processed_block["inputs"][input_name] = [1, input_data["block"]]
                         else:
-                            # If it's a menu without a block reference, it might be a direct value in a shadow.
-                            # This case is less common for menu 'kind'.
-                            processed_block["inputs"][input_name] = [1, [10, menu_option]] # Default to type 10 for string menu options
-
-
-                elif isinstance(input_data, list):
-                    # This branch handles existing list structures from all_gen_block_data (or generated_output_json if no all_gen_block_data)
-                    # It needs to decide if it's a direct value, a block reference, or a special type (11, 12)
+                            # direct value in menu -> type 1 with a string shadow (type 10)
+                            menu_option = input_data.get("option", "")
+                            processed_block["inputs"][input_name] = [1, [10, menu_option]]
+                        continue
 
+                # --- Input is a list already (various formats) ---
+                if isinstance(input_data, list):
+                    # Common shapes:
+                    # [1, <value shadow>], [1, <block_id>], [3, <block_id>, [shadow_type, value]], etc.
                     if len(input_data) == 2:
                         first_val = input_data[0]
                         second_val = input_data[1]
 
+                        # If the second element is a block id that exists
                         if isinstance(second_val, str) and second_val in all_generated_blocks:
-                            # The second element is a block ID
+                            # If explicit menu mapping -> force [1, block_id]
+                            if is_explicit_menu_opcode_input(opcode, input_name):
+                                processed_block["inputs"][input_name] = [1, second_val]
+                                continue
+
                             nested_block_opcode = all_generated_blocks[second_val].get("op_code")
 
                             if input_name in ["SUBSTACK", "CONDITION", "SUBSTACK2"]:
-                                # These are control flow blocks, should always be type 2
                                 processed_block["inputs"][input_name] = [2, second_val]
                             elif nested_block_opcode in ["data_variable", "data_listcontents"]:
-                                # It's a variable/list reporter, should be type 12 inside type 1
                                 variable_name = all_generated_blocks[second_val].get("fields", {}).get("VARIABLE", ["", ""])[0]
                                 variable_id = all_generated_blocks[second_val].get("fields", {}).get("VARIABLE", ["", ""])[1]
                                 if not variable_id:
                                     variable_id = variable_id_map[variable_name]
                                 processed_block["inputs"][input_name] = [1, [12, variable_name, variable_id]]
                             elif input_name in ["TOUCHINGOBJECTMENU", "TO", "TOWARDS", "CLONE_OPTION", "SOUND_MENU", "KEY_OPTION", "OBJECT"]:
-                                # These are menu/dropdown inputs that refer to another block/menu,
-                                # and should be type 1, referring to a shadow block.
                                 processed_block["inputs"][input_name] = [1, second_val]
                             else:
-                                # For other reporter blocks (like motion_xposition, operators),
-                                # they should be type 3 when nested. Correct the first_val if it's not 3.
                                 shadow_type_for_nested = input_type_mapping.get(input_name, 10)
+                                # Ensure nested reporters use type 3
                                 processed_block["inputs"][input_name] = [3, second_val, [shadow_type_for_nested, ""]]
+                            continue
 
-                        elif isinstance(second_val, str):
-                            # It's a value literal (e.g., "-240") that needs wrapping with a shadow type
-                            shadow_type = input_type_mapping.get(input_name, 4) # Default to 4
-                            if input_name == "NUM" and processed_block["opcode"] == "looks_goforwardbackwardlayers":
+                        # If the second element is a string literal value -> wrap with appropriate shadow type
+                        if isinstance(second_val, str):
+                            shadow_type = input_type_mapping.get(input_name, 4)  # default 4
+                            if input_name == "NUM" and opcode == "looks_goforwardbackwardlayers":
                                 shadow_type = 7
-                            if input_name == "VALUE" and processed_block["opcode"] == "data_setvariableto":
+                            if input_name == "VALUE" and opcode == "data_setvariableto":
                                 shadow_type = 10
                             processed_block["inputs"][input_name] = [1, [shadow_type, str(second_val)]]
-                        else:
-                            # Fallback for other 2-element lists (e.g., [1, [11, ...]]), copy as is
-                            processed_block["inputs"][input_name] = input_data
+                            continue
+
+                        # fallback: preserve the input as-is
+                        processed_block["inputs"][input_name] = input_data
+                        continue
 
                     elif len(input_data) == 3 and isinstance(input_data[1], str) and isinstance(input_data[2], list):
-                        # Case: [3, "block_id", [shadow_type, shadow_value]] - an already well-formed nested block
-                        # or [1, "block_id", [shadow_type, shadow_value]] - an existing shadow for a direct value
-                        # Preserve these if they conform to the rules, otherwise correct shadow type
-                        if input_data[0] == 3 and input_data[1] in all_generated_blocks:
-                            # This is a valid type 3 nested block, keep it as is
-                            processed_block["inputs"][input_name] = input_data
-                        elif input_data[0] == 1 and isinstance(input_data[1], list) and input_data[1][0] in [11, 12]:
-                            # This is a type 11 or 12 structure, preserve it
-                            processed_block["inputs"][input_name] = input_data
-                        elif input_data[0] == 1 and isinstance(input_data[1], list) and len(input_data[1]) == 2:
-                            # This is a type 1 with a shadow, re-evaluate shadow type
-                            shadow_type = input_type_mapping.get(input_name, 4)
-                            if input_name == "NUM" and processed_block["opcode"] == "looks_goforwardbackwardlayers":
-                                shadow_type = 7
-                            if input_name == "VALUE" and processed_block["opcode"] == "data_setvariableto":
-                                shadow_type = 10
-                            processed_block["inputs"][input_name] = [input_data[0], [shadow_type, str(input_data[1][1])]]
-                        else:
-                            # Fallback for other 3-element lists, copy as is
-                            processed_block["inputs"][input_name] = input_data
+                        # case: [3, "block_id", [shadow_type, shadow_value]] or
+                        #       [1, "block_id", [shadow_type, shadow_value]] (rare)
+                        block_ref = input_data[1]
+                        if block_ref in all_generated_blocks:
+                            # If explicit menu mapping -> convert to [1, block_id]
+                            if is_explicit_menu_opcode_input(opcode, input_name):
+                                processed_block["inputs"][input_name] = [1, block_ref]
+                                continue
+
+                            # keep already well-formed nested reporter [3, ...]
+                            if input_data[0] == 3:
+                                processed_block["inputs"][input_name] = input_data
+                                continue
+
+                            # If it's a type 1 with a type shadow like [1, [11,...]] or [1, [12,...]] -> preserve
+                            if input_data[0] == 1 and isinstance(input_data[1], list) and input_data[1][0] in [11, 12]:
+                                processed_block["inputs"][input_name] = input_data
+                                continue
+
+                            # if it's [1, [shadow_type, value]] then re-evaluate shadow type
+                            if input_data[0] == 1 and isinstance(input_data[1], list) and len(input_data[1]) == 2:
+                                shadow_type = input_type_mapping.get(input_name, 4)
+                                if input_name == "NUM" and opcode == "looks_goforwardbackwardlayers":
+                                    shadow_type = 7
+                                if input_name == "VALUE" and opcode == "data_setvariableto":
+                                    shadow_type = 10
+                                processed_block["inputs"][input_name] = [input_data[0], [shadow_type, str(input_data[1][1])]]
+                                continue
+
+                        # fallback: preserve the list as-is
+                        processed_block["inputs"][input_name] = input_data
+                        continue
+
                     else:
-                        # Fallback for any other unexpected list formats, copy as is
+                        # other unexpected list shapes -> preserve for now
                         processed_block["inputs"][input_name] = input_data
+                        continue
 
+                # If input_data didn't match any of the above -> try to fallback to original generated value if available
+                processed_block["inputs"][input_name] = gen_block_data.get("inputs", {}).get(input_name, input_data)
 
         # Process fields
         if "fields" in all_gen_block_data:
@@ -2751,7 +2803,7 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                     
                     # Check if TOUCHINGOBJECTMENU input exists and is a block reference
                     referenced_block_id = None
-                    if "TOUCHINGOBJECTMENU" in all_gen_block_data["inputs"]:
+                    if "TOUCHINGOBJECTMENU" in all_gen_block_data.get("inputs", {}):
                         input_val = all_gen_block_data["inputs"]["TOUCHINGOBJECTMENU"]
                         if isinstance(input_val, list) and len(input_val) > 1 and isinstance(input_val[1], str):
                             referenced_block_id = input_val[1]
@@ -2769,7 +2821,7 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                 else:
                     processed_block["fields"][field_name] = field_value
         
-        # Remove unwanted keys from the processed block
+        # Remove unwanted keys from the processed block (if somehow present)
         keys_to_remove = ["functionality", "block_shape", "id", "block_name", "block_type"]
         for key in keys_to_remove:
             if key in processed_block: