Update utils/block_relation_builder.py

utils/block_relation_builder.py

@@ -277,7 +277,7 @@ all_block_definitions = {
     "control_stop": {
         "block_name": "stop [v]", "block_type": "Control", "block_shape": "Cap Block", "op_code": "control_stop",
         "functionality": "Halts all scripts, only the current script, or other scripts within the same sprite. Its shape can dynamically change based on the selected option.",
-        "inputs": {}, "fields": {"STOP_OPTION": ["all", None]}, "shadow": False, "topLevel": True
+        "inputs": {}, "fields": {"STOP_OPTION": ["all", None]}, "shadow": False, "topLevel": True, "mutation": {"tagName": "mutation", "children": [], "hasnext": "false"}
     },
     "control_start_as_clone": {
         "block_name": "When I Start as a Clone", "block_type": "Control", "block_shape": "Hat Block", "op_code": "control_start_as_clone",
@@ -1017,7 +1017,6 @@ def parse_reporter_or_value(text, parent_key, pick_key_func, all_generated_block
     # [ORDER NO: ] 
     # Variable reporter: [score v] or (score) or just "score"
     m_var = re.fullmatch(r"\[([^\]]+)\s*v\]", text)
-    
     if m_var:
         var_name = m_var.group(1).strip()
         print("the reportor block variable: ",var_name)
@@ -1026,18 +1025,18 @@ def parse_reporter_or_value(text, parent_key, pick_key_func, all_generated_block
     
     # [ORDER NO: ] 
     m_paren_var = re.fullmatch(r"\(([^)]+)\)", text)
-    m_cos = re.fullmatch(r"""\(\s*costume\s+(?:\(\s*(.+?)\s*\)|\[\s*([^\]]+?)\s*v\s*\])\s*\)""",text, re.IGNORECASE | re.VERBOSE)
+    m_cos       = re.fullmatch(r"""\(\s*costume\s+(?:\(\s*(.+?)\s*\)|\[\s*([^\]]+?)\s*v\s*\])\s*\)""",text,re.IGNORECASE | re.VERBOSE)
     if m_paren_var and not m_cos:
-        potential_var_name = m_paren_var.group(1).strip()
-        print("the potential_var_name variable: ", potential_var_name)
-        # *only* treat it as a variable if it contains no arithmetic operators
-        if (potential_var_name not in simple_reporters
-            and not re.fullmatch(r"-?\d+(\.\d+)?", potential_var_name)
-            and not re.search(r"[+\-*/]", potential_var_name)):
-            block_id = _register_block("data_variable", parent_key, True, pick_key_func, all_generated_blocks,
-                                       fields={"VARIABLE": [potential_var_name, None]})
+        potential = m_paren_var.group(1).strip()
+        # If it's literally “[name v]”, pull out just “name”
+        m_bracket_var = re.fullmatch(r"\[\s*([^\]]+?)\s*v\s*\]", potential)
+        if m_bracket_var: potential = m_bracket_var.group(1).strip()
+        print("the potential_var_name variable:", potential)
+        # Only create a data_variable if it’s not a reporter or a number or contains arithmetic
+        if (potential not in simple_reporters and not re.fullmatch(r"-?\d+(\.\d+)?", potential) and not re.search(r"[+\-*/]", potential)):
+            block_id = _register_block("data_variable",parent_key,True,pick_key_func,all_generated_blocks,fields={"VARIABLE": [potential, None]})
             return {"kind": "block", "block": block_id}
-    
+        
     # [ORDER NO: ] 
     # List reporter: [my list v]
     m_list_reporter = re.fullmatch(r"\[([^\]]+)\s*v\]", text.strip())
@@ -1618,7 +1617,7 @@ def parse_condition(stmt, parent_key, pick_key_func, all_generated_blocks):
     m_not = re.fullmatch(r"\s*(?:<\s*)?not\s+(.+?)(?:\s*>)?\s*", s_lower, re.IGNORECASE)  
     if m_not:
         inner = m_not.group(1).strip()
-        print("Boolean NOT",m_not)
+        print("Boolean NOT--->",m_not.group(1).strip())
         inner_obj = parse_condition(inner, parent_key, pick_key_func, all_generated_blocks)
         bid = _register_block("operator_not", parent_key, True, pick_key_func, all_generated_blocks,
                               inputs={"OPERAND": inner_obj})
@@ -1714,13 +1713,7 @@ 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*                # optional leading '<'
-    touching\s*\[\s*        # 'touching ['
-    (?P<sprite>[^\]]+?)     # sprite name
-    \s*(?:v)?\s*\]          # optional 'v' and close ']'
-    \s*\?\s*>?              # literal '?' and optional '>'
-    """, s_lower, re.IGNORECASE | re.VERBOSE)
+    m_touch = re.fullmatch(r"""\s*<?\s*touching\s*\[\s*(?P<sprite>[^\]]+?)\s*(?:v)?\s*\]\s*\?\s*>?""", s_lower, re.IGNORECASE | re.VERBOSE)
     if m_touch:
         sprite = m_touch.group('sprite').strip()
         val = {'mouse-pointer':'_mouse_', 'edge':'_edge_'}.get(sprite, sprite)
@@ -1753,11 +1746,20 @@ def parse_condition(stmt, parent_key, pick_key_func, all_generated_blocks):
         return {"kind": "block", "block": block_id}
 
     # 8) Key pressed: <key [key v] pressed?>
-    m = re.search(r"key \[([^\]]+)\s*v\] pressed\?", s_lower)
+    # 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()
         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)
+        print("<key [...] 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
@@ -1785,7 +1787,7 @@ def classify(line):
     Order of checks matters: more specific patterns should come before more general ones.
     """
     l = line.lower().strip()
-
+    print("the line is this:", l)
     # Ignore comments
     if l.startswith("//"): return None, None
 
@@ -1960,7 +1962,7 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
     while i < len(lines):
         raw_line = lines[i]
         stripped_line = raw_line.strip()
-
+        print("Stripped line here -----1---->", stripped_line)
         # Skip empty lines and comments
         if not stripped_line or stripped_line.startswith("//"):
             i += 1
@@ -1993,6 +1995,7 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
             # Pop the current substack's scope
             popped_indent, popped_owner_key, popped_last_block_in_chain = stack.pop()
             if popped_last_block_in_chain:
+                print("popped_last_block_in_chain is executed here")
                 all_generated_blocks[popped_last_block_in_chain]["next"] = None
             
             # If the popped scope had an owner (C-block or procedure definition),
@@ -2036,9 +2039,11 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
         current_scope_indent, current_owner_block_id, last_block_in_current_chain = stack[-1]
 
         # Classify the statement and create the block
-        stmt_for_parse = stripped_line.rstrip("then").strip()
+        #stmt_for_parse = stripped_line.rstrip("then").strip()
+        stmt_for_parse = re.sub(r"\bthen\s*$", "", stripped_line, flags=re.IGNORECASE).strip()
+        print("befor the classify hit here: ",stmt_for_parse)
         opcode, ntype = classify(stmt_for_parse)
-
+        print("the opcode classify: ",opcode)
         if opcode is None: # Should not happen if classify is robust
             i += 1
             continue
@@ -2238,7 +2243,9 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
             if m_item: info["inputs"]["ITEM"] = {"kind": "value", "value": m_item.group(1).strip()}
         elif opcode == "event_whengreaterthan":
             #m = re.search(r">\s*\(\s*(-?\d+(\.\d+)?)\s*\)", stmt_for_parse, re.IGNORECASE)
-            m = re.search(r""">\s*(?:\(\s*)?(.*?)(?:\s*\))?""", stmt_for_parse, re.IGNORECASE | re.VERBOSE)
+            print(stmt_for_parse)
+            m = re.search(r">\s*(?:\(\s*(.*?)\s*\)|([^\s\)]+))", stmt_for_parse, re.IGNORECASE)
+            print("event_whengreaterthan parse",m.group(1).strip())
             #if m: info["inputs"]["VALUE"] = {"kind": "value", "value": float(m.group(1)) if '.' in m.group(1) else int(m.group(1))}
             if m: info["inputs"]["VALUE"] = parse_reporter_or_value(m.group(1).strip(), key, pick_key, all_generated_blocks)
 
@@ -2341,6 +2348,7 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
             m = re.search(r"switch costume to\s*\[([^\]]+)\s*v\]", 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]})
                 info["inputs"]["COSTUME"] = {"kind": "block", "block": menu_block_id}
         elif opcode in ["looks_switchbackdropto", "looks_switchbackdroptowait"]:
@@ -3058,39 +3066,18 @@ def block_builder(opcode_count,pseudo_code):
 #################################################################################################################################################################
 
 initial_opcode_counts = [
-    {"opcode":"event_whenflagclicked","count":1},
-    {"opcode":"motion_gotoxy","count":1},
-    {"opcode":"motion_changeyby","count":1},
-    {"opcode":"operator_random","count":1},
-    {"opcode":"motion_xposition","count":2},
-    {"opcode":"control_wait","count":1},
-    {"opcode":"control_forever","count":1},
-    {"opcode":"control_if","count":2},
-    {"opcode":"control_stop","count":1},
-    {"opcode":"operator_lt","count":1},
-    {"opcode":"sensing_touchingobject","count":1},
-    #{"opcode":"sensing_touchingobjectmenu","count":1},
-    {"opcode":"event_broadcast","count":1},
-    {"opcode":"data_setvariableto","count":2},
-    {"opcode":"data_showvariable","count":2},
-]
+          {
+            "opcode": "event_whenbroadcastreceived",
+            "count": 1
+          },
+          {
+            "opcode": "looks_hide",
+            "count": 1
+          }
+        ]
 pseudo_code="""
-when green flag clicked
-    wait (2) sec
-    go to x: (pick random -240 to 240) y: (-135)
-    set [score v] to (1)
-    set [speed v] to (1)
-    show variable [score v]
-    show variable [speed v]
-    forever
-        if <((x position)) < (-235)> then
-            change y by (x position)
-        end
-        if <touching [Sprite1 v]?> then
-            broadcast [Game Over v]
-            stop [all v]
-        end
-    end
+when I receive [Game Over v]
+    hide
 end
 """
 # print(pseudo_code)