Update utils/block_relation_builder.py

utils/block_relation_builder.py

@@ -1104,47 +1104,7 @@ def parse_reporter_or_value(text, parent_key, pick_key_func, all_generated_block
         block_id = _register_block("data_itemnumoflist", parent_key, False, pick_key_func, all_generated_blocks, inputs=inputs, fields=fields)
         if item_obj.get("kind") == "block": all_generated_blocks[item_obj["block"]]["parent"] = block_id
         all_generated_blocks[list_block_id]["parent"] = block_id
-        return {"kind": "block", "block": block_id}
-        
-    # # [ORDER NO: ]
-    # # (item (index) of [list v]) (data_itemoflist)
-    # m = re.search(r"item \((.+?)\) of \((.+?)\)", text)
-    # if not m:
-    #     m = re.search(r"item \((.+?)\) of \[([^\]]+)\s*v\]", text)
-    # if m:
-    #     index_obj = parse_reporter_or_value(m.group(1).strip(), parent_key, pick_key_func, all_generated_blocks)
-    #     list_name = m.group(2).strip()
-    #     print("(item (index) of [list v]) : ",index_obj)
-    #     print("(item (index) of [list v]) : ",list_name)
-    #     # Create data_list shadow block for the list name
-    #     list_block_id = _register_block("data_list", parent_key, True, pick_key_func, all_generated_blocks, fields={"LIST": [list_name, None]})
-
-    #     inputs = {"INDEX": index_obj, "LIST": {"kind": "block", "block": list_block_id}}
-    #     fields = {} # No fields in data_itemoflist itself for the list name
-    #     block_id = _register_block("data_itemoflist", parent_key, False, pick_key_func, all_generated_blocks, inputs=inputs, fields=fields)
-    #     if index_obj.get("kind") == "block": all_generated_blocks[index_obj["block"]]["parent"] = block_id
-    #     all_generated_blocks[list_block_id]["parent"] = block_id
-    #     return {"kind": "block", "block": block_id}
-
-    # # [ORDER NO: ]
-    # # (item # of [item] in [list v]) (data_itemnumoflist)
-    # m = re.search(r"item # of \((.+?)\) in \((.+?)\)", text)
-    # if not m:
-    #     m = re.search(r"item # of \[([^\]]+)\] in \[([^\]]+)\s*v\]", text)
-    # if m:
-    #     item_obj = parse_reporter_or_value(m.group(1).strip(), parent_key, pick_key_func, all_generated_blocks)
-    #     list_name = m.group(2).strip()
-    #     print("(item # of [item] in [list v])  : ",index_obj)
-    #     print("(item # of [item] in [list v])  : ",list_name)
-    #     # Create data_list shadow block for the list name
-    #     list_block_id = _register_block("data_list", parent_key, True, pick_key_func, all_generated_blocks, fields={"LIST": [list_name, None]})
-
-    #     inputs = {"ITEM": item_obj, "LIST": {"kind": "block", "block": list_block_id}}
-    #     fields = {} # No fields in data_itemnumoflist itself for the list name
-    #     block_id = _register_block("data_itemnumoflist", parent_key, False, pick_key_func, all_generated_blocks, inputs=inputs, fields=fields)
-    #     if item_obj.get("kind") == "block": all_generated_blocks[item_obj["block"]]["parent"] = block_id
-    #     all_generated_blocks[list_block_id]["parent"] = block_id
-    #     return {"kind": "block", "block": block_id}
+        return {"kind": "block", "block": block_id}        
     
     # [ORDER NO: ] 
     # (pick random () to ()) (operator_random)
@@ -1243,20 +1203,7 @@ def parse_reporter_or_value(text, parent_key, pick_key_func, all_generated_block
         return {"kind": "block", "block": block_id}
 
     # [ORDER NO: ]
-    # (() of ()) (operator_mathop) - handle variable for function type
-    # m = re.search(r"\[([^\]]+)\s*v\] of \((.+?)\)", text) # e.g. [sqrt v] of ((x pos) * (x pos))
-    # if m:
-    #     print("(() of ()) (operator_mathop):[left] ",m.group(1).strip())
-    #     print("(() of ()) (operator_mathop):[rigth] ",m.group(2).strip())
-    #     func_type = m.group(1).strip()
-    #     value_obj = parse_reporter_or_value(m.group(2).strip(), parent_key, pick_key_func, all_generated_blocks)
-    #     inputs = {"NUM": value_obj}
-    #     fields = {"OPERATOR": [func_type.upper(), None]}
-    #     block_id = _register_block("operator_mathop", parent_key, False, pick_key_func, all_generated_blocks, inputs=inputs, fields=fields)
-    #     if value_obj.get("kind") == "block": all_generated_blocks[value_obj["block"]]["parent"] = block_id
-    #     return {"kind": "block", "block": block_id}
-        # (() of ()) (operator_mathop) - handle variable for function type
-        
+       
     def extract_mathop_of_expression(text):
         # Match the function like [sqrt v] of
         m = re.search(r"\[([^\]]+)\s*v\]\s+of\s+\(", text)
@@ -1351,41 +1298,6 @@ def parse_reporter_or_value(text, parent_key, pick_key_func, all_generated_block
         block_id = _register_block("looks_backdropnumbername", parent_key, True, pick_key_func, all_generated_blocks, fields=fields)
         return {"kind": "block", "block": block_id}
     
-    #     # [ORDER NO: ]
-    # # (costume ()) (looks_costumenumbername) - handle with or without 'v'
-    # #m = re.search(r"costume \((.+?)\)", text)
-    # m = re.fullmatch(r"\(?\s*costume\s+(?:\(\s*(.+?)\s*\)|\[\s*([^\]]+?)\s*v\s*\])\s*\)?",text,re.IGNORECASE | re.VERBOSE)
-    # if m:
-    #     option = (m.group(1) or m.group(2))
-    #     if option is None:
-    #         raise ValueError(f"Unable to extract costume option from: {text}")
-    #     option = option.strip()
-    #     print("(costume ()) : ", option)
-    #     fields = {"NUMBER_NAME": [option, None]}
-    #     block_id = _register_block(
-    #         "looks_costumenumbername",
-    #         parent_key,
-    #         False,
-    #         pick_key_func,
-    #         all_generated_blocks,
-    #         fields=fields
-    #     )
-    #     if block_id is None:
-    #         raise RuntimeError(f"_register_block failed for: {text} with fields: {fields}")
-    #     return {"kind": "block", "block": block_id}
-
-    # # [ORDER NO: ]
-    # # (backdrop ()) (looks_backdropnumbername) - handle with or without 'v'
-    # m = re.search(r"backdrop \((.+?)\)", text)
-    # if not m:
-    #     m = re.search(r"backdrop \[([^\]]+)\s*v\]", text)
-    # if m:
-    #     option = m.group(1).strip()
-    #     print("(backdrop ()) : ",option)
-    #     fields = {"NUMBER_NAME": [option, None]}
-    #     block_id = _register_block("looks_backdropnumbername", parent_key, False, pick_key_func, all_generated_blocks, fields=fields)
-    #     return {"kind": "block", "block": block_id}
-
     # [ORDER NO: ]
     # (distance to ()) (sensing_distanceto) - handle with or without 'v'
     m = re.search(r"distance to \((.+?)\)", text)
@@ -1458,53 +1370,6 @@ def parse_reporter_or_value(text, parent_key, pick_key_func, all_generated_block
 
     
     # [ORDER NO: ALWAYS LAST]
-    # Arithmetic operations: (() + ()), (() - ()), (() * ()), (() / ())
-    
-    
-    #_strip_outer = re.compile(r"^\s*(?P<open>[\(\[]+)\s*(?P<inner>.*\S\s*(?P=open)\s*$", re.VERBOSE)
-    # _strip_outer = re.compile(r"^\s*(?P<open>[\(\[]+)\s*(?P<inner>.*\S)\s*(?P=open)\s*$",re.VERBOSE)
-    # _expr = re.compile(r"^\s*(?P<left>[^\s\(\)\[\]]+)\s*(?P<op>[+\-*/])\s*(?P<right>[^\s\(\)\[\]]+)\s*$", re.VERBOSE)
-    # #m_art = re.compile(r"\(?\s*([^\s()]+)\s*\)?\s*([+\-*/])\s*\(?\s*([^\s()]+)\s*\)?", re.VERBOSE)
-    # if text:
-    #     expr = text
-    #     # strip *all* matching layers of () or []
-    #     while True:
-    #         m = _strip_outer.match(expr)
-    #         if not m:
-    #             break
-    #         expr = m.group("inner")
-
-    #     # now match the core "left op right"
-    #     m = _expr.match(expr)
-
-    #     left_str   = m.group("left")
-    #     operator   = m.group("op")
-    #     right_str  = m.group("right")
-    #     print("arithemetic ops:[left] ",left_str)
-    #     print("arithemetic ops:[rigth] ",right_str)
-    #     # your existing parse & block‑creation logic
-    #     op1_obj = parse_reporter_or_value(left_str,  parent_key, pick_key_func, all_generated_blocks)
-    #     op2_obj = parse_reporter_or_value(right_str, parent_key, pick_key_func, all_generated_blocks)
-
-    #     opcode_map = {
-    #         '+': 'operator_add',
-    #         '-': 'operator_subtract',
-    #         '*': 'operator_multiply',
-    #         '/': 'operator_divide',
-    #     }
-    #     inputs = {"NUM1": op1_obj, "NUM2": op2_obj}
-    #     block_id = _register_block(
-    #         opcode_map[operator], parent_key, False,
-    #         pick_key_func, all_generated_blocks,
-    #         inputs=inputs
-    #     )
-
-    #     if op1_obj.get("kind") == "block":
-    #         all_generated_blocks[op1_obj["block"]]["parent"] = block_id
-    #     if op2_obj.get("kind") == "block":
-    #         all_generated_blocks[op2_obj["block"]]["parent"] = block_id
-
-    #     return {"kind": "block", "block": block_id}  
     # Function to strip outer parentheses if they enclose the entire expression
     def strip_outer_parentheses(s):
         s = s.strip()
@@ -1613,9 +1478,10 @@ def parse_condition(stmt, parent_key, pick_key_func, all_generated_blocks):
     boolean operators (and, or, not), and other sensing conditions.
     """
     s = stmt.strip()
+    print("the processed text on parse_conditon-1-->",s )
     s = extract_condition_balanced(s)
     s_lower = s.lower()
-    print("the processed text on parse_conditon",s_lower)
+    print("the processed text on parse_conditon-2-->",s_lower)
     # 1) Boolean NOT: `not <...>`
     m_not = re.fullmatch(r"\s*(?:<\s*)?not\s+(.+?)(?:\s*>)?\s*", s_lower, re.IGNORECASE)  
     if m_not:
@@ -1641,40 +1507,7 @@ def parse_condition(stmt, parent_key, pick_key_func, all_generated_blocks):
         if cond1_obj.get("kind") == "block": all_generated_blocks[cond1_obj["block"]]["parent"] = block_id
         if cond2_obj.get("kind") == "block": all_generated_blocks[cond2_obj["block"]]["parent"] = block_id
         return {"kind": "block", "block": block_id}
-        
-    
-    # # 1a) Comparisons with explicit angle wrappers: < (...) op (...) >
-    # m = re.fullmatch(
-    #     r"\s*<\s*(.+?)\s*(?P<op><|=|>)\s*(.+?)\s*>\s*",
-    #     s_lower,
-    #     re.VERBOSE
-    # )
-    # if m:
-    #     left_txt, right_txt = m.group(1), m.group(3)
-    #     operand1_obj = parse_reporter_or_value(unparen(left_txt), parent_key, pick_key_func, all_generated_blocks)
-    #     operand2_obj = parse_reporter_or_value(unparen(right_txt), parent_key, pick_key_func, all_generated_blocks)
-    #     op_map = {'<': 'operator_lt', '=': 'operator_equals', '>': 'operator_gt'}
-        
-    #     inputs = {"OPERAND1": operand1_obj, "OPERAND2": operand2_obj}
-    #     block_id = _register_block(op_map[m.group('op')], parent_key, False, pick_key_func, all_generated_blocks, inputs=inputs)
-    #     # Set parents for nested inputs
-    #     if operand1_obj.get("kind") == "block": all_generated_blocks[operand1_obj["block"]]["parent"] = block_id
-    #     if operand2_obj.get("kind") == "block": all_generated_blocks[operand2_obj["block"]]["parent"] = block_id
-    #     return {"kind": "block", "block": block_id}
-
-    # # 1b) Simple comparisons without angle wrappers: A op B
-    # m_simple = re.fullmatch(r"\s*(.+?)\s*(?P<op><|=|>)\s*(.+?)\s*", s_lower)
-    # if m_simple:
-    #     left_txt, right_txt = m_simple.group(1), m_simple.group(3)
-    #     operand1_obj = parse_reporter_or_value(unparen(left_txt), parent_key, pick_key_func, all_generated_blocks)
-    #     operand2_obj = parse_reporter_or_value(unparen(right_txt), parent_key, pick_key_func, all_generated_blocks)
-    #     op_map = {'<': 'operator_lt', '=': 'operator_equals', '>': 'operator_gt'}
-        
-    #     inputs = {"OPERAND1": operand1_obj, "OPERAND2": operand2_obj}
-    #     block_id = _register_block(op_map[m_simple.group('op')], parent_key, False, pick_key_func, all_generated_blocks, inputs=inputs)
-    #     if operand1_obj.get("kind") == "block": all_generated_blocks[operand1_obj["block"]]["parent"] = block_id
-    #     if operand2_obj.get("kind") == "block": all_generated_blocks[operand2_obj["block"]]["parent"] = block_id
-    #     return {"kind": "block", "block": block_id}
+
     m_comp = re.fullmatch(r"\s*(?:<\s*)?(?P<left>.+?)\s*(?P<op><|=|>)\s*(?P<right>.+?)(?:\s*>)?\s*",s_lower,re.VERBOSE)
     if m_comp:
         left_txt  = m_comp.group('left')
@@ -1716,8 +1549,6 @@ def parse_condition(stmt, parent_key, pick_key_func, all_generated_blocks):
         return {"kind": "block", "block": block_id}
 
     # 5) Touching object: <touching [edge v]?>
-    # m_touch = re.fullmatch(r"""\s*<?\s*touching\s*\[\s*(?P<sprite>[^\]]+?)\s*(?:v)?\s*\]\s*\?\s*>?""", s_lower, re.IGNORECASE | re.VERBOSE)
-    #m_touch = re.fullmatch(r"""\s*<?\s*touching\s*\[\s*(?P<sprite>[^\]]+?)\s*(?:v)?\s*\]\s*\?\s*>?\s*""", s_lower, re.IGNORECASE | re.VERBOSE)
     m_touch = re.fullmatch(r"""\s*<?\s*touching\s*\[\s*(?P<sprite>[^\]]+?)\s*(?:v)?\s*\]\s*(?:\?)?\s*>?\s*""", s_lower, re.IGNORECASE | re.VERBOSE)
     if m_touch:
         sprite = m_touch.group('sprite').strip()
@@ -1735,31 +1566,65 @@ def parse_condition(stmt, parent_key, pick_key_func, all_generated_blocks):
         return {"kind":"block","block":bid}
 
     # 6) Touching color: <touching color [#rrggbb]?>
-    m = re.search(r"touching color \[(#[0-9A-Fa-f]{6})\]\?", s_lower)
+    COLOR_MAP = {"red": "#FF0000","yellow": "#FFFF00","pink": "#FFC0CB","blue": "#0000FF","green": "#008000",
+                     "black": "#000000","white": "#FFFFFF","orange": "#FFA500","purple": "#800080","gray": "#808080",}
+    # m = re.search(r"touching color \[(#[0-9A-Fa-f]{6})\]\?", s_lower)
+    m = re.search(r"touching color [<\[\(]?(#?[0-9A-Fa-f]{6}|[a-zA-Z]+(?: v)?)[>\]\)]?\??", s_lower)
     if m:
-        inputs = {"COLOR": {"kind": "value", "value": m.group(1)}}
-        print("<touching color [#rrggbb]?> : ",inputs)
-        block_id = _register_block("sensing_touchingcolor", parent_key, True, pick_key_func, all_generated_blocks, inputs=inputs)
+        color_str = m.group(1).strip()
+
+        # Remove trailing " v" if present (Scratch dropdown)
+        if color_str.endswith(" v"):
+            color_str = color_str[:-2].strip()
+        
+        # Normalize to hex
+        if not color_str.startswith("#"):
+            color_str = COLOR_MAP.get(color_str.lower(), None)
+            if color_str is None:
+                raise ValueError(f"❌ Unknown color name: {m.group(1)}")
+
+        inputs = {"COLOR": {"kind": "value", "value": color_str}}
+        print("<touching color [#rrggbb]?> : ", inputs)
+        block_id = _register_block(
+            "sensing_touchingcolor", parent_key, True,
+            pick_key_func, all_generated_blocks, inputs=inputs
+        )
         return {"kind": "block", "block": block_id}
 
     # 7) Color is touching color: <color [#rggbb] is touching [#rrggbb]?>
-    m = re.search(r"color \[(#[0-9A-Fa-f]{6})\] is touching \[(#[0-9A-Fa-f]{6})\]\?", s_lower)
+    m = re.search(r"color [<\[\(]?(#?[0-9A-Fa-f]{6}|[a-zA-Z]+(?: v)?)[>\]\)]? is touching [<\[\(]?(#?[0-9A-Fa-f]{6}|[a-zA-Z]+(?: v)?)[>\]\)]?\??", s_lower)
     if m:
-        inputs = {"COLOR1": {"kind": "value", "value": m.group(1)}, "COLOR2": {"kind": "value", "value": m.group(2)}}
-        print("<color [#rggbb] is touching [#rrggbb]?> : ",inputs)
-        block_id = _register_block("sensing_coloristouchingcolor", parent_key, True, pick_key_func, all_generated_blocks, inputs=inputs)
-        return {"kind": "block", "block": block_id}
+        c1, c2 = m.group(1).strip(), m.group(2).strip()
+
+        # Cleanup dropdown suffix
+        if c1.endswith(" v"):
+            c1 = c1[:-2].strip()
+        if c2.endswith(" v"):
+            c2 = c2[:-2].strip()
+
+        # Normalize each color
+        if not c1.startswith("#"):
+            c1 = COLOR_MAP.get(c1.lower(), None)
+            if c1 is None:
+                raise ValueError(f"❌ Unknown color name: {m.group(1)}")
+        if not c2.startswith("#"):
+            c2 = COLOR_MAP.get(c2.lower(), None)
+            if c2 is None:
+                raise ValueError(f"❌ Unknown color name: {m.group(2)}")
+
+        inputs = {
+            "COLOR1": {"kind": "value", "value": c1},
+            "COLOR2": {"kind": "value", "value": c2},
+        }
+        print("<color [#rrggbb] is touching [#rrggbb]?> : ", inputs)
+
+        block_id = _register_block(
+            "sensing_coloristouchingcolor", parent_key, True,
+            pick_key_func, all_generated_blocks, inputs=inputs
+        )
+        return {"kind": "block", "block": block_id}    
 
     # 8) Key pressed: <key [key v] pressed?>
-    # m = re.search(r"key \[([^\]]+)\s*v\] pressed\?", s_lower)
-    # if m:
-    #     option = m.group(1).strip()
-    #     menu_block_id = _register_block("sensing_keyoptions", parent_key, True, pick_key_func, all_generated_blocks, fields={"KEY_OPTION": [option, None]})
-    #     print("<key [key v] pressed?> :   ",option)
-    #     inputs = {"KEY_OPTION": {"kind": "block", "block": menu_block_id}}
-    #     block_id = _register_block("sensing_keypressed", parent_key, True, pick_key_func, all_generated_blocks, inputs=inputs)
-    #     all_generated_blocks[menu_block_id]["parent"] = block_id
-    #     return {"kind": "block", "block": block_id}
     m = re.search(r"(?:<)?(?:key\s*)?\[([^\]]+?)\s*v\](?:\s*key)?\s*pressed\?(?:>)?", s_lower, re.IGNORECASE)
     if m:
         option = m.group(1).strip()
@@ -1947,6 +1812,46 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
             return f"{opcode}_{idx + 1}"
         ptrs[opcode] += 1
         return lst[idx]
+    
+    # Helper: lookahead for `else` that matches this `if`
+    def classify_with_else_context(lines, i, stripped_line):
+        """
+        If stripped_line starts with an if-expression (e.g. "if <...> then"),
+        scan forward to see if a corresponding 'else' exists before the matching 'end'.
+        Returns a tuple (opcode, ntype).
+        If this helper doesn't apply, it returns ("", "") (no None).
+        """
+        l = stripped_line.strip().lower()
+        if not l.startswith("if <"):
+            return ("", "")
+
+        # Lookahead with nesting: nested 'if' increments depth.
+        depth = 0
+        for j in range(i + 1, len(lines)):
+            look = lines[j].strip().lower()
+            # ignore blank lines and comments
+            if not look or look.startswith("//"):
+                continue
+
+            # if we find another 'if <' before an 'end', that's a nested if -> depth+1
+            if look.startswith("if <"):
+                depth += 1
+                continue
+
+            # an 'end' closes the most recent if (nested or this one)
+            if look == "end":
+                if depth == 0:
+                    # reached the end for this if without seeing an else
+                    break
+                depth -= 1
+                continue
+
+            # an else that occurs when depth == 0 belongs to this if
+            if look == "else" and depth == 0:
+                return ("control_if_else", "c_block")
+
+        # no matching else found before the corresponding end -> plain control_if
+        return ("control_if", "c_block")
 
     # Change: Start with an empty dictionary. Blocks will be added only as they are parsed.
     all_generated_blocks = {}
@@ -1955,6 +1860,7 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
     top_level_script_keys = []
 
     lines = pseudo_code.splitlines()
+    print("The lines here are:\n", lines)
     i = 0
     while i < len(lines):
         raw_line = lines[i]
@@ -1976,16 +1882,13 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
             # This check now looks for any C-Block, which is correct for this context.
             if popped_owner_key and all_generated_blocks[popped_owner_key]["block_shape"] == "C-Block":
                 
-                # This is the crucial step that fixes the issue.
-                # We explicitly upgrade the block from a 'control_if' to a 'control_if_else'.
+                # Explicitly upgrade the block from a 'control_if' to a 'control_if_else'.
                 owner_block = all_generated_blocks[popped_owner_key]
                 owner_block["op_code"] = "control_if_else"
                 
                 # Push a new scope for the 'else' substack, with the same owner.
                 stack.append((current_indent, popped_owner_key, None))
             else:
-                # This is the error you were getting.
-                # It happens because the 'if' block was never correctly upgraded.
                 print(f"Error: 'else' found without a corresponding 'if-else' block at line {i+1}")
                 stack.append((popped_indent, popped_owner_key, popped_last_block_in_chain))
             i += 1
@@ -2016,10 +1919,17 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
 
         current_scope_indent, current_owner_block_id, last_block_in_current_chain = stack[-1]
 
-        opcode, ntype = classify(stripped_line)
+        # RUN the lookahead classifier first; it never returns None.
+        override_opcode, override_ntype = classify_with_else_context(lines, i, stripped_line)
+        if override_opcode:
+            opcode, ntype = override_opcode, override_ntype
+        else:
+            # fallback to your original classify (unchanged)
+            opcode, ntype = classify(stripped_line)
+
         stmt_for_parse = re.sub(r"\bthen(\s+go)?\s*$", "", stripped_line, flags=re.IGNORECASE).strip()
-        print("The opcode here is",opcode)
-        print("The ntype here is",ntype)
+        print("The opcode here is", opcode)
+        print("The ntype here is", ntype)
         if opcode is None:
             i += 1
             continue
@@ -2073,34 +1983,17 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
         # are passed the *newly created block's ID* as the parent_key for nested inputs)
         # Numeric inputs (e.g., move (10) steps, wait (1) seconds)
         if opcode == "motion_movesteps":
-            #m = re.search(r"move\s*(?:\(\s*)?(-?\d+(?:\.\d+)?)(?:\s*\))?\s*steps", stmt_for_parse, re.IGNORECASE)
             m = re.search(r"move\s*(?:\(\s*)?(.+?)(?:\s*\))?\s*steps", stmt_for_parse, re.IGNORECASE)
-            #if m: info["inputs"]["STEPS"] = {"kind": "value", "value": float(m.group(1)) if '.' in m.group(1) else int(m.group(1))}
             print("motion_movesteps : ",m.group(1).strip())
             if m: info["inputs"]["STEPS"] = parse_reporter_or_value(m.group(1).strip(), key, pick_key, all_generated_blocks)
-            # block_id = _register_block(opcode, key, False, pick_key, all_generated_blocks, inputs=info["inputs"]["STEPS"])
-            # print(f"block_id {opcode} : {block_id}")
         elif opcode == "motion_turnright" or opcode == "motion_turnleft":
-            # m = re.search(r"turn\s*(?:right|left)?\s*\(.*?\)\s*\(\s*(-?\d+(\.\d+)?)\s*\)\s*degrees", stmt_for_parse, re.IGNORECASE)
-            #m = re.search(r"turn\s*(?:right|left)?\s*(?:\(\s*)?(-?\d+(?:\.\d+)?)(?:\s*\))?\s*degrees", stmt_for_parse, re.IGNORECASE)
             m = re.search(r"turn\s*(?:right|left)?\s*(?:\(\s*)?(.+?)(?:\s*\))?\s*degrees", stmt_for_parse, re.IGNORECASE)
-            # if m: info["inputs"]["DEGREES"] = {"kind": "value", "value": float(m.group(1)) if '.' in m.group(1) else int(m.group(1))}
             if m: info["inputs"]["DEGREES"] = parse_reporter_or_value(m.group(1).strip(), key, pick_key, all_generated_blocks)
-            # block_id = _register_block(opcode, key, False, pick_key, all_generated_blocks, info["inputs"]["DEGREES"])
-            # print(f"block_id {opcode} : {block_id}")
         elif opcode == "motion_gotoxy":
-            # m_x = re.search(r"x:\s*(\(.+?\)|[^\s)]+)", stmt_for_parse, re.IGNORECASE)
-            # m_y = re.search(r"y:\s*(\(.+?\)|[^\s)]+)", stmt_for_parse, re.IGNORECASE)
             m_x = re.search(r"x:\s*(?:\(\s*)?(.+?)(?:\s*\))?(?=\s*y:|$)", stmt_for_parse, re.IGNORECASE)
             m_y = re.search(r"y:\s*(?:\(\s*)?(.+?)(?:\s*\))?(?=\s*$)", stmt_for_parse, re.IGNORECASE)
             if m_x: info["inputs"]["X"] = parse_reporter_or_value( m_x.group(1).strip("() "), key, pick_key, all_generated_blocks)
             if m_y: info["inputs"]["Y"] = parse_reporter_or_value( m_y.group(1).strip("() "), key, pick_key, all_generated_blocks)
-            # print("motion_gotoxy m_x", m_x.group(1) if m_x else None)
-            # print("motion_gotoxy m_y", m_y.group(1) if m_y else None)
-            # if m_x: block_id = _register_block(opcode, key, False, pick_key, all_generated_blocks, )
-            # print(f"block_id {opcode} : {block_id}")
-            # if m_y: block_id = _register_block(opcode, key, False, pick_key, all_generated_blocks, inputs=info["inputs"]["Y"])
-            # print(f"block_id {opcode} : {block_id}")
         elif opcode == "motion_glidesecstoxy":
             stmt = _auto_balance(stmt_for_parse)
             # m_secs = re.search(r"glide\s*\(\s*(-?\d+(\.\d+)?)\s*\)\s*secs", stmt_for_parse, re.IGNORECASE)
@@ -2244,60 +2137,59 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
 
         # Dropdown/Menu inputs (UPDATED)
         elif opcode == "motion_goto":
-            m = re.search(r"go to\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
+            m = re.search(r"go to\s*(?:\[\s*([^\]]+?)\s*v\]|\(?\s*([^)]+?)\s*\)?|([A-Za-z][^\n]+))", stmt_for_parse, re.IGNORECASE)
             if m:
-                option = m.group(1).strip()
-                if option == "random position": option_val = "_random_"
-                elif option == "mouse-pointer": option_val = "_mouse_"
-                else: option_val = option
-                
-                menu_block_id = _register_block("motion_goto_menu", key, True, pick_key, all_generated_blocks, fields={"TO": [option_val, None]})
+                option = (m.group(1) or m.group(2) or m.group(3)).strip()
+                option_val = {"random position": "_random_", "mouse-pointer": "_mouse_"}.get(option, option)
+                menu_block_id = _register_block("motion_goto_menu", key, True, pick_key, all_generated_blocks,
+                                                fields={"TO": [option_val, None]})
                 info["inputs"]["TO"] = {"kind": "block", "block": menu_block_id}
+
         elif opcode == "motion_glideto":
-            m_secs = re.search(r"glide\s*\(\s*(-?\d+(\.\d+)?)\s*\)\s*secs to\s*(?:\[([^\]]+)\s*v\]|\((.+?)\))", stmt_for_parse, re.IGNORECASE)
+            m_secs = re.search(
+                r"glide\s*\(\s*(-?\d+(?:\.\d+)?)\s*\)\s*secs to\s*(?:\[\s*([^\]]+?)\s*v\]|\(?\s*([^)]+?)\s*\)?|([A-Za-z][^\n]+))",stmt_for_parse, re.IGNORECASE)
             if m_secs:
-                info["inputs"]["SECS"] = {"kind": "value", "value": float(m_secs.group(1)) if '.' in m_secs.group(1) else int(m_secs.group(1))}
-                # Use group 3 for [random position v] or group 4 for (random position)
-                option = (m_secs.group(3) or m_secs.group(4)).strip() 
-                if option == "random position": option_val = "_random_"
-                elif option == "mouse-pointer": option_val = "_mouse_"
-                else: option_val = option
-                
-                menu_block_id = _register_block("motion_glideto_menu", key, True, pick_key, all_generated_blocks, fields={"TO": [option_val, None]})
+                secs = float(m_secs.group(1)) if '.' in m_secs.group(1) else int(m_secs.group(1))
+                option = (m_secs.group(2) or m_secs.group(3) or m_secs.group(4)).strip()
+                option_val = {"random position": "_random_", "mouse-pointer": "_mouse_"}.get(option, option)
+                info["inputs"]["SECS"] = {"kind": "value", "value": secs}
+                menu_block_id = _register_block("motion_glideto_menu", key, True, pick_key, all_generated_blocks,
+                                                fields={"TO": [option_val, None]})
                 info["inputs"]["TO"] = {"kind": "block", "block": menu_block_id}
+
         elif opcode == "motion_pointtowards":
-            m = re.search(r"point towards\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
+            m = re.search(r"point towards\s*(?:\[\s*([^\]]+?)\s*v\]|\(?\s*([^)]+?)\s*\)?|([A-Za-z][^\n]+))",stmt_for_parse, re.IGNORECASE)
             if m:
-                option = m.group(1).strip()
-                if option == "mouse-pointer": option_val = "_mouse_"
-                else: option_val = option
-                
-                menu_block_id = _register_block("motion_pointtowards_menu", key, True, pick_key, all_generated_blocks, fields={"TOWARDS": [option_val, None]})
+                option = (m.group(1) or m.group(2) or m.group(3)).strip()
+                option_val = {"mouse-pointer": "_mouse_"}.get(option, option)
+                menu_block_id = _register_block("motion_pointtowards_menu", key, True, pick_key, all_generated_blocks,
+                                                fields={"TOWARDS": [option_val, None]})
                 info["inputs"]["TOWARDS"] = {"kind": "block", "block": menu_block_id}
+
         elif opcode == "sensing_keypressed":
-            m = re.search(r"key \[([^\]]+)\s*v\] pressed\?", stmt_for_parse, re.IGNORECASE)
+            m = re.search(r"key\s*(?:\[\s*([^\]]+?)\s*v\]|\(?\s*([^)]+?)\s*\)?|([A-Za-z][^\n]+))\s*pressed\?",stmt_for_parse, re.IGNORECASE)
             if m:
-                option = m.group(1).strip()
-                menu_block_id = _register_block("sensing_keyoptions", key, True, pick_key, all_generated_blocks, fields={"KEY_OPTION": [option, None]})
+                option = (m.group(1) or m.group(2) or m.group(3)).strip()
+                menu_block_id = _register_block("sensing_keyoptions", key, True, pick_key, all_generated_blocks,
+                                                fields={"KEY_OPTION": [option, None]})
                 info["inputs"]["KEY_OPTION"] = {"kind": "block", "block": menu_block_id}
+
         elif opcode == "sensing_touchingobject":
-            m = re.search(r"touching \[([^\]]+)\s*v\]\?", stmt_for_parse, re.IGNORECASE)
+            m = re.search(r"touching\s*(?:\[\s*([^\]]+?)\s*v\]|\(?\s*([^)]+?)\s*\)?|([A-Za-z][^\n]+))\?",stmt_for_parse, re.IGNORECASE)
             if m:
-                option = m.group(1).strip()
-                if option == "mouse-pointer": option_val = "_mouse_"
-                elif option == "edge": option_val = "_edge_"
-                else: option_val = option
-                
-                menu_block_id = _register_block("sensing_touchingobjectmenu", key, True, pick_key, all_generated_blocks, fields={"TOUCHINGOBJECTMENU": [option_val, None]})
+                option = (m.group(1) or m.group(2) or m.group(3)).strip()
+                option_val = {"mouse-pointer": "_mouse_", "edge": "_edge_"}.get(option, option)
+                menu_block_id = _register_block("sensing_touchingobjectmenu", key, True, pick_key, all_generated_blocks,
+                                                fields={"TOUCHINGOBJECTMENU": [option_val, None]})
                 info["inputs"]["TOUCHINGOBJECTMENU"] = {"kind": "block", "block": menu_block_id}
+
         elif opcode == "control_create_clone_of":
-            m = re.search(r"create clone of\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
+            m = re.search(r"create clone of\s*(?:\[\s*([^\]]+?)\s*v\]|\(?\s*([^)]+?)\s*\)?|([A-Za-z][^\n]+))",stmt_for_parse, re.IGNORECASE)
             if m:
-                option = m.group(1).strip()
-                if option == "myself": option_val = "_myself_"
-                else: option_val = option
-                
-                menu_block_id = _register_block("control_create_clone_of_menu", key, True, pick_key, all_generated_blocks, fields={"CLONE_OPTION": [option_val, None]})
+                option = (m.group(1) or m.group(2) or m.group(3)).strip()
+                option_val = {"myself": "_myself_"}.get(option, option)
+                menu_block_id = _register_block("control_create_clone_of_menu", key, True, pick_key, all_generated_blocks,
+                                                fields={"CLONE_OPTION": [option_val, None]})
                 info["inputs"]["CLONE_OPTION"] = {"kind": "block", "block": menu_block_id}
         elif opcode in ["sound_playuntildone", "sound_play"]:
             # m = re.search(r"(?:play sound|start sound)\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
@@ -2309,28 +2201,42 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
                 menu_block_id = _register_block("sound_sounds_menu", key, True, pick_key, all_generated_blocks, fields={"SOUND_MENU": [option, None]})
                 info["inputs"]["SOUND_MENU"] = {"kind": "block", "block": menu_block_id}
         elif opcode == "looks_switchcostumeto":
-            m = re.search(r"switch costume to\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
+            m = re.search(r"switch costume to\s*(?:\[\s*([^\]]+?)\s*v\]|\(?\s*([^)]+?)\s*\)?|([A-Za-z][^\n]+))",stmt_for_parse, re.IGNORECASE)
             if m:
-                option = m.group(1).strip()
-                print("option at looks_switchcostumeto:  ",option)
-                menu_block_id = _register_block("looks_costume", key, True, pick_key, all_generated_blocks, fields={"COSTUME": [option, None]})
+                option = (m.group(1) or m.group(2) or m.group(3)).strip()
+                menu_block_id = _register_block("looks_costume", key, True, pick_key, all_generated_blocks,
+                                                fields={"COSTUME": [option, None]})
                 info["inputs"]["COSTUME"] = {"kind": "block", "block": menu_block_id}
+
         elif opcode in ["looks_switchbackdropto", "looks_switchbackdroptowait"]:
-            m = re.search(r"switch backdrop to\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
+            m = re.search(r"switch backdrop to\s*(?:\[\s*([^\]]+?)\s*v\]|\(?\s*([^)]+?)\s*\)?|([A-Za-z][^\n]+))",stmt_for_parse, re.IGNORECASE)
             if m:
-                option = m.group(1).strip()
-                menu_block_id = _register_block("looks_backdrops", key, True, pick_key, all_generated_blocks, fields={"BACKDROP": [option, None]})
+                option = (m.group(1) or m.group(2) or m.group(3)).strip()
+                menu_block_id = _register_block("looks_backdrops", key, True, pick_key, all_generated_blocks,
+                                                fields={"BACKDROP": [option, None]})
                 info["inputs"]["BACKDROP"] = {"kind": "block", "block": menu_block_id}
+
         elif opcode in ["event_broadcast", "event_broadcastandwait"]:
-            m = re.search(r"broadcast\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
+            m = re.search(r"broadcast\s*(?:\[\s*([^\]]+?)\s*v\]|\(?\s*([^)]+?)\s*\)?|([A-Za-z][^\n]+))",stmt_for_parse, re.IGNORECASE)
+            if m:
+                option = (m.group(1) or m.group(2) or m.group(3)).strip()
+                info["inputs"]["BROADCAST_INPUT"] = {"kind": "value", "value": option}
+        elif opcode == "control_stop":
+            # m = re.match(r"stop\s*[\[(]?\s*(all|this script|other scripts in sprite)\s*(?:v)?\s*[\])]?$",
+            m = re.match(r"stop\s*[\[(]?\s*(all|this script|other scripts in sprite)\s*(?:v)?\s*[\])]?$",
+                        stmt_for_parse, re.IGNORECASE)
             if m:
-                option = m.group(1).strip()
-                # Broadcast input doesn't use a separate menu block in definitions, it's a direct menu field in the input.
-                # So, it should be [1, [11, "message1", "id"]] or [1, [12, "message1"]]
-                # For now, let's keep it simple as [1, [11, option, None]] or similar if the definition allows.
-                # The `all_block_definitions` has `[1, [11, "message1", "5O!nei;S$!c!=hCT}0:a"]]`
-                # Let's use that format, but without the specific ID for now.
-                info["inputs"]["BROADCAST_INPUT"] = {"kind": "value", "value": option} # Store as a value for now
+                option = m.group(1).strip().lower()
+                # Normalize casing to match Scratch’s expected field values
+                if option == "all":
+                    stop_val = "all"
+                elif option == "this script":
+                    stop_val = "this script"
+                else:
+                    stop_val = "other scripts in sprite"
+
+                info.setdefault("fields", {})
+                info["fields"]["STOP_OPTION"] = [stop_val, None]
 
         # Conditional inputs (Boolean blocks)
         elif opcode in ["control_if", "control_if_else", "control_wait_until", "control_repeat_until"]:
@@ -2462,6 +2368,7 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
                         info["mutation"]["argumentnames"].append(f"arg{idx+1}") # Placeholder name for mutation
                         
                         info["inputs"][arg_input_name] = parse_reporter_or_value(arg_val_str, key, pick_key, all_generated_blocks) # Pass current block's key
+
         i += 1 # Move to the next line
 
     # Final pass to ensure last blocks have next: None (already handled by stack pops)
@@ -2828,6 +2735,18 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                         processed_block["fields"][field_name] = field_value
                 else:
                     processed_block["fields"][field_name] = field_value
+                    
+        if opcode == "control_stop":
+            stop_option = processed_block["fields"].get("STOP_OPTION", ["", None])[0]
+            hasnext_val = "true" if stop_option == "other scripts in sprite" else "false"
+            if "mutation" not in processed_block:
+                processed_block["mutation"] = {
+                    "tagName": "mutation",
+                    "children": [],
+                    "hasnext": hasnext_val
+                }
+            else:
+                processed_block["mutation"]["hasnext"] = hasnext_val
         
         # Remove unwanted keys from the processed block (if somehow present)
         keys_to_remove = ["functionality", "block_shape", "id", "block_name", "block_type"]
@@ -2837,7 +2756,7 @@ 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]-------------------------------
 #################################################################################################################################################################
@@ -3097,7 +3016,8 @@ def _find_all_opcodes(code_block: str) -> list[str]:
         # --- Multi-line Control Blocks (most specific, non-greedy) ---
         (r"if <.+?> then(?:.|\n)+?else(?:.|\n)+?end", "control_if_else"), #(to test muliple stack)
         (r"forever", "control_forever"),
-        (r"if <.+?> then", "control_if"),
+        # (r"if <.+?> then", "control_if"),
+        (r"if <.+?> then(?:(?!else).|\n)+?end", "control_if"),
         (r"repeat until <.+?>", "control_repeat_until"),
         (r"repeat\s+(?:\(.+?\)|\[.+?(?:\s+v)?\]|\S+)", "control_repeat"),
         (r"stop\s+(?:all|this script|other scripts in sprite|\[(?:all|this script|other scripts in sprite)(?:\s+v)?\])(?!\s+sounds)", "control_stop"),
@@ -3153,7 +3073,7 @@ def _find_all_opcodes(code_block: str) -> list[str]:
         # (r"play sound \[.+? v\] until done", "sound_playuntildone"),
         # (r"start sound \[.+? v\]", "sound_play"),
         (r"play sound\s+(?:\[\s*.+?\s*v\]|\(?\s*.+?\s*\)?)\s+until done", "sound_playuntildone"),
-        (r"start sound\s+(?:\[\s*.+?\s*v\]|\(?\s*.+?\s*\)?)", "sound_play"),
+        (r"start sound\s+(?:\[\s*.+?\s*v\]|\(?\s*.+?\s*\)?)", "sound_play"), 
         (r"stop all sounds", "sound_stopallsounds"),
         (r"change volume by\s*(?:\((.+?)\)|\[(.+?)\]|(.+))", "sound_changevolumeby"),
         (r"""set\ volume\ to\s+\(?\s*(?:-?\d+(?:\.\d+)?|\[?[a-zA-Z_][\w\s]*\]?(?:\ v)?)\s*\)?\s*%?""", "sound_setvolumeto"),
@@ -3257,75 +3177,49 @@ def analyze_opcode_counts(pseudo_code: str) -> list[dict]:
 #--------------------------------------------------[Helper function to seperate an correct the json]-------------------------------------------------------------
 #################################################################################################################################################################
 
-# def separate_scripts(pseudocode_string):
-#     """
-#     Separates a block of Scratch pseudocode into a list of individual scripts.
-
-#     This function finds the start of each "hat" block and slices the
-#     original string to capture the full code block for each script,
-#     providing a more robust and reliable separation.
-
-#     Args:
-#         pseudocode_string (str): A string containing Scratch pseudocode.
-
-#     Returns:
-#         list: A list of strings, where each string is a complete,
-#               separated script.
-#     """
-#     # Define the "hat" block patterns with more robust regex.
-#     # We use a non-capturing group (?:...) for the patterns.
-#     # We use a logical OR (|) to combine them into a single pattern.
-#     delimiter_patterns = (
-#         r"when green flag clicked|when flag clicked|when \S+ key pressed|"
-#         r"when this sprite clicked|when backdrop switches to \[.*?\]|"
-#         r"when I receive \[.*?\]|when \[.*?\] > \[.*?\]"
-#     )
-
-#     # Use re.finditer to get an iterator of all hat block matches.
-#     # The `re.DOTALL` flag allows the '.' to match newlines.
-#     matches = list(re.finditer(delimiter_patterns, pseudocode_string, flags=re.DOTALL | re.IGNORECASE))
-
-#     scripts = []
-#     # If no matches are found, return an empty list.
-#     if not matches:
-#         return []
-
-#     # Iterate through the matches to slice the original string.
-#     for i in range(len(matches)):
-#         start = matches[i].start()
-#         end = matches[i+1].start() if i + 1 < len(matches) else len(pseudocode_string)
-        
-#         # Slice the pseudocode string from the start of one match to the start
-#         # of the next, or to the end of the string.
-#         script = pseudocode_string[start:end]
-#         scripts.append(script.strip())
-    
-#     return scripts
 def separate_scripts(pseudocode_string):
     """
-    Split a block of Scratch pseudocode into individual scripts.
-    Each script starts at a 'when ...' hat block that appears at the start
-    of a line (leading whitespace allowed).
-    """
-    # Robust, non-capturing hat-block patterns (no capturing groups!)
-    patterns = [
-        r"when\s+(?:green\s+flag\s+)?click(?:ed)?\b",                 # when flag clicked / when green flag clicked
-        r"when\s+(?:\S+(?:\s+\S+)*)\s+key\s+press(?:ed)?\b",         # when space key pressed / when up arrow key press
-        r"when\s+this\s+sprite\s+click(?:ed)?\b",                   # when this sprite clicked
-        r"when\s+backdrop\s+switch(?:es|ed)?\s+to\s*\[[^\]]*\]",    # when backdrop switches to [..]
-        r"when\s+I\s+receive(?:d)?\s*\[[^\]]*\]",                   # when I receive [..] / when I received [..]
-        r"when\s*\[[^\]]*\]\s*>\s*\[[^\]]*\]"                       # when [sensor] > [value]
-    ]
+    Separates a block of Scratch pseudocode into a list of individual scripts.
 
-    # Build a lookahead that finds positions just before a hat block at line-start
-    lookahead = r"(?=^\s*(?:{}))".format("|".join(patterns))
+    This function finds the start of each "hat" block and slices the
+    original string to capture the full code block for each script,
+    providing a more robust and reliable separation.
 
-    # Use MULTILINE so ^ matches start of lines, DOTALL to allow patterns that may include brackets/newlines as needed
-    parts = re.split(lookahead, pseudocode_string, flags=re.IGNORECASE | re.MULTILINE | re.DOTALL)
-
-    # Filter out empties and strip leading/trailing whitespace/newlines
-    scripts = [p.strip() for p in parts if p and p.strip()]
+    Args:
+        pseudocode_string (str): A string containing Scratch pseudocode.
 
+    Returns:
+        list: A list of strings, where each string is a complete,
+              separated script.
+    """
+    # Define the "hat" block patterns with more robust regex.
+    # We use a non-capturing group (?:...) for the patterns.
+    # We use a logical OR (|) to combine them into a single pattern.
+    delimiter_patterns = (
+        r"when green flag clicked|when flag clicked|when \S+ key pressed|"
+        r"when this sprite clicked|when backdrop switches to \[.*?\]|"
+        r"when I receive \[.*?\]|when \[.*?\] > \[.*?\]"
+    )
+
+    # Use re.finditer to get an iterator of all hat block matches.
+    # The `re.DOTALL` flag allows the '.' to match newlines.
+    matches = list(re.finditer(delimiter_patterns, pseudocode_string, flags=re.DOTALL | re.IGNORECASE))
+
+    scripts = []
+    # If no matches are found, return an empty list.
+    if not matches:
+        return []
+
+    # Iterate through the matches to slice the original string.
+    for i in range(len(matches)):
+        start = matches[i].start()
+        end = matches[i+1].start() if i + 1 < len(matches) else len(pseudocode_string)
+        
+        # Slice the pseudocode string from the start of one match to the start
+        # of the next, or to the end of the string.
+        script = pseudocode_string[start:end]
+        scripts.append(script.strip())
+    
     return scripts
 
 def transform_logic_to_action_flow(source_data, description=""):
@@ -3393,37 +3287,38 @@ def block_builder(opcode_count,pseudo_code):
 #--------------------------------------------------[Example use of the function here]----------------------------------------------------------------------------
 #################################################################################################################################################################
 
-initial_opcode_counts = [
-          {"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 Start v]
-    forever
-        if <touching [obstacle v]?> then
-            hide
-            switch backdrop to [loose v]
-            broadcast [Game Over v]
-            stop all
-        end
-end
-"""
+# initial_opcode_counts = [
+#           {"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 [space v] key pressed
+#     start sound (Meow)
+#     next costume
+#     repeat (10)
+#         change y by (10)
+#         wait (0.0001) seconds
+#         change y by (-10)
+#         wait (0.0001) seconds
+#     end
+#     next costume
+# """
 # print(pseudo_code)
 # opcode_counts_result = analyze_opcode_counts(pseudo_code)
 # generated_output_json, initial_opcode_occurrences = generate_blocks_from_opcodes(opcode_counts_result, all_block_definitions)
 # 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(opcode_counts_result)
+# print(generated_output_json)
 # print("--------------\n\n")
 # print(processed_blocks)
 # print("--------------\n\n")
-# print(initial_opcode_occurrences)
+# print(all_generated_blocks)
 # print("--------------\n\n")
-# print(renamed_blocks)
+# print(opcode_counts_result)