Update utils/block_relation_builder.py

utils/block_relation_builder.py

@@ -4,7 +4,7 @@ import re
 from collections import defaultdict
 import secrets
 import string
-from typing import Dict, Any, TypedDict
+from typing import Dict, Any, TypedDict,Tuple
 
 
 #################################################################################################################################################################
@@ -1871,7 +1871,8 @@ def classify(line):
     if l.startswith("if <"): return "control_if", "c_block"
     if l.startswith("repeat until <"): return "control_repeat_until", "c_block"
     # Updated regex for stop block to handle different options
-    if re.match(r"stop \[(all|this script|other scripts in sprite)\s*v\]", l): return "control_stop", "cap"
+    #if re.match(r"stop \[(all|this script|other scripts in sprite)\s*v\]", l): return "control_stop", "cap"
+    if re.match(r"stop\s*(?:[\[(]?\s*(all|this script|other scripts in sprite)\s*[\])]?$)", l, re.IGNORECASE): return "control_stop", "cap"
     if l.startswith("create clone of"): return "control_create_clone_of", "stack"
     if l == "delete this clone": return "control_delete_this_clone", "cap"
 
@@ -2572,8 +2573,9 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
             for input_name, input_data in all_gen_block_data["inputs"].items():
                 if input_name == "BROADCAST_INPUT":
                     # Special handling for BROADCAST_INPUT (type 11)
-                    if isinstance(input_data, dict) and input_data.get("kind") == "menu":
-                        menu_option = input_data.get("option", "")
+                    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] = [
                             1,
@@ -2794,12 +2796,66 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
         
         processed_blocks[block_id] = processed_block
     return processed_blocks
-    
+   
 #################################################################################################################################################################
 #--------------------------------------------------[Unique secret key for skelton json to make sure it donot overwrite each other]-------------------------------
 #################################################################################################################################################################
 
-def rename_blocks(block_json: dict, opcode_count: dict) -> tuple[dict, dict]:
+def rename_blocks(block_json: Dict[str, Any], opcode_count: Dict[str, list]) -> Tuple[Dict[str, Any], Dict[str, list]]:
+    """
+    Replace each block key in block_json and each identifier in opcode_count
+    with a newly generated secure token, ensuring all references are updated.
+
+    Args:
+        block_json: Mapping of block_key -> block_data.
+        opcode_count: Mapping of opcode -> list of block_keys.
+
+    Returns:
+        A tuple of (new_block_json, new_opcode_count) with updated keys.
+    """
+    token_map = {}
+    
+    # Step 1: Generate a secure token mapping for every existing block key
+    for old_key in block_json.keys():
+        while True:
+            new_key = generate_secure_token()
+            if new_key not in token_map.values():
+                break
+        token_map[old_key] = new_key
+
+    new_block_json = {}
+    
+    # Step 2: Rebuild block_json with new keys and update all references
+    for old_key, block in block_json.items():
+        new_key = token_map[old_key]
+        new_block_json[new_key] = block.copy()
+        
+        # Update parent and next references
+        if 'parent' in block and block['parent'] in token_map:
+            new_block_json[new_key]['parent'] = token_map[block['parent']]
+        if 'next' in block and block['next'] in token_map:
+            new_block_json[new_key]['next'] = token_map[block['next']]
+        
+        # Update inputs that reference blocks
+        if 'inputs' in block:
+            for inp_key, inp_val in block['inputs'].items():
+                # This handles references like [2, 'block_key']
+                if isinstance(inp_val, list) and len(inp_val) == 2:
+                    idx, ref = inp_val
+                    if isinstance(ref, str) and ref in token_map:
+                        new_block_json[new_key]['inputs'][inp_key] = [idx, token_map[ref]]
+                # This new block handles references like [3, 'block_key', [10, '']]
+                elif isinstance(inp_val, list) and len(inp_val) == 3:
+                    idx, ref, rest = inp_val
+                    if isinstance(ref, str) and ref in token_map:
+                        new_block_json[new_key]['inputs'][inp_key] = [idx, token_map[ref], rest]
+                
+    # Step 3: Update opcode count map
+    new_opcode_count = {}
+    for opcode, key_list in opcode_count.items():
+        new_opcode_count[opcode] = [token_map.get(k, k) for k in key_list]
+        
+    return new_block_json, new_opcode_count
     """
     Replace each block key in block_json and each identifier in opcode_count
     with a newly generated secure token.
@@ -2895,60 +2951,39 @@ def variable_intialization(project_data):
                     initial_value = ""
                     if value_input and isinstance(value_input, list) and len(value_input) > 1 and \
                        isinstance(value_input[1], list) and len(value_input[1]) > 1:
-                        # Extract value from various formats, e.g., [1, [10, "0"]] or [3, [12, "score", "id"], [10, "0"]]
-                        if value_input[1][0] == 10: # Direct value like [10, "0"]
+                        if value_input[1][0] == 10:
                             initial_value = str(value_input[1][1])
-                        elif value_input[1][0] == 12 and len(value_input) > 2 and isinstance(value_input[2], list) and value_input[2][0] == 10: # Variable reference with initial value block
-                             initial_value = str(value_input[2][1])
-                        elif isinstance(value_input[1], (str, int, float)): # For direct number/string inputs
+                        elif value_input[1][0] == 12 and len(value_input) > 2 and isinstance(value_input[2], list) and value_input[2][0] == 10:
+                            initial_value = str(value_input[2][1])
+                        elif isinstance(value_input[1], (str, int, float)):
                             initial_value = str(value_input[1])
-
-
-                    # Add/update the variable in the Stage's 'variables' with its initial value
                     stage_target["variables"][var_id] = [var_name, initial_value]
 
-
             for key, value in obj.items():
-                # Process variable definitions in 'fields' (for blocks that define variables like 'show variable')
-                if key == "VARIABLE" and isinstance(value, list) and len(value) == 2:
-                    var_name = value[0]
-                    var_id = value[1]
-                    # Only add if not already defined with an initial value from set_variableto
-                    if var_id not in stage_target["variables"]:
-                        stage_target["variables"][var_id] = [var_name, ""] # Default to empty string if no initial value found yet
-                    elif stage_target["variables"][var_id][0] != var_name: # Update name if ID exists but name is different
-                        stage_target["variables"][var_id][0] = var_name
-
-
                 # Process broadcast definitions in 'inputs' (BROADCAST_INPUT)
-                elif key == "BROADCAST_INPUT" and isinstance(value, list) and len(value) == 2 and \
-                     isinstance(value[1], list) and len(value[1]) == 3 and value[1][0] == 11:
+                if key == "BROADCAST_INPUT" and isinstance(value, list) and len(value) == 2 and \
+                   isinstance(value[1], list) and len(value[1]) == 3 and value[1][0] == 11:
                     broadcast_name = value[1][1]
                     broadcast_id = value[1][2]
-                    # Add/update the broadcast in the Stage's 'broadcasts'
                     stage_target["broadcasts"][broadcast_id] = broadcast_name
 
                 # Process broadcast definitions in 'fields' (BROADCAST_OPTION)
                 elif key == "BROADCAST_OPTION" and isinstance(value, list) and len(value) == 2:
                     broadcast_name = value[0]
                     broadcast_id = value[1]
-                    # Add/update the broadcast in the Stage's 'broadcasts'
                     stage_target["broadcasts"][broadcast_id] = broadcast_name
-
+                
                 # Recursively call for nested dictionaries or lists
                 process_dict(value)
+
         elif isinstance(obj, list):
             for i, item in enumerate(obj):
                 # Process variable references in 'inputs' (like [12, "score", "id"])
                 if isinstance(item, list) and len(item) == 3 and item[0] == 12:
                     var_name = item[1]
                     var_id = item[2]
-                    # Only add if not already defined with an initial value from set_variableto
                     if var_id not in stage_target["variables"]:
-                        stage_target["variables"][var_id] = [var_name, ""] # Default to empty string if no initial value found yet
-                    elif stage_target["variables"][var_id][0] != var_name: # Update name if ID exists but name is different
-                        stage_target["variables"][var_id][0] = var_name
-
+                        stage_target["variables"][var_id] = [var_name, ""]
                 process_dict(item)
 
     # Iterate through all targets to process their blocks
@@ -3030,14 +3065,15 @@ def deduplicate_variables(project_data):
 def variable_adder_main(project_data):
     try:
         declare_variable_json=  variable_intialization(project_data)
+        print("declare_variable_json------->",declare_variable_json)
     except Exception as e:
         print(f"Error error in the variable initialization opcodes: {e}")
     try:
         processed_json= deduplicate_variables(declare_variable_json)
-        return 
+        print("processed_json------->",processed_json)
+        return processed_json
     except Exception as e:
         print(f"Error error in the variable initialization opcodes: {e}")
-
 #################################################################################################################################################################
 #--------------------------------------------------[Helper main function]----------------------------------------------------------------------------------------
 #################################################################################################################################################################
@@ -3066,18 +3102,24 @@ def block_builder(opcode_count,pseudo_code):
 #################################################################################################################################################################
 
 initial_opcode_counts = [
-          {
-            "opcode": "event_whenbroadcastreceived",
-            "count": 1
-          },
-          {
-            "opcode": "looks_hide",
-            "count": 1
-          }
+          {"opcode": "event_whenbroadcastreceived","count": 1},
+          {"opcode": "control_forever","count": 1},
+          {"opcode": "control_if","count": 1},
+          {"opcode": "sensing_istouching","count": 1},
+          {"opcode": "looks_hide","count": 1},
+          {"opcode": "looks_switchbackdropto","count": 1},
+          {"opcode": "event_broadcast","count": 1},
+          {"opcode": "control_stop","count": 1}
         ]
 pseudo_code="""
-when I receive [Game Over v]
-    hide
+when I receive [Game Start v]
+    forever
+        if <touching [obstacle v]?> then
+            hide
+            switch backdrop to [loose v]
+            broadcast [Game Over v]
+            stop all
+        end
 end
 """
 # print(pseudo_code)
@@ -3085,8 +3127,10 @@ end
 # all_generated_blocks = generate_plan(generated_output_json, initial_opcode_occurrences, pseudo_code)
 # processed_blocks= process_scratch_blocks(all_generated_blocks, generated_output_json)
 # renamed_blocks, renamed_counts = rename_blocks(processed_blocks, initial_opcode_occurrences)
-# print(all_generated_blocks)
+# #print(all_generated_blocks)
 # print("--------------\n\n")
 # print(processed_blocks)
 # print("--------------\n\n")
+# print(initial_opcode_occurrences)
+# print("--------------\n\n")
 # print(renamed_blocks)