diff --git a/cube1/data/C485.json b/cube1/data/C485.json new file mode 100644 index 0000000000000000000000000000000000000000..d219c7c05c48245373a368250dc335951669f88d --- /dev/null +++ b/cube1/data/C485.json @@ -0,0 +1,316 @@ +{ + "sample_id": "C485", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: S -> E -> E -> S -> W -> S -> W -> N -> N -> N\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "S", + "E", + "E", + "S", + "W", + "S", + "W", + "N", + "N", + "N" + ], + "observed_path_faces": [ + { + "patternId": "P", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C485_path_sequence.png" + }, + "metadata": { + "level_id": 485, + "name": "Reconstruct 485", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-485.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "B", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "P", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "D", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "heart", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_left", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "B", + "P", + "D", + "K", + "heart", + "arrow_left" + ], + "start_x": 1, + "start_y": 1, + "grid_width": 5, + "grid_height": 6, + "true_solution_faces": { + "TOP": { + "patternId": "B", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + }, + "FRONT": { + "patternId": "P", + "rotation": 90 + }, + "BACK": { + "patternId": "K", + "rotation": 90 + }, + "LEFT": { + "patternId": "heart", + "rotation": 270 + }, + "RIGHT": { + "patternId": "D", + "rotation": 180 + } + }, + "bottom_faces": [ + { + "patternId": "arrow_left", + "rotation": 270, + "x": 1, + "y": 1 + }, + { + "patternId": "P", + "rotation": 90, + "x": 1, + "y": 2 + }, + { + "patternId": "D", + "rotation": 180, + "x": 2, + "y": 2 + }, + { + "patternId": "K", + "rotation": 90, + "x": 3, + "y": 2 + }, + { + "patternId": "B", + "rotation": 0, + "x": 3, + "y": 3 + }, + { + "patternId": "D", + "rotation": 270, + "x": 2, + "y": 3 + }, + { + "patternId": "P", + "rotation": 180, + "x": 2, + "y": 4 + }, + { + "patternId": "arrow_left", + "rotation": 0, + "x": 1, + "y": 4 + }, + { + "patternId": "D", + "rotation": 0, + "x": 1, + "y": 3 + }, + { + "patternId": "B", + "rotation": 90, + "x": 1, + "y": 2 + }, + { + "patternId": "heart", + "rotation": 270, + "x": 1, + "y": 1 + } + ], + "slot_sequence": [ + "FRONT", + "RIGHT", + "BACK", + "TOP", + "RIGHT", + "FRONT", + "BOTTOM", + "RIGHT", + "TOP", + "LEFT" + ], + "required_slots": [ + "FRONT", + "RIGHT", + "BACK", + "TOP", + "BOTTOM", + "LEFT" + ], + "required_count": 6, + "answer": { + "faces": { + "TOP": { + "patternId": "B", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + }, + "FRONT": { + "patternId": "P", + "rotation": 90 + }, + "BACK": { + "patternId": "K", + "rotation": 270 + }, + "LEFT": { + "patternId": "heart", + "rotation": 0 + }, + "RIGHT": { + "patternId": "D", + "rotation": 90 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "B", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + }, + "FRONT": { + "patternId": "P", + "rotation": 90 + }, + "BACK": { + "patternId": "K", + "rotation": 270 + }, + "LEFT": { + "patternId": "heart", + "rotation": 0 + }, + "RIGHT": { + "patternId": "D", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C485\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): S -> E -> E -> S -> W -> S -> W -> N -> N -> N\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=P, rotation=90, flipVertical=true\n- step 2: patternId=D, rotation=180, flipVertical=true\n- step 3: patternId=K, rotation=90, flipVertical=true\n- step 4: patternId=B, rotation=0, flipVertical=true\n- step 5: patternId=D, rotation=270, flipVertical=true\n- step 6: patternId=P, rotation=180, flipVertical=true\n- step 7: patternId=arrow_left, rotation=0, flipVertical=true\n- step 8: patternId=D, rotation=0, flipVertical=true\n- step 9: patternId=B, rotation=90, flipVertical=true\n- step 10: patternId=heart, rotation=270, flipVertical=true\n- allowed patternId values for this task: P, D, K, B, arrow_left, heart, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C486.json b/cube1/data/C486.json new file mode 100644 index 0000000000000000000000000000000000000000..022ebe60ad4f158a1f1e14d621700aec88c2e6d2 --- /dev/null +++ b/cube1/data/C486.json @@ -0,0 +1,316 @@ +{ + "sample_id": "C486", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: S -> W -> S -> E -> W -> S -> W -> N -> W -> W\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "S", + "W", + "S", + "E", + "W", + "S", + "W", + "N", + "W", + "W" + ], + "observed_path_faces": [ + { + "patternId": "H", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "H", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C486_path_sequence.png" + }, + "metadata": { + "level_id": 486, + "name": "Reconstruct 486", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-486.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "circle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "H", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "W", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_left", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "circle", + "H", + "W", + "2", + "K", + "arrow_left" + ], + "start_x": 5, + "start_y": 1, + "grid_width": 7, + "grid_height": 6, + "true_solution_faces": { + "TOP": { + "patternId": "circle", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + }, + "FRONT": { + "patternId": "H", + "rotation": 270 + }, + "BACK": { + "patternId": "2", + "rotation": 90 + }, + "LEFT": { + "patternId": "K", + "rotation": 180 + }, + "RIGHT": { + "patternId": "W", + "rotation": 0 + } + }, + "bottom_faces": [ + { + "patternId": "arrow_left", + "rotation": 270, + "x": 5, + "y": 1 + }, + { + "patternId": "H", + "rotation": 270, + "x": 5, + "y": 2 + }, + { + "patternId": "K", + "rotation": 180, + "x": 4, + "y": 2 + }, + { + "patternId": "circle", + "rotation": 180, + "x": 4, + "y": 3 + }, + { + "patternId": "H", + "rotation": 180, + "x": 5, + "y": 3 + }, + { + "patternId": "circle", + "rotation": 180, + "x": 4, + "y": 3 + }, + { + "patternId": "W", + "rotation": 180, + "x": 4, + "y": 4 + }, + { + "patternId": "2", + "rotation": 270, + "x": 3, + "y": 4 + }, + { + "patternId": "circle", + "rotation": 270, + "x": 3, + "y": 3 + }, + { + "patternId": "K", + "rotation": 270, + "x": 2, + "y": 3 + }, + { + "patternId": "arrow_left", + "rotation": 90, + "x": 1, + "y": 3 + } + ], + "slot_sequence": [ + "FRONT", + "LEFT", + "TOP", + "FRONT", + "TOP", + "RIGHT", + "BACK", + "TOP", + "LEFT", + "BOTTOM" + ], + "required_slots": [ + "FRONT", + "LEFT", + "TOP", + "RIGHT", + "BACK", + "BOTTOM" + ], + "required_count": 6, + "answer": { + "faces": { + "TOP": { + "patternId": "circle", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + }, + "FRONT": { + "patternId": "H", + "rotation": 270 + }, + "BACK": { + "patternId": "2", + "rotation": 270 + }, + "LEFT": { + "patternId": "K", + "rotation": 270 + }, + "RIGHT": { + "patternId": "W", + "rotation": 270 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "circle", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + }, + "FRONT": { + "patternId": "H", + "rotation": 270 + }, + "BACK": { + "patternId": "2", + "rotation": 270 + }, + "LEFT": { + "patternId": "K", + "rotation": 270 + }, + "RIGHT": { + "patternId": "W", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C486\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): S -> W -> S -> E -> W -> S -> W -> N -> W -> W\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=H, rotation=270, flipVertical=true\n- step 2: patternId=K, rotation=180, flipVertical=true\n- step 3: patternId=circle, rotation=180, flipVertical=true\n- step 4: patternId=H, rotation=180, flipVertical=true\n- step 5: patternId=circle, rotation=180, flipVertical=true\n- step 6: patternId=W, rotation=180, flipVertical=true\n- step 7: patternId=2, rotation=270, flipVertical=true\n- step 8: patternId=circle, rotation=270, flipVertical=true\n- step 9: patternId=K, rotation=270, flipVertical=true\n- step 10: patternId=arrow_left, rotation=90, flipVertical=true\n- allowed patternId values for this task: H, K, circle, W, 2, arrow_left, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C487.json b/cube1/data/C487.json new file mode 100644 index 0000000000000000000000000000000000000000..b235d4f6f1b89f5ffb8f34c9d6ebacf97b0d3661 --- /dev/null +++ b/cube1/data/C487.json @@ -0,0 +1,315 @@ +{ + "sample_id": "C487", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: S -> E -> S -> E -> N -> N -> N -> S -> N -> N\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "S", + "E", + "S", + "E", + "N", + "N", + "N", + "S", + "N", + "N" + ], + "observed_path_faces": [ + { + "patternId": "E", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C487_path_sequence.png" + }, + "metadata": { + "level_id": 487, + "name": "Reconstruct 487", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-487.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "arrow_right", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "E", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "D", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "D", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "6", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "arrow_right", + "E", + "D", + "arrow_up", + "D", + "6" + ], + "start_x": 1, + "start_y": 3, + "grid_width": 5, + "grid_height": 7, + "true_solution_faces": { + "TOP": { + "patternId": "arrow_right", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "6", + "rotation": 270 + }, + "FRONT": { + "patternId": "E", + "rotation": 90 + }, + "BACK": { + "patternId": "arrow_up", + "rotation": 180 + }, + "LEFT": { + "patternId": "D", + "rotation": 270 + }, + "RIGHT": { + "patternId": "D", + "rotation": 270 + } + }, + "bottom_faces": [ + { + "patternId": "6", + "rotation": 270, + "x": 1, + "y": 3 + }, + { + "patternId": "E", + "rotation": 90, + "x": 1, + "y": 4 + }, + { + "patternId": "D", + "rotation": 270, + "x": 2, + "y": 4 + }, + { + "patternId": "arrow_right", + "rotation": 180, + "x": 2, + "y": 5 + }, + { + "patternId": "arrow_up", + "rotation": 90, + "x": 3, + "y": 5 + }, + { + "patternId": "D", + "rotation": 180, + "x": 3, + "y": 4 + }, + { + "patternId": "E", + "rotation": 0, + "x": 3, + "y": 3 + }, + { + "patternId": "D", + "rotation": 180, + "x": 3, + "y": 2 + }, + { + "patternId": "E", + "rotation": 0, + "x": 3, + "y": 3 + }, + { + "patternId": "D", + "rotation": 180, + "x": 3, + "y": 2 + }, + { + "patternId": "arrow_up", + "rotation": 90, + "x": 3, + "y": 1 + } + ], + "slot_sequence": [ + "FRONT", + "RIGHT", + "TOP", + "BACK", + "RIGHT", + "FRONT", + "LEFT", + "FRONT", + "LEFT", + "BACK" + ], + "required_slots": [ + "FRONT", + "RIGHT", + "TOP", + "BACK", + "LEFT" + ], + "required_count": 5, + "answer": { + "faces": { + "TOP": { + "patternId": "arrow_right", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "E", + "rotation": 90 + }, + "BACK": { + "patternId": "arrow_up", + "rotation": 0 + }, + "LEFT": { + "patternId": "D", + "rotation": 0 + }, + "RIGHT": { + "patternId": "D", + "rotation": 180 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "arrow_right", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "E", + "rotation": 90 + }, + "BACK": { + "patternId": "arrow_up", + "rotation": 0 + }, + "LEFT": { + "patternId": "D", + "rotation": 0 + }, + "RIGHT": { + "patternId": "D", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C487\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): S -> E -> S -> E -> N -> N -> N -> S -> N -> N\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=E, rotation=90, flipVertical=true\n- step 2: patternId=D, rotation=270, flipVertical=true\n- step 3: patternId=arrow_right, rotation=180, flipVertical=true\n- step 4: patternId=arrow_up, rotation=90, flipVertical=true\n- step 5: patternId=D, rotation=180, flipVertical=true\n- step 6: patternId=E, rotation=0, flipVertical=true\n- step 7: patternId=D, rotation=180, flipVertical=true\n- step 8: patternId=E, rotation=0, flipVertical=true\n- step 9: patternId=D, rotation=180, flipVertical=true\n- step 10: patternId=arrow_up, rotation=90, flipVertical=true\n- allowed patternId values for this task: E, D, arrow_right, arrow_up, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C488.json b/cube1/data/C488.json new file mode 100644 index 0000000000000000000000000000000000000000..9de908e13fdaf77a695505f6a48f6231ae2cf4d2 --- /dev/null +++ b/cube1/data/C488.json @@ -0,0 +1,315 @@ +{ + "sample_id": "C488", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: N -> W -> S -> S -> S -> E -> S -> E -> N -> N\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "N", + "W", + "S", + "S", + "S", + "E", + "S", + "E", + "N", + "N" + ], + "observed_path_faces": [ + { + "patternId": "M", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Y", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Y", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C488_path_sequence.png" + }, + "metadata": { + "level_id": 488, + "name": "Reconstruct 488", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-488.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "Y", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_down", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "M", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "M", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "Q", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "Y", + "arrow_down", + "M", + "M", + "Q", + "X" + ], + "start_x": 2, + "start_y": 2, + "grid_width": 5, + "grid_height": 7, + "true_solution_faces": { + "TOP": { + "patternId": "Y", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "X", + "rotation": 0 + }, + "FRONT": { + "patternId": "arrow_down", + "rotation": 0 + }, + "BACK": { + "patternId": "M", + "rotation": 180 + }, + "LEFT": { + "patternId": "Q", + "rotation": 0 + }, + "RIGHT": { + "patternId": "M", + "rotation": 270 + } + }, + "bottom_faces": [ + { + "patternId": "X", + "rotation": 0, + "x": 2, + "y": 2 + }, + { + "patternId": "M", + "rotation": 0, + "x": 2, + "y": 1 + }, + { + "patternId": "Q", + "rotation": 180, + "x": 1, + "y": 1 + }, + { + "patternId": "X", + "rotation": 270, + "x": 1, + "y": 2 + }, + { + "patternId": "M", + "rotation": 270, + "x": 1, + "y": 3 + }, + { + "patternId": "Y", + "rotation": 90, + "x": 1, + "y": 4 + }, + { + "patternId": "M", + "rotation": 90, + "x": 2, + "y": 4 + }, + { + "patternId": "Q", + "rotation": 270, + "x": 2, + "y": 5 + }, + { + "patternId": "X", + "rotation": 0, + "x": 3, + "y": 5 + }, + { + "patternId": "M", + "rotation": 0, + "x": 3, + "y": 4 + }, + { + "patternId": "Y", + "rotation": 0, + "x": 3, + "y": 3 + } + ], + "slot_sequence": [ + "BACK", + "LEFT", + "BOTTOM", + "RIGHT", + "TOP", + "BACK", + "LEFT", + "BOTTOM", + "BACK", + "TOP" + ], + "required_slots": [ + "BACK", + "LEFT", + "BOTTOM", + "RIGHT", + "TOP" + ], + "required_count": 5, + "answer": { + "faces": { + "TOP": { + "patternId": "Y", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "X", + "rotation": 0 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "M", + "rotation": 0 + }, + "LEFT": { + "patternId": "Q", + "rotation": 90 + }, + "RIGHT": { + "patternId": "M", + "rotation": 180 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "Y", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "X", + "rotation": 0 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "M", + "rotation": 0 + }, + "LEFT": { + "patternId": "Q", + "rotation": 90 + }, + "RIGHT": { + "patternId": "M", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C488\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): N -> W -> S -> S -> S -> E -> S -> E -> N -> N\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=M, rotation=0, flipVertical=true\n- step 2: patternId=Q, rotation=180, flipVertical=true\n- step 3: patternId=X, rotation=270, flipVertical=true\n- step 4: patternId=M, rotation=270, flipVertical=true\n- step 5: patternId=Y, rotation=90, flipVertical=true\n- step 6: patternId=M, rotation=90, flipVertical=true\n- step 7: patternId=Q, rotation=270, flipVertical=true\n- step 8: patternId=X, rotation=0, flipVertical=true\n- step 9: patternId=M, rotation=0, flipVertical=true\n- step 10: patternId=Y, rotation=0, flipVertical=true\n- allowed patternId values for this task: M, Q, X, Y, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C489.json b/cube1/data/C489.json new file mode 100644 index 0000000000000000000000000000000000000000..418e64616fd1c3922bb1b4a684eee23aee1860f5 --- /dev/null +++ b/cube1/data/C489.json @@ -0,0 +1,315 @@ +{ + "sample_id": "C489", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: N -> N -> E -> S -> E -> N -> W -> W -> S -> S\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "N", + "N", + "E", + "S", + "E", + "N", + "W", + "W", + "S", + "S" + ], + "observed_path_faces": [ + { + "patternId": "diamond", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C489_path_sequence.png" + }, + "metadata": { + "level_id": 489, + "name": "Reconstruct 489", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-489.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "smile", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "diamond", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "M", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "diamond", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "6", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "smile", + "diamond", + "M", + "diamond", + "X", + "6" + ], + "start_x": 1, + "start_y": 3, + "grid_width": 5, + "grid_height": 5, + "true_solution_faces": { + "TOP": { + "patternId": "smile", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "6", + "rotation": 270 + }, + "FRONT": { + "patternId": "diamond", + "rotation": 270 + }, + "BACK": { + "patternId": "diamond", + "rotation": 180 + }, + "LEFT": { + "patternId": "X", + "rotation": 270 + }, + "RIGHT": { + "patternId": "M", + "rotation": 180 + } + }, + "bottom_faces": [ + { + "patternId": "6", + "rotation": 270, + "x": 1, + "y": 3 + }, + { + "patternId": "diamond", + "rotation": 0, + "x": 1, + "y": 2 + }, + { + "patternId": "smile", + "rotation": 0, + "x": 1, + "y": 1 + }, + { + "patternId": "M", + "rotation": 90, + "x": 2, + "y": 1 + }, + { + "patternId": "diamond", + "rotation": 90, + "x": 2, + "y": 2 + }, + { + "patternId": "6", + "rotation": 0, + "x": 3, + "y": 2 + }, + { + "patternId": "M", + "rotation": 0, + "x": 3, + "y": 1 + }, + { + "patternId": "diamond", + "rotation": 0, + "x": 2, + "y": 1 + }, + { + "patternId": "X", + "rotation": 90, + "x": 1, + "y": 1 + }, + { + "patternId": "6", + "rotation": 180, + "x": 1, + "y": 2 + }, + { + "patternId": "M", + "rotation": 180, + "x": 1, + "y": 3 + } + ], + "slot_sequence": [ + "BACK", + "TOP", + "RIGHT", + "BACK", + "BOTTOM", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM", + "RIGHT" + ], + "required_slots": [ + "BACK", + "TOP", + "RIGHT", + "BOTTOM", + "LEFT" + ], + "required_count": 5, + "answer": { + "faces": { + "TOP": { + "patternId": "smile", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "6", + "rotation": 270 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "diamond", + "rotation": 0 + }, + "LEFT": { + "patternId": "X", + "rotation": 0 + }, + "RIGHT": { + "patternId": "M", + "rotation": 90 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "smile", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "6", + "rotation": 270 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "diamond", + "rotation": 0 + }, + "LEFT": { + "patternId": "X", + "rotation": 0 + }, + "RIGHT": { + "patternId": "M", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C489\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): N -> N -> E -> S -> E -> N -> W -> W -> S -> S\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=diamond, rotation=0, flipVertical=true\n- step 2: patternId=smile, rotation=0, flipVertical=true\n- step 3: patternId=M, rotation=90, flipVertical=true\n- step 4: patternId=diamond, rotation=90, flipVertical=true\n- step 5: patternId=6, rotation=0, flipVertical=true\n- step 6: patternId=M, rotation=0, flipVertical=true\n- step 7: patternId=diamond, rotation=0, flipVertical=true\n- step 8: patternId=X, rotation=90, flipVertical=true\n- step 9: patternId=6, rotation=180, flipVertical=true\n- step 10: patternId=M, rotation=180, flipVertical=true\n- allowed patternId values for this task: diamond, smile, M, 6, X, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C490.json b/cube1/data/C490.json new file mode 100644 index 0000000000000000000000000000000000000000..1f687c923e73faf57b02a5965674e9f485bc9a23 --- /dev/null +++ b/cube1/data/C490.json @@ -0,0 +1,316 @@ +{ + "sample_id": "C490", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: N -> E -> W -> S -> W -> N -> W -> N -> W -> S\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "N", + "E", + "W", + "S", + "W", + "N", + "W", + "N", + "W", + "S" + ], + "observed_path_faces": [ + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C490_path_sequence.png" + }, + "metadata": { + "level_id": 490, + "name": "Reconstruct 490", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-490.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "E", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "S", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "N", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "5", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "2", + "E", + "S", + "Z", + "N", + "5" + ], + "start_x": 4, + "start_y": 3, + "grid_width": 7, + "grid_height": 5, + "true_solution_faces": { + "TOP": { + "patternId": "2", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "E", + "rotation": 0 + }, + "BACK": { + "patternId": "Z", + "rotation": 270 + }, + "LEFT": { + "patternId": "N", + "rotation": 90 + }, + "RIGHT": { + "patternId": "S", + "rotation": 180 + } + }, + "bottom_faces": [ + { + "patternId": "5", + "rotation": 90, + "x": 4, + "y": 3 + }, + { + "patternId": "Z", + "rotation": 90, + "x": 4, + "y": 2 + }, + { + "patternId": "S", + "rotation": 0, + "x": 5, + "y": 2 + }, + { + "patternId": "Z", + "rotation": 90, + "x": 4, + "y": 2 + }, + { + "patternId": "5", + "rotation": 90, + "x": 4, + "y": 3 + }, + { + "patternId": "N", + "rotation": 0, + "x": 3, + "y": 3 + }, + { + "patternId": "Z", + "rotation": 180, + "x": 3, + "y": 2 + }, + { + "patternId": "2", + "rotation": 0, + "x": 2, + "y": 2 + }, + { + "patternId": "S", + "rotation": 180, + "x": 2, + "y": 1 + }, + { + "patternId": "E", + "rotation": 0, + "x": 1, + "y": 1 + }, + { + "patternId": "2", + "rotation": 270, + "x": 1, + "y": 2 + } + ], + "slot_sequence": [ + "BACK", + "RIGHT", + "BACK", + "BOTTOM", + "LEFT", + "BACK", + "TOP", + "RIGHT", + "FRONT", + "TOP" + ], + "required_slots": [ + "BACK", + "RIGHT", + "BOTTOM", + "LEFT", + "TOP", + "FRONT" + ], + "required_count": 6, + "answer": { + "faces": { + "TOP": { + "patternId": "2", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "E", + "rotation": 0 + }, + "BACK": { + "patternId": "Z", + "rotation": 90 + }, + "LEFT": { + "patternId": "N", + "rotation": 180 + }, + "RIGHT": { + "patternId": "S", + "rotation": 90 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "2", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "E", + "rotation": 0 + }, + "BACK": { + "patternId": "Z", + "rotation": 90 + }, + "LEFT": { + "patternId": "N", + "rotation": 180 + }, + "RIGHT": { + "patternId": "S", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C490\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): N -> E -> W -> S -> W -> N -> W -> N -> W -> S\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=Z, rotation=90, flipVertical=true\n- step 2: patternId=S, rotation=0, flipVertical=true\n- step 3: patternId=Z, rotation=90, flipVertical=true\n- step 4: patternId=5, rotation=90, flipVertical=true\n- step 5: patternId=N, rotation=0, flipVertical=true\n- step 6: patternId=Z, rotation=180, flipVertical=true\n- step 7: patternId=2, rotation=0, flipVertical=true\n- step 8: patternId=S, rotation=180, flipVertical=true\n- step 9: patternId=E, rotation=0, flipVertical=true\n- step 10: patternId=2, rotation=270, flipVertical=true\n- allowed patternId values for this task: Z, S, 5, N, 2, E, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C491.json b/cube1/data/C491.json new file mode 100644 index 0000000000000000000000000000000000000000..84929f9a5feec50c74e8afaf847c6f06e477d476 --- /dev/null +++ b/cube1/data/C491.json @@ -0,0 +1,315 @@ +{ + "sample_id": "C491", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: E -> E -> W -> W -> N -> W -> N -> E -> E -> S\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "E", + "E", + "W", + "W", + "N", + "W", + "N", + "E", + "E", + "S" + ], + "observed_path_faces": [ + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C491_path_sequence.png" + }, + "metadata": { + "level_id": 491, + "name": "Reconstruct 491", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-491.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "4", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "U", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "B", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "Z", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_left", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "4", + "U", + "X", + "B", + "Z", + "arrow_left" + ], + "start_x": 2, + "start_y": 3, + "grid_width": 6, + "grid_height": 5, + "true_solution_faces": { + "TOP": { + "patternId": "4", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 180 + }, + "FRONT": { + "patternId": "U", + "rotation": 0 + }, + "BACK": { + "patternId": "B", + "rotation": 180 + }, + "LEFT": { + "patternId": "Z", + "rotation": 180 + }, + "RIGHT": { + "patternId": "X", + "rotation": 90 + } + }, + "bottom_faces": [ + { + "patternId": "arrow_left", + "rotation": 180, + "x": 2, + "y": 3 + }, + { + "patternId": "X", + "rotation": 180, + "x": 3, + "y": 3 + }, + { + "patternId": "4", + "rotation": 90, + "x": 4, + "y": 3 + }, + { + "patternId": "X", + "rotation": 180, + "x": 3, + "y": 3 + }, + { + "patternId": "arrow_left", + "rotation": 180, + "x": 2, + "y": 3 + }, + { + "patternId": "B", + "rotation": 0, + "x": 2, + "y": 2 + }, + { + "patternId": "Z", + "rotation": 0, + "x": 1, + "y": 2 + }, + { + "patternId": "4", + "rotation": 0, + "x": 1, + "y": 1 + }, + { + "patternId": "B", + "rotation": 90, + "x": 2, + "y": 1 + }, + { + "patternId": "arrow_left", + "rotation": 270, + "x": 3, + "y": 1 + }, + { + "patternId": "Z", + "rotation": 180, + "x": 3, + "y": 2 + } + ], + "slot_sequence": [ + "RIGHT", + "TOP", + "RIGHT", + "BOTTOM", + "BACK", + "LEFT", + "TOP", + "BACK", + "BOTTOM", + "LEFT" + ], + "required_slots": [ + "RIGHT", + "TOP", + "BOTTOM", + "BACK", + "LEFT" + ], + "required_count": 5, + "answer": { + "faces": { + "TOP": { + "patternId": "4", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 180 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "B", + "rotation": 0 + }, + "LEFT": { + "patternId": "Z", + "rotation": 270 + }, + "RIGHT": { + "patternId": "X", + "rotation": 0 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "4", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 180 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "B", + "rotation": 0 + }, + "LEFT": { + "patternId": "Z", + "rotation": 270 + }, + "RIGHT": { + "patternId": "X", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C491\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): E -> E -> W -> W -> N -> W -> N -> E -> E -> S\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=X, rotation=180, flipVertical=true\n- step 2: patternId=4, rotation=90, flipVertical=true\n- step 3: patternId=X, rotation=180, flipVertical=true\n- step 4: patternId=arrow_left, rotation=180, flipVertical=true\n- step 5: patternId=B, rotation=0, flipVertical=true\n- step 6: patternId=Z, rotation=0, flipVertical=true\n- step 7: patternId=4, rotation=0, flipVertical=true\n- step 8: patternId=B, rotation=90, flipVertical=true\n- step 9: patternId=arrow_left, rotation=270, flipVertical=true\n- step 10: patternId=Z, rotation=180, flipVertical=true\n- allowed patternId values for this task: X, 4, arrow_left, B, Z, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C492.json b/cube1/data/C492.json new file mode 100644 index 0000000000000000000000000000000000000000..6cd7ea684931ab4c8572ba0da67cfc692200ae6d --- /dev/null +++ b/cube1/data/C492.json @@ -0,0 +1,315 @@ +{ + "sample_id": "C492", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: N -> W -> N -> N -> E -> E -> S -> E -> N -> N\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "N", + "W", + "N", + "N", + "E", + "E", + "S", + "E", + "N", + "N" + ], + "observed_path_faces": [ + { + "patternId": "F", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C492_path_sequence.png" + }, + "metadata": { + "level_id": 492, + "name": "Reconstruct 492", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-492.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "X", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "F", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "F", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "S", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "K", + "star", + "X", + "F", + "F", + "S" + ], + "start_x": 2, + "start_y": 5, + "grid_width": 6, + "grid_height": 7, + "true_solution_faces": { + "TOP": { + "patternId": "K", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "S", + "rotation": 270 + }, + "FRONT": { + "patternId": "star", + "rotation": 270 + }, + "BACK": { + "patternId": "F", + "rotation": 180 + }, + "LEFT": { + "patternId": "F", + "rotation": 90 + }, + "RIGHT": { + "patternId": "X", + "rotation": 0 + } + }, + "bottom_faces": [ + { + "patternId": "S", + "rotation": 270, + "x": 2, + "y": 5 + }, + { + "patternId": "F", + "rotation": 0, + "x": 2, + "y": 4 + }, + { + "patternId": "F", + "rotation": 270, + "x": 1, + "y": 4 + }, + { + "patternId": "K", + "rotation": 0, + "x": 1, + "y": 3 + }, + { + "patternId": "X", + "rotation": 0, + "x": 1, + "y": 2 + }, + { + "patternId": "F", + "rotation": 180, + "x": 2, + "y": 2 + }, + { + "patternId": "F", + "rotation": 90, + "x": 3, + "y": 2 + }, + { + "patternId": "K", + "rotation": 180, + "x": 3, + "y": 3 + }, + { + "patternId": "star", + "rotation": 180, + "x": 4, + "y": 3 + }, + { + "patternId": "F", + "rotation": 0, + "x": 4, + "y": 2 + }, + { + "patternId": "F", + "rotation": 90, + "x": 4, + "y": 1 + } + ], + "slot_sequence": [ + "BACK", + "LEFT", + "TOP", + "RIGHT", + "BACK", + "LEFT", + "TOP", + "FRONT", + "LEFT", + "BACK" + ], + "required_slots": [ + "BACK", + "LEFT", + "TOP", + "RIGHT", + "FRONT" + ], + "required_count": 5, + "answer": { + "faces": { + "TOP": { + "patternId": "K", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "star", + "rotation": 270 + }, + "BACK": { + "patternId": "F", + "rotation": 0 + }, + "LEFT": { + "patternId": "F", + "rotation": 180 + }, + "RIGHT": { + "patternId": "X", + "rotation": 270 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "K", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "star", + "rotation": 270 + }, + "BACK": { + "patternId": "F", + "rotation": 0 + }, + "LEFT": { + "patternId": "F", + "rotation": 180 + }, + "RIGHT": { + "patternId": "X", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C492\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): N -> W -> N -> N -> E -> E -> S -> E -> N -> N\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=F, rotation=0, flipVertical=true\n- step 2: patternId=F, rotation=270, flipVertical=true\n- step 3: patternId=K, rotation=0, flipVertical=true\n- step 4: patternId=X, rotation=0, flipVertical=true\n- step 5: patternId=F, rotation=180, flipVertical=true\n- step 6: patternId=F, rotation=90, flipVertical=true\n- step 7: patternId=K, rotation=180, flipVertical=true\n- step 8: patternId=star, rotation=180, flipVertical=true\n- step 9: patternId=F, rotation=0, flipVertical=true\n- step 10: patternId=F, rotation=90, flipVertical=true\n- allowed patternId values for this task: F, K, X, star, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C493.json b/cube1/data/C493.json new file mode 100644 index 0000000000000000000000000000000000000000..1a92b00ad452103539c79e6e71e4492be54ea34f --- /dev/null +++ b/cube1/data/C493.json @@ -0,0 +1,315 @@ +{ + "sample_id": "C493", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: E -> N -> N -> N -> S -> E -> S -> W -> W -> N\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "E", + "N", + "N", + "N", + "S", + "E", + "S", + "W", + "W", + "N" + ], + "observed_path_faces": [ + { + "patternId": "arrow_up", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C493_path_sequence.png" + }, + "metadata": { + "level_id": 493, + "name": "Reconstruct 493", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-493.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "5", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "B", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "W", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "star", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "5", + "B", + "arrow_up", + "W", + "star", + "X" + ], + "start_x": 1, + "start_y": 4, + "grid_width": 5, + "grid_height": 6, + "true_solution_faces": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "X", + "rotation": 0 + }, + "FRONT": { + "patternId": "B", + "rotation": 270 + }, + "BACK": { + "patternId": "W", + "rotation": 0 + }, + "LEFT": { + "patternId": "star", + "rotation": 0 + }, + "RIGHT": { + "patternId": "arrow_up", + "rotation": 90 + } + }, + "bottom_faces": [ + { + "patternId": "X", + "rotation": 0, + "x": 1, + "y": 4 + }, + { + "patternId": "arrow_up", + "rotation": 180, + "x": 2, + "y": 4 + }, + { + "patternId": "W", + "rotation": 90, + "x": 2, + "y": 3 + }, + { + "patternId": "star", + "rotation": 90, + "x": 2, + "y": 2 + }, + { + "patternId": "B", + "rotation": 0, + "x": 2, + "y": 1 + }, + { + "patternId": "star", + "rotation": 90, + "x": 2, + "y": 2 + }, + { + "patternId": "5", + "rotation": 90, + "x": 3, + "y": 2 + }, + { + "patternId": "W", + "rotation": 180, + "x": 3, + "y": 3 + }, + { + "patternId": "star", + "rotation": 180, + "x": 2, + "y": 3 + }, + { + "patternId": "B", + "rotation": 90, + "x": 1, + "y": 3 + }, + { + "patternId": "5", + "rotation": 270, + "x": 1, + "y": 2 + } + ], + "slot_sequence": [ + "RIGHT", + "BACK", + "LEFT", + "FRONT", + "LEFT", + "TOP", + "BACK", + "LEFT", + "FRONT", + "TOP" + ], + "required_slots": [ + "RIGHT", + "BACK", + "LEFT", + "FRONT", + "TOP" + ], + "required_count": 5, + "answer": { + "faces": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "B", + "rotation": 270 + }, + "BACK": { + "patternId": "W", + "rotation": 180 + }, + "LEFT": { + "patternId": "star", + "rotation": 90 + }, + "RIGHT": { + "patternId": "arrow_up", + "rotation": 0 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "B", + "rotation": 270 + }, + "BACK": { + "patternId": "W", + "rotation": 180 + }, + "LEFT": { + "patternId": "star", + "rotation": 90 + }, + "RIGHT": { + "patternId": "arrow_up", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C493\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): E -> N -> N -> N -> S -> E -> S -> W -> W -> N\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=arrow_up, rotation=180, flipVertical=true\n- step 2: patternId=W, rotation=90, flipVertical=true\n- step 3: patternId=star, rotation=90, flipVertical=true\n- step 4: patternId=B, rotation=0, flipVertical=true\n- step 5: patternId=star, rotation=90, flipVertical=true\n- step 6: patternId=5, rotation=90, flipVertical=true\n- step 7: patternId=W, rotation=180, flipVertical=true\n- step 8: patternId=star, rotation=180, flipVertical=true\n- step 9: patternId=B, rotation=90, flipVertical=true\n- step 10: patternId=5, rotation=270, flipVertical=true\n- allowed patternId values for this task: arrow_up, W, star, B, 5, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C494.json b/cube1/data/C494.json new file mode 100644 index 0000000000000000000000000000000000000000..19a4eb6f90f10fdd28f3b67f2339fc8dfa72d69c --- /dev/null +++ b/cube1/data/C494.json @@ -0,0 +1,314 @@ +{ + "sample_id": "C494", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: W -> S -> S -> N -> N -> E -> S -> E -> W -> N\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "W", + "S", + "S", + "N", + "N", + "E", + "S", + "E", + "W", + "N" + ], + "observed_path_faces": [ + { + "patternId": "T", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "plus", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "T", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "plus", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C494_path_sequence.png" + }, + "metadata": { + "level_id": 494, + "name": "Reconstruct 494", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-494.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "C", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "S", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "plus", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "W", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "T", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "C", + "S", + "plus", + "W", + "T", + "smile" + ], + "start_x": 2, + "start_y": 1, + "grid_width": 5, + "grid_height": 5, + "true_solution_faces": { + "TOP": { + "patternId": "C", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "smile", + "rotation": 180 + }, + "FRONT": { + "patternId": "S", + "rotation": 180 + }, + "BACK": { + "patternId": "W", + "rotation": 90 + }, + "LEFT": { + "patternId": "T", + "rotation": 270 + }, + "RIGHT": { + "patternId": "plus", + "rotation": 0 + } + }, + "bottom_faces": [ + { + "patternId": "smile", + "rotation": 180, + "x": 2, + "y": 1 + }, + { + "patternId": "T", + "rotation": 180, + "x": 1, + "y": 1 + }, + { + "patternId": "S", + "rotation": 90, + "x": 1, + "y": 2 + }, + { + "patternId": "plus", + "rotation": 270, + "x": 1, + "y": 3 + }, + { + "patternId": "S", + "rotation": 90, + "x": 1, + "y": 2 + }, + { + "patternId": "T", + "rotation": 180, + "x": 1, + "y": 1 + }, + { + "patternId": "smile", + "rotation": 180, + "x": 2, + "y": 1 + }, + { + "patternId": "S", + "rotation": 180, + "x": 2, + "y": 2 + }, + { + "patternId": "plus", + "rotation": 0, + "x": 3, + "y": 2 + }, + { + "patternId": "S", + "rotation": 180, + "x": 2, + "y": 2 + }, + { + "patternId": "smile", + "rotation": 180, + "x": 2, + "y": 1 + } + ], + "slot_sequence": [ + "LEFT", + "FRONT", + "RIGHT", + "FRONT", + "LEFT", + "BOTTOM", + "FRONT", + "RIGHT", + "FRONT", + "BOTTOM" + ], + "required_slots": [ + "LEFT", + "FRONT", + "RIGHT", + "BOTTOM" + ], + "required_count": 4, + "answer": { + "faces": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "smile", + "rotation": 180 + }, + "FRONT": { + "patternId": "S", + "rotation": 180 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "T", + "rotation": 0 + }, + "RIGHT": { + "patternId": "plus", + "rotation": 270 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "smile", + "rotation": 180 + }, + "FRONT": { + "patternId": "S", + "rotation": 180 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "T", + "rotation": 0 + }, + "RIGHT": { + "patternId": "plus", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C494\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): W -> S -> S -> N -> N -> E -> S -> E -> W -> N\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=T, rotation=180, flipVertical=true\n- step 2: patternId=S, rotation=90, flipVertical=true\n- step 3: patternId=plus, rotation=270, flipVertical=true\n- step 4: patternId=S, rotation=90, flipVertical=true\n- step 5: patternId=T, rotation=180, flipVertical=true\n- step 6: patternId=smile, rotation=180, flipVertical=true\n- step 7: patternId=S, rotation=180, flipVertical=true\n- step 8: patternId=plus, rotation=0, flipVertical=true\n- step 9: patternId=S, rotation=180, flipVertical=true\n- step 10: patternId=smile, rotation=180, flipVertical=true\n- allowed patternId values for this task: T, S, plus, smile, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C495.json b/cube1/data/C495.json new file mode 100644 index 0000000000000000000000000000000000000000..f17cc9df711ff52afcf519f1602c705b4178670d --- /dev/null +++ b/cube1/data/C495.json @@ -0,0 +1,316 @@ +{ + "sample_id": "C495", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: N -> N -> S -> W -> S -> S -> N -> W -> N -> W\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "N", + "N", + "S", + "W", + "S", + "S", + "N", + "W", + "N", + "W" + ], + "observed_path_faces": [ + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C495_path_sequence.png" + }, + "metadata": { + "level_id": 495, + "name": "Reconstruct 495", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-495.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "S", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "heart", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "circle", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "R", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "K", + "S", + "heart", + "X", + "circle", + "R" + ], + "start_x": 4, + "start_y": 3, + "grid_width": 6, + "grid_height": 6, + "true_solution_faces": { + "TOP": { + "patternId": "K", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "R", + "rotation": 270 + }, + "FRONT": { + "patternId": "S", + "rotation": 90 + }, + "BACK": { + "patternId": "X", + "rotation": 180 + }, + "LEFT": { + "patternId": "circle", + "rotation": 270 + }, + "RIGHT": { + "patternId": "heart", + "rotation": 270 + } + }, + "bottom_faces": [ + { + "patternId": "R", + "rotation": 270, + "x": 4, + "y": 3 + }, + { + "patternId": "X", + "rotation": 0, + "x": 4, + "y": 2 + }, + { + "patternId": "K", + "rotation": 270, + "x": 4, + "y": 1 + }, + { + "patternId": "X", + "rotation": 0, + "x": 4, + "y": 2 + }, + { + "patternId": "circle", + "rotation": 90, + "x": 3, + "y": 2 + }, + { + "patternId": "R", + "rotation": 180, + "x": 3, + "y": 3 + }, + { + "patternId": "heart", + "rotation": 270, + "x": 3, + "y": 4 + }, + { + "patternId": "R", + "rotation": 180, + "x": 3, + "y": 3 + }, + { + "patternId": "S", + "rotation": 0, + "x": 2, + "y": 3 + }, + { + "patternId": "circle", + "rotation": 180, + "x": 2, + "y": 2 + }, + { + "patternId": "K", + "rotation": 90, + "x": 1, + "y": 2 + } + ], + "slot_sequence": [ + "BACK", + "TOP", + "BACK", + "LEFT", + "BOTTOM", + "RIGHT", + "BOTTOM", + "FRONT", + "LEFT", + "TOP" + ], + "required_slots": [ + "BACK", + "TOP", + "LEFT", + "BOTTOM", + "RIGHT", + "FRONT" + ], + "required_count": 6, + "answer": { + "faces": { + "TOP": { + "patternId": "K", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "R", + "rotation": 270 + }, + "FRONT": { + "patternId": "S", + "rotation": 90 + }, + "BACK": { + "patternId": "X", + "rotation": 0 + }, + "LEFT": { + "patternId": "circle", + "rotation": 0 + }, + "RIGHT": { + "patternId": "heart", + "rotation": 180 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "K", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "R", + "rotation": 270 + }, + "FRONT": { + "patternId": "S", + "rotation": 90 + }, + "BACK": { + "patternId": "X", + "rotation": 0 + }, + "LEFT": { + "patternId": "circle", + "rotation": 0 + }, + "RIGHT": { + "patternId": "heart", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C495\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): N -> N -> S -> W -> S -> S -> N -> W -> N -> W\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=X, rotation=0, flipVertical=true\n- step 2: patternId=K, rotation=270, flipVertical=true\n- step 3: patternId=X, rotation=0, flipVertical=true\n- step 4: patternId=circle, rotation=90, flipVertical=true\n- step 5: patternId=R, rotation=180, flipVertical=true\n- step 6: patternId=heart, rotation=270, flipVertical=true\n- step 7: patternId=R, rotation=180, flipVertical=true\n- step 8: patternId=S, rotation=0, flipVertical=true\n- step 9: patternId=circle, rotation=180, flipVertical=true\n- step 10: patternId=K, rotation=90, flipVertical=true\n- allowed patternId values for this task: X, K, circle, R, heart, S, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C496.json b/cube1/data/C496.json new file mode 100644 index 0000000000000000000000000000000000000000..64ee3d920986e3fd482009edce3824af904daf5b --- /dev/null +++ b/cube1/data/C496.json @@ -0,0 +1,316 @@ +{ + "sample_id": "C496", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: E -> S -> S -> N -> N -> E -> N -> E -> N -> N\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "E", + "S", + "S", + "N", + "N", + "E", + "N", + "E", + "N", + "N" + ], + "observed_path_faces": [ + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C496_path_sequence.png" + }, + "metadata": { + "level_id": 496, + "name": "Reconstruct 496", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-496.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "Z", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "6", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "Z", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "2", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "1", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "G", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "Z", + "6", + "Z", + "2", + "1", + "G" + ], + "start_x": 1, + "start_y": 4, + "grid_width": 6, + "grid_height": 8, + "true_solution_faces": { + "TOP": { + "patternId": "Z", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 270 + }, + "FRONT": { + "patternId": "6", + "rotation": 180 + }, + "BACK": { + "patternId": "2", + "rotation": 270 + }, + "LEFT": { + "patternId": "1", + "rotation": 270 + }, + "RIGHT": { + "patternId": "Z", + "rotation": 90 + } + }, + "bottom_faces": [ + { + "patternId": "G", + "rotation": 270, + "x": 1, + "y": 4 + }, + { + "patternId": "Z", + "rotation": 180, + "x": 2, + "y": 4 + }, + { + "patternId": "6", + "rotation": 270, + "x": 2, + "y": 5 + }, + { + "patternId": "1", + "rotation": 0, + "x": 2, + "y": 6 + }, + { + "patternId": "6", + "rotation": 270, + "x": 2, + "y": 5 + }, + { + "patternId": "Z", + "rotation": 180, + "x": 2, + "y": 4 + }, + { + "patternId": "Z", + "rotation": 180, + "x": 3, + "y": 4 + }, + { + "patternId": "2", + "rotation": 270, + "x": 3, + "y": 3 + }, + { + "patternId": "1", + "rotation": 270, + "x": 4, + "y": 3 + }, + { + "patternId": "G", + "rotation": 0, + "x": 4, + "y": 2 + }, + { + "patternId": "Z", + "rotation": 270, + "x": 4, + "y": 1 + } + ], + "slot_sequence": [ + "RIGHT", + "FRONT", + "LEFT", + "FRONT", + "RIGHT", + "TOP", + "BACK", + "LEFT", + "BOTTOM", + "RIGHT" + ], + "required_slots": [ + "RIGHT", + "FRONT", + "LEFT", + "TOP", + "BACK", + "BOTTOM" + ], + "required_count": 6, + "answer": { + "faces": { + "TOP": { + "patternId": "Z", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 270 + }, + "FRONT": { + "patternId": "6", + "rotation": 180 + }, + "BACK": { + "patternId": "2", + "rotation": 90 + }, + "LEFT": { + "patternId": "1", + "rotation": 0 + }, + "RIGHT": { + "patternId": "Z", + "rotation": 0 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "Z", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 270 + }, + "FRONT": { + "patternId": "6", + "rotation": 180 + }, + "BACK": { + "patternId": "2", + "rotation": 90 + }, + "LEFT": { + "patternId": "1", + "rotation": 0 + }, + "RIGHT": { + "patternId": "Z", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C496\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): E -> S -> S -> N -> N -> E -> N -> E -> N -> N\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=Z, rotation=180, flipVertical=true\n- step 2: patternId=6, rotation=270, flipVertical=true\n- step 3: patternId=1, rotation=0, flipVertical=true\n- step 4: patternId=6, rotation=270, flipVertical=true\n- step 5: patternId=Z, rotation=180, flipVertical=true\n- step 6: patternId=Z, rotation=180, flipVertical=true\n- step 7: patternId=2, rotation=270, flipVertical=true\n- step 8: patternId=1, rotation=270, flipVertical=true\n- step 9: patternId=G, rotation=0, flipVertical=true\n- step 10: patternId=Z, rotation=270, flipVertical=true\n- allowed patternId values for this task: Z, 6, 1, 2, G, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C497.json b/cube1/data/C497.json new file mode 100644 index 0000000000000000000000000000000000000000..b01b36c82a054cac7809f81e6d1fa9be0d729006 --- /dev/null +++ b/cube1/data/C497.json @@ -0,0 +1,316 @@ +{ + "sample_id": "C497", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: S -> E -> N -> N -> W -> S -> W -> S -> W -> W\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "S", + "E", + "N", + "N", + "W", + "S", + "W", + "S", + "W", + "W" + ], + "observed_path_faces": [ + { + "patternId": "Z", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "3", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C497_path_sequence.png" + }, + "metadata": { + "level_id": 497, + "name": "Reconstruct 497", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-497.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "3", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "Z", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "2", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "F", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "4", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "2", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "3", + "Z", + "2", + "F", + "4", + "2" + ], + "start_x": 4, + "start_y": 2, + "grid_width": 7, + "grid_height": 5, + "true_solution_faces": { + "TOP": { + "patternId": "3", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "2", + "rotation": 0 + }, + "FRONT": { + "patternId": "Z", + "rotation": 0 + }, + "BACK": { + "patternId": "F", + "rotation": 0 + }, + "LEFT": { + "patternId": "4", + "rotation": 180 + }, + "RIGHT": { + "patternId": "2", + "rotation": 180 + } + }, + "bottom_faces": [ + { + "patternId": "2", + "rotation": 0, + "x": 4, + "y": 2 + }, + { + "patternId": "Z", + "rotation": 0, + "x": 4, + "y": 3 + }, + { + "patternId": "2", + "rotation": 180, + "x": 5, + "y": 3 + }, + { + "patternId": "2", + "rotation": 270, + "x": 5, + "y": 2 + }, + { + "patternId": "4", + "rotation": 0, + "x": 5, + "y": 1 + }, + { + "patternId": "Z", + "rotation": 180, + "x": 4, + "y": 1 + }, + { + "patternId": "2", + "rotation": 180, + "x": 4, + "y": 2 + }, + { + "patternId": "2", + "rotation": 90, + "x": 3, + "y": 2 + }, + { + "patternId": "F", + "rotation": 270, + "x": 3, + "y": 3 + }, + { + "patternId": "3", + "rotation": 0, + "x": 2, + "y": 3 + }, + { + "patternId": "Z", + "rotation": 90, + "x": 1, + "y": 3 + } + ], + "slot_sequence": [ + "FRONT", + "RIGHT", + "BOTTOM", + "LEFT", + "FRONT", + "BOTTOM", + "RIGHT", + "BACK", + "TOP", + "FRONT" + ], + "required_slots": [ + "FRONT", + "RIGHT", + "BOTTOM", + "LEFT", + "BACK", + "TOP" + ], + "required_count": 6, + "answer": { + "faces": { + "TOP": { + "patternId": "3", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "2", + "rotation": 0 + }, + "FRONT": { + "patternId": "Z", + "rotation": 0 + }, + "BACK": { + "patternId": "F", + "rotation": 180 + }, + "LEFT": { + "patternId": "4", + "rotation": 270 + }, + "RIGHT": { + "patternId": "2", + "rotation": 90 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "3", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "2", + "rotation": 0 + }, + "FRONT": { + "patternId": "Z", + "rotation": 0 + }, + "BACK": { + "patternId": "F", + "rotation": 180 + }, + "LEFT": { + "patternId": "4", + "rotation": 270 + }, + "RIGHT": { + "patternId": "2", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C497\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): S -> E -> N -> N -> W -> S -> W -> S -> W -> W\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=Z, rotation=0, flipVertical=true\n- step 2: patternId=2, rotation=180, flipVertical=true\n- step 3: patternId=2, rotation=270, flipVertical=true\n- step 4: patternId=4, rotation=0, flipVertical=true\n- step 5: patternId=Z, rotation=180, flipVertical=true\n- step 6: patternId=2, rotation=180, flipVertical=true\n- step 7: patternId=2, rotation=90, flipVertical=true\n- step 8: patternId=F, rotation=270, flipVertical=true\n- step 9: patternId=3, rotation=0, flipVertical=true\n- step 10: patternId=Z, rotation=90, flipVertical=true\n- allowed patternId values for this task: Z, 2, 4, F, 3, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C498.json b/cube1/data/C498.json new file mode 100644 index 0000000000000000000000000000000000000000..314626c1fc15dc6e60db82635a64ac7e2c07ac2f --- /dev/null +++ b/cube1/data/C498.json @@ -0,0 +1,316 @@ +{ + "sample_id": "C498", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: E -> S -> S -> S -> W -> E -> E -> S -> S -> N\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "E", + "S", + "S", + "S", + "W", + "E", + "E", + "S", + "S", + "N" + ], + "observed_path_faces": [ + { + "patternId": "circle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "J", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C498_path_sequence.png" + }, + "metadata": { + "level_id": 498, + "name": "Reconstruct 498", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-498.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "arrow_left", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "J", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "circle", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "heart", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "triangle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_up", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "arrow_left", + "J", + "circle", + "heart", + "triangle", + "arrow_up" + ], + "start_x": 1, + "start_y": 1, + "grid_width": 5, + "grid_height": 8, + "true_solution_faces": { + "TOP": { + "patternId": "arrow_left", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 90 + }, + "FRONT": { + "patternId": "J", + "rotation": 270 + }, + "BACK": { + "patternId": "heart", + "rotation": 0 + }, + "LEFT": { + "patternId": "triangle", + "rotation": 0 + }, + "RIGHT": { + "patternId": "circle", + "rotation": 90 + } + }, + "bottom_faces": [ + { + "patternId": "arrow_up", + "rotation": 90, + "x": 1, + "y": 1 + }, + { + "patternId": "circle", + "rotation": 180, + "x": 2, + "y": 1 + }, + { + "patternId": "J", + "rotation": 0, + "x": 2, + "y": 2 + }, + { + "patternId": "triangle", + "rotation": 90, + "x": 2, + "y": 3 + }, + { + "patternId": "heart", + "rotation": 90, + "x": 2, + "y": 4 + }, + { + "patternId": "arrow_up", + "rotation": 0, + "x": 1, + "y": 4 + }, + { + "patternId": "heart", + "rotation": 90, + "x": 2, + "y": 4 + }, + { + "patternId": "arrow_left", + "rotation": 0, + "x": 3, + "y": 4 + }, + { + "patternId": "circle", + "rotation": 270, + "x": 3, + "y": 5 + }, + { + "patternId": "arrow_up", + "rotation": 180, + "x": 3, + "y": 6 + }, + { + "patternId": "circle", + "rotation": 270, + "x": 3, + "y": 5 + } + ], + "slot_sequence": [ + "RIGHT", + "FRONT", + "LEFT", + "BACK", + "BOTTOM", + "BACK", + "TOP", + "RIGHT", + "BOTTOM", + "RIGHT" + ], + "required_slots": [ + "RIGHT", + "FRONT", + "LEFT", + "BACK", + "BOTTOM", + "TOP" + ], + "required_count": 6, + "answer": { + "faces": { + "TOP": { + "patternId": "arrow_left", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 90 + }, + "FRONT": { + "patternId": "J", + "rotation": 270 + }, + "BACK": { + "patternId": "heart", + "rotation": 180 + }, + "LEFT": { + "patternId": "triangle", + "rotation": 90 + }, + "RIGHT": { + "patternId": "circle", + "rotation": 0 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "arrow_left", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 90 + }, + "FRONT": { + "patternId": "J", + "rotation": 270 + }, + "BACK": { + "patternId": "heart", + "rotation": 180 + }, + "LEFT": { + "patternId": "triangle", + "rotation": 90 + }, + "RIGHT": { + "patternId": "circle", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C498\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): E -> S -> S -> S -> W -> E -> E -> S -> S -> N\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=circle, rotation=180, flipVertical=true\n- step 2: patternId=J, rotation=0, flipVertical=true\n- step 3: patternId=triangle, rotation=90, flipVertical=true\n- step 4: patternId=heart, rotation=90, flipVertical=true\n- step 5: patternId=arrow_up, rotation=0, flipVertical=true\n- step 6: patternId=heart, rotation=90, flipVertical=true\n- step 7: patternId=arrow_left, rotation=0, flipVertical=true\n- step 8: patternId=circle, rotation=270, flipVertical=true\n- step 9: patternId=arrow_up, rotation=180, flipVertical=true\n- step 10: patternId=circle, rotation=270, flipVertical=true\n- allowed patternId values for this task: circle, J, triangle, heart, arrow_up, arrow_left, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C499.json b/cube1/data/C499.json new file mode 100644 index 0000000000000000000000000000000000000000..24ff4a4abab819a44e115328e936aceba7f64219 --- /dev/null +++ b/cube1/data/C499.json @@ -0,0 +1,315 @@ +{ + "sample_id": "C499", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: E -> E -> S -> W -> S -> E -> N -> E -> E -> S\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "E", + "E", + "S", + "W", + "S", + "E", + "N", + "E", + "E", + "S" + ], + "observed_path_faces": [ + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C499_path_sequence.png" + }, + "metadata": { + "level_id": 499, + "name": "Reconstruct 499", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-499.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "S", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "smile", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "2", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_left", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "4", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "square", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "S", + "smile", + "2", + "arrow_left", + "4", + "square" + ], + "start_x": 1, + "start_y": 1, + "grid_width": 7, + "grid_height": 5, + "true_solution_faces": { + "TOP": { + "patternId": "S", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 90 + }, + "FRONT": { + "patternId": "smile", + "rotation": 0 + }, + "BACK": { + "patternId": "arrow_left", + "rotation": 270 + }, + "LEFT": { + "patternId": "4", + "rotation": 90 + }, + "RIGHT": { + "patternId": "2", + "rotation": 180 + } + }, + "bottom_faces": [ + { + "patternId": "square", + "rotation": 90, + "x": 1, + "y": 1 + }, + { + "patternId": "2", + "rotation": 270, + "x": 2, + "y": 1 + }, + { + "patternId": "S", + "rotation": 270, + "x": 3, + "y": 1 + }, + { + "patternId": "smile", + "rotation": 180, + "x": 3, + "y": 2 + }, + { + "patternId": "2", + "rotation": 0, + "x": 2, + "y": 2 + }, + { + "patternId": "square", + "rotation": 180, + "x": 2, + "y": 3 + }, + { + "patternId": "smile", + "rotation": 90, + "x": 3, + "y": 3 + }, + { + "patternId": "2", + "rotation": 270, + "x": 3, + "y": 2 + }, + { + "patternId": "S", + "rotation": 270, + "x": 4, + "y": 2 + }, + { + "patternId": "4", + "rotation": 0, + "x": 5, + "y": 2 + }, + { + "patternId": "smile", + "rotation": 270, + "x": 5, + "y": 3 + } + ], + "slot_sequence": [ + "RIGHT", + "TOP", + "FRONT", + "RIGHT", + "BOTTOM", + "FRONT", + "RIGHT", + "TOP", + "LEFT", + "FRONT" + ], + "required_slots": [ + "RIGHT", + "TOP", + "FRONT", + "BOTTOM", + "LEFT" + ], + "required_count": 5, + "answer": { + "faces": { + "TOP": { + "patternId": "S", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 90 + }, + "FRONT": { + "patternId": "smile", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "4", + "rotation": 180 + }, + "RIGHT": { + "patternId": "2", + "rotation": 90 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "S", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 90 + }, + "FRONT": { + "patternId": "smile", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "4", + "rotation": 180 + }, + "RIGHT": { + "patternId": "2", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C499\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): E -> E -> S -> W -> S -> E -> N -> E -> E -> S\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=2, rotation=270, flipVertical=true\n- step 2: patternId=S, rotation=270, flipVertical=true\n- step 3: patternId=smile, rotation=180, flipVertical=true\n- step 4: patternId=2, rotation=0, flipVertical=true\n- step 5: patternId=square, rotation=180, flipVertical=true\n- step 6: patternId=smile, rotation=90, flipVertical=true\n- step 7: patternId=2, rotation=270, flipVertical=true\n- step 8: patternId=S, rotation=270, flipVertical=true\n- step 9: patternId=4, rotation=0, flipVertical=true\n- step 10: patternId=smile, rotation=270, flipVertical=true\n- allowed patternId values for this task: 2, S, smile, square, 4, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C500.json b/cube1/data/C500.json new file mode 100644 index 0000000000000000000000000000000000000000..d7705d04341539f21b885834377608852e102188 --- /dev/null +++ b/cube1/data/C500.json @@ -0,0 +1,314 @@ +{ + "sample_id": "C500", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: E -> S -> N -> S -> S -> W -> N -> W -> S -> S\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "E", + "S", + "N", + "S", + "S", + "W", + "N", + "W", + "S", + "S" + ], + "observed_path_faces": [ + { + "patternId": "1", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C500_path_sequence.png" + }, + "metadata": { + "level_id": 500, + "name": "Reconstruct 500", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-500.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "J", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "smile", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "1", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_left", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_up", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "J", + "smile", + "1", + "arrow_left", + "arrow_up", + "arrow_up" + ], + "start_x": 2, + "start_y": 1, + "grid_width": 5, + "grid_height": 6, + "true_solution_faces": { + "TOP": { + "patternId": "J", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 270 + }, + "FRONT": { + "patternId": "smile", + "rotation": 0 + }, + "BACK": { + "patternId": "arrow_left", + "rotation": 90 + }, + "LEFT": { + "patternId": "arrow_up", + "rotation": 270 + }, + "RIGHT": { + "patternId": "1", + "rotation": 90 + } + }, + "bottom_faces": [ + { + "patternId": "arrow_up", + "rotation": 270, + "x": 2, + "y": 1 + }, + { + "patternId": "1", + "rotation": 180, + "x": 3, + "y": 1 + }, + { + "patternId": "smile", + "rotation": 90, + "x": 3, + "y": 2 + }, + { + "patternId": "1", + "rotation": 180, + "x": 3, + "y": 1 + }, + { + "patternId": "smile", + "rotation": 90, + "x": 3, + "y": 2 + }, + { + "patternId": "arrow_up", + "rotation": 0, + "x": 3, + "y": 3 + }, + { + "patternId": "arrow_up", + "rotation": 90, + "x": 2, + "y": 3 + }, + { + "patternId": "smile", + "rotation": 180, + "x": 2, + "y": 2 + }, + { + "patternId": "1", + "rotation": 270, + "x": 1, + "y": 2 + }, + { + "patternId": "arrow_up", + "rotation": 0, + "x": 1, + "y": 3 + }, + { + "patternId": "arrow_up", + "rotation": 270, + "x": 1, + "y": 4 + } + ], + "slot_sequence": [ + "RIGHT", + "FRONT", + "RIGHT", + "FRONT", + "LEFT", + "BOTTOM", + "FRONT", + "RIGHT", + "BOTTOM", + "LEFT" + ], + "required_slots": [ + "RIGHT", + "FRONT", + "LEFT", + "BOTTOM" + ], + "required_count": 4, + "answer": { + "faces": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 270 + }, + "FRONT": { + "patternId": "smile", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "arrow_up", + "rotation": 0 + }, + "RIGHT": { + "patternId": "1", + "rotation": 0 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 270 + }, + "FRONT": { + "patternId": "smile", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "arrow_up", + "rotation": 0 + }, + "RIGHT": { + "patternId": "1", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C500\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): E -> S -> N -> S -> S -> W -> N -> W -> S -> S\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=1, rotation=180, flipVertical=true\n- step 2: patternId=smile, rotation=90, flipVertical=true\n- step 3: patternId=1, rotation=180, flipVertical=true\n- step 4: patternId=smile, rotation=90, flipVertical=true\n- step 5: patternId=arrow_up, rotation=0, flipVertical=true\n- step 6: patternId=arrow_up, rotation=90, flipVertical=true\n- step 7: patternId=smile, rotation=180, flipVertical=true\n- step 8: patternId=1, rotation=270, flipVertical=true\n- step 9: patternId=arrow_up, rotation=0, flipVertical=true\n- step 10: patternId=arrow_up, rotation=270, flipVertical=true\n- allowed patternId values for this task: 1, smile, arrow_up, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C501.json b/cube1/data/C501.json new file mode 100644 index 0000000000000000000000000000000000000000..85898af31d7df3900b718450e6fb47460a1cb2b5 --- /dev/null +++ b/cube1/data/C501.json @@ -0,0 +1,316 @@ +{ + "sample_id": "C501", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: W -> W -> W -> S -> S -> W -> W -> N -> E -> E\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "W", + "W", + "W", + "S", + "S", + "W", + "W", + "N", + "E", + "E" + ], + "observed_path_faces": [ + { + "patternId": "A", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "J", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C501_path_sequence.png" + }, + "metadata": { + "level_id": 501, + "name": "Reconstruct 501", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-501.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "W", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_right", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "J", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "A", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "square", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "W", + "arrow_left", + "arrow_right", + "J", + "A", + "square" + ], + "start_x": 6, + "start_y": 1, + "grid_width": 8, + "grid_height": 5, + "true_solution_faces": { + "TOP": { + "patternId": "W", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 0 + }, + "FRONT": { + "patternId": "arrow_left", + "rotation": 0 + }, + "BACK": { + "patternId": "J", + "rotation": 180 + }, + "LEFT": { + "patternId": "A", + "rotation": 0 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 270 + } + }, + "bottom_faces": [ + { + "patternId": "square", + "rotation": 0, + "x": 6, + "y": 1 + }, + { + "patternId": "A", + "rotation": 270, + "x": 5, + "y": 1 + }, + { + "patternId": "W", + "rotation": 180, + "x": 4, + "y": 1 + }, + { + "patternId": "arrow_right", + "rotation": 0, + "x": 3, + "y": 1 + }, + { + "patternId": "arrow_left", + "rotation": 90, + "x": 3, + "y": 2 + }, + { + "patternId": "A", + "rotation": 90, + "x": 3, + "y": 3 + }, + { + "patternId": "square", + "rotation": 180, + "x": 2, + "y": 3 + }, + { + "patternId": "arrow_right", + "rotation": 180, + "x": 1, + "y": 3 + }, + { + "patternId": "arrow_left", + "rotation": 270, + "x": 1, + "y": 2 + }, + { + "patternId": "square", + "rotation": 270, + "x": 2, + "y": 2 + }, + { + "patternId": "J", + "rotation": 270, + "x": 3, + "y": 2 + } + ], + "slot_sequence": [ + "LEFT", + "TOP", + "RIGHT", + "FRONT", + "LEFT", + "BOTTOM", + "RIGHT", + "FRONT", + "BOTTOM", + "BACK" + ], + "required_slots": [ + "LEFT", + "TOP", + "RIGHT", + "FRONT", + "BOTTOM", + "BACK" + ], + "required_count": 6, + "answer": { + "faces": { + "TOP": { + "patternId": "W", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 0 + }, + "FRONT": { + "patternId": "arrow_left", + "rotation": 0 + }, + "BACK": { + "patternId": "J", + "rotation": 0 + }, + "LEFT": { + "patternId": "A", + "rotation": 90 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 180 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "W", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 0 + }, + "FRONT": { + "patternId": "arrow_left", + "rotation": 0 + }, + "BACK": { + "patternId": "J", + "rotation": 0 + }, + "LEFT": { + "patternId": "A", + "rotation": 90 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C501\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): W -> W -> W -> S -> S -> W -> W -> N -> E -> E\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=A, rotation=270, flipVertical=true\n- step 2: patternId=W, rotation=180, flipVertical=true\n- step 3: patternId=arrow_right, rotation=0, flipVertical=true\n- step 4: patternId=arrow_left, rotation=90, flipVertical=true\n- step 5: patternId=A, rotation=90, flipVertical=true\n- step 6: patternId=square, rotation=180, flipVertical=true\n- step 7: patternId=arrow_right, rotation=180, flipVertical=true\n- step 8: patternId=arrow_left, rotation=270, flipVertical=true\n- step 9: patternId=square, rotation=270, flipVertical=true\n- step 10: patternId=J, rotation=270, flipVertical=true\n- allowed patternId values for this task: A, W, arrow_right, arrow_left, square, J, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/data/C502.json b/cube1/data/C502.json new file mode 100644 index 0000000000000000000000000000000000000000..c14ae814c574824d737be4ff3f9b372e12c48bcb --- /dev/null +++ b/cube1/data/C502.json @@ -0,0 +1,316 @@ +{ + "sample_id": "C502", + "text_description": "Task: reconstruct the six outer faces of the cube from the blank cross net image and the path-view observation image.\nThe net uses the fixed face names TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\nIf a face cannot be uniquely determined, output patternId='?' and rotation=0.\nRoll sequence: N -> E -> N -> E -> E -> W -> S -> E -> E -> S\nThe puzzle images already show the roll path and the observed path-face states.", + "net_layout": "standard_cross", + "roll_sequence": [ + "N", + "E", + "N", + "E", + "E", + "W", + "S", + "E", + "E", + "S" + ], + "observed_path_faces": [ + { + "patternId": "F", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "image_paths": { + "blank_net_image": "images/blank_nets/open.png", + "path_sequence_image": "images/path_sequences/C502_path_sequence.png" + }, + "metadata": { + "level_id": 502, + "name": "Reconstruct 502", + "difficulty": 5, + "move_count": 10, + "tier": 5, + "source_level_path": "levels/reconstruct/generated-502.json", + "tier_label": "Difficulty 5" + }, + "description": "10-move reconstruct puzzle", + "net_faces": [ + { + "patternId": "A", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "G", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "arrow_right", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "F", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "S", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": false + }, + { + "patternId": "C", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": false + } + ], + "net_patterns": [ + "A", + "G", + "arrow_right", + "F", + "S", + "C" + ], + "start_x": 1, + "start_y": 3, + "grid_width": 7, + "grid_height": 5, + "true_solution_faces": { + "TOP": { + "patternId": "A", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "C", + "rotation": 90 + }, + "FRONT": { + "patternId": "G", + "rotation": 90 + }, + "BACK": { + "patternId": "F", + "rotation": 90 + }, + "LEFT": { + "patternId": "S", + "rotation": 180 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 0 + } + }, + "bottom_faces": [ + { + "patternId": "C", + "rotation": 90, + "x": 1, + "y": 3 + }, + { + "patternId": "F", + "rotation": 270, + "x": 1, + "y": 2 + }, + { + "patternId": "arrow_right", + "rotation": 180, + "x": 2, + "y": 2 + }, + { + "patternId": "A", + "rotation": 0, + "x": 2, + "y": 1 + }, + { + "patternId": "G", + "rotation": 0, + "x": 3, + "y": 1 + }, + { + "patternId": "C", + "rotation": 0, + "x": 4, + "y": 1 + }, + { + "patternId": "G", + "rotation": 0, + "x": 3, + "y": 1 + }, + { + "patternId": "arrow_right", + "rotation": 270, + "x": 3, + "y": 2 + }, + { + "patternId": "C", + "rotation": 270, + "x": 4, + "y": 2 + }, + { + "patternId": "S", + "rotation": 270, + "x": 5, + "y": 2 + }, + { + "patternId": "F", + "rotation": 180, + "x": 5, + "y": 3 + } + ], + "slot_sequence": [ + "BACK", + "RIGHT", + "TOP", + "FRONT", + "BOTTOM", + "FRONT", + "RIGHT", + "BOTTOM", + "LEFT", + "BACK" + ], + "required_slots": [ + "BACK", + "RIGHT", + "TOP", + "FRONT", + "BOTTOM", + "LEFT" + ], + "required_count": 6, + "answer": { + "faces": { + "TOP": { + "patternId": "A", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "C", + "rotation": 90 + }, + "FRONT": { + "patternId": "G", + "rotation": 90 + }, + "BACK": { + "patternId": "F", + "rotation": 270 + }, + "LEFT": { + "patternId": "S", + "rotation": 270 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 270 + } + } + }, + "legacy_answer": { + "TOP": { + "patternId": "A", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "C", + "rotation": 90 + }, + "FRONT": { + "patternId": "G", + "rotation": 90 + }, + "BACK": { + "patternId": "F", + "rotation": 270 + }, + "LEFT": { + "patternId": "S", + "rotation": 270 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-reconstruction puzzle solver. Given a blank cross net of a cube and a top-down path image showing the bottom-face imprints stamped onto the road as the cube rolls, you reconstruct the patternId and rotation of every outer face.\n\nYou will receive: (a) one blank cross-net image (the unfolded outer surface, with the six face slots TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT), (b) one path-sequence image (top-down view of the cube's roll path with the bottom-face imprints visible), and (c) a structured text body listing the roll sequence, observed path faces, and the allowed patternId values for this task.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the faces schema described in section 8 of the user prompt. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf a face cannot be uniquely determined from the inputs, output patternId=\"?\" and rotation=0 for that face. Always emit a complete FINAL_JSON line covering all six face keys; never refuse, never return prose only.", + "user": "## 1. TASK\nReconstruct the patternId and absolute rotation of every face of a cube from a roll-trace image.\nThe puzzle is solved when every output face matches the cube's true outer-surface configuration; faces that cannot be uniquely determined are reported with patternId=\"?\" and rotation=0.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. Faces are named by their orientation in the world frame: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- Cross net: the unfolded outer surface laid flat in a cross shape. Each cell of the cross is one face of the cube.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell.\n- Path imprint / bottom-face stamp: as the cube rolls, the face touching the ground stamps that face's pattern (rotated according to the roll) onto the grid cell it lay on. The path-sequence image shows these imprints from a top-down view.\n- patternId: the symbolic name of a face's printed pattern (e.g. \"smile\", \"triangle\", \"5\"). The literal string \"?\" denotes \"cannot be uniquely determined\".\n- rotation: an integer in {0, 90, 180, 270} measured clockwise from the pattern's upright orientation when the face is viewed from outside the cube.\n\n## 3. VISUAL LEGEND\n- Blank cross net image: shows the six face slots arranged in a cross with TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT labelled.\n- Path sequence image: a top-down grid showing the cube's start cell, the roll path, and the bottom-face imprints stamped along the path. Each imprint is the bottom-face pattern at the moment the cube rested on that cell, viewed from above (NOT viewed from underneath looking up).\n- Coordinate system: top-down, with grid cell positions used to locate imprints; rotations are expressed in degrees clockwise.\n\n## 4. INPUT FIELDS\n- sample_id: C502\n- net_layout: standard_cross\n- difficulty: 5\n- move_count: 10\n- roll_sequence (N=up, S=down, W=left, E=right): N -> E -> N -> E -> E -> W -> S -> E -> E -> S\n- observed_path_faces (one entry per stamped imprint, in roll order):\n- step 1: patternId=F, rotation=270, flipVertical=true\n- step 2: patternId=arrow_right, rotation=180, flipVertical=true\n- step 3: patternId=A, rotation=0, flipVertical=true\n- step 4: patternId=G, rotation=0, flipVertical=true\n- step 5: patternId=C, rotation=0, flipVertical=true\n- step 6: patternId=G, rotation=0, flipVertical=true\n- step 7: patternId=arrow_right, rotation=270, flipVertical=true\n- step 8: patternId=C, rotation=270, flipVertical=true\n- step 9: patternId=S, rotation=270, flipVertical=true\n- step 10: patternId=F, rotation=180, flipVertical=true\n- allowed patternId values for this task: F, arrow_right, A, G, C, S, ?\n\n## 5. ACTION VOCABULARY\nA complete answer is one map from face name to its `(patternId, rotation)` pair:\n- face: one of {\"TOP\", \"BOTTOM\", \"FRONT\", \"BACK\", \"LEFT\", \"RIGHT\"}.\n- patternId: a string drawn from the allowed list above, or the literal \"?\" sentinel.\n- rotation: integer in {0, 90, 180, 270}.\nA face is \"uniquely determined\" iff the inputs (roll sequence, observed imprints, blank net) constrain its pattern and rotation to exactly one possibility.\n\n## 6. CONSTRAINTS\n- The output must list all six face keys exactly: TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT (no extras, no omissions).\n- Each `patternId` must come from the allowed list, or be the literal \"?\".\n- When `patternId == \"?\"`, `rotation` must be 0.\n- Each rotation must be one of 0, 90, 180, 270.\n- Do not invent new patternIds. The model is scored only against the listed allowed values plus \"?\".\n\n## 7. SOLVING ADVICE\n- Trace the roll one step at a time: which face becomes the bottom after each roll? The path imprint at that step records that face.\n- When a stamped imprint is rotated relative to the original pattern's upright orientation, infer the cumulative rotation that the rolling chain has applied to that face.\n- Faces that never touch the ground may not appear in the imprints; if no other constraint pins them, they are \"?\".\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"faces\":{\"TOP\":{\"patternId\":,\"rotation\":},\"BOTTOM\":{...},\"FRONT\":{...},\"BACK\":{...},\"LEFT\":{...},\"RIGHT\":{...}}}\n- faces: object with exactly six keys TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT.\n- patternId: string from the allowed list, or \"?\".\n- rotation: integer in {0, 90, 180, 270}; 0 when patternId is \"?\".\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube1/images/blank_nets/.gitkeep b/cube1/images/blank_nets/.gitkeep new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/cube1/images/blank_nets/.gitkeep @@ -0,0 +1 @@ + diff --git a/cube1/images/path_sequences/.gitkeep b/cube1/images/path_sequences/.gitkeep new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/cube1/images/path_sequences/.gitkeep @@ -0,0 +1 @@ + diff --git a/cube2/data/C425.json b/cube2/data/C425.json new file mode 100644 index 0000000000000000000000000000000000000000..76243f49ff21824c2e0ac6c36e332f03318bd007 --- /dev/null +++ b/cube2/data/C425.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C425", + "name": "Goal Roll C425", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "I", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "4", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "3", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "I", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "7", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "I", + "rotation": 90 + }, + "FRONT": { + "patternId": "4", + "rotation": 90 + }, + "RIGHT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "3", + "rotation": 180 + }, + "LEFT": { + "patternId": "I", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "7", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 6, + "stepNumber": 7, + "patternId": "4", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C425/initial_net.png", + "targetTopFaceImage": "../images/C425/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 7, + "targetRotationOffset": 270, + "levelId": 425, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-425.json" + }, + "rollSequence": [ + "S", + "W", + "W", + "E", + "E", + "N", + "N", + "N", + "W", + "S" + ], + "observedPathFaces": [ + { + "patternId": "4", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "3", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "7", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "3", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "3", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "W", + "W", + "E", + "E", + "N", + "N", + "N", + "W", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "I", + "rotation": 90 + }, + "FRONT": { + "patternId": "4", + "rotation": 90 + }, + "RIGHT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "3", + "rotation": 180 + }, + "LEFT": { + "patternId": "I", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "7", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C425\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=4, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=3, rotation=180]\n[LEFT: patternId=I, rotation=180] [TOP: patternId=I, rotation=90] [RIGHT: patternId=?, rotation=0]\n [FRONT: patternId=4, rotation=90]\n [BOTTOM: patternId=7, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=3, rotation=180\n- LEFT: patternId=I, rotation=180\n- TOP: patternId=I, rotation=90\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=4, rotation=90\n- BOTTOM: patternId=7, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C426.json b/cube2/data/C426.json new file mode 100644 index 0000000000000000000000000000000000000000..0ec3c80c4acdf1f34018ef43a6f9f2ad2e33bb6e --- /dev/null +++ b/cube2/data/C426.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C426", + "name": "Goal Roll C426", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "triangle", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "F", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "X", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "star", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "9", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "heart", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "triangle", + "rotation": 270 + }, + "FRONT": { + "patternId": "F", + "rotation": 270 + }, + "RIGHT": { + "patternId": "X", + "rotation": 0 + }, + "BACK": { + "patternId": "star", + "rotation": 270 + }, + "LEFT": { + "patternId": "9", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "heart", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 2, + "stepNumber": 3, + "patternId": "star", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C426/initial_net.png", + "targetTopFaceImage": "../images/C426/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 3, + "targetRotationOffset": 180, + "levelId": 426, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-426.json" + }, + "rollSequence": [ + "N", + "S", + "S", + "W", + "S", + "W", + "S", + "E", + "S", + "W" + ], + "observedPathFaces": [ + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "S", + "S", + "W", + "S", + "W", + "S", + "E", + "S", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "triangle", + "rotation": 270 + }, + "FRONT": { + "patternId": "F", + "rotation": 270 + }, + "RIGHT": { + "patternId": "X", + "rotation": 0 + }, + "BACK": { + "patternId": "star", + "rotation": 270 + }, + "LEFT": { + "patternId": "9", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "heart", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C426\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=star, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=star, rotation=270]\n[LEFT: patternId=9, rotation=90] [TOP: patternId=triangle, rotation=270] [RIGHT: patternId=X, rotation=0]\n [FRONT: patternId=F, rotation=270]\n [BOTTOM: patternId=heart, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=star, rotation=270\n- LEFT: patternId=9, rotation=90\n- TOP: patternId=triangle, rotation=270\n- RIGHT: patternId=X, rotation=0\n- FRONT: patternId=F, rotation=270\n- BOTTOM: patternId=heart, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C427.json b/cube2/data/C427.json new file mode 100644 index 0000000000000000000000000000000000000000..3a8952449dfcf1a702ea760cbcdcce604f2ae54c --- /dev/null +++ b/cube2/data/C427.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C427", + "name": "Goal Roll C427", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "X", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "star", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "E", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "X", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "B", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "D", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "X", + "rotation": 90 + }, + "FRONT": { + "patternId": "star", + "rotation": 0 + }, + "RIGHT": { + "patternId": "E", + "rotation": 90 + }, + "BACK": { + "patternId": "X", + "rotation": 90 + }, + "LEFT": { + "patternId": "B", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "D", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 5, + "stepNumber": 6, + "patternId": "X", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C427/initial_net.png", + "targetTopFaceImage": "../images/C427/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 6, + "targetRotationOffset": 90, + "levelId": 427, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-427.json" + }, + "rollSequence": [ + "N", + "N", + "S", + "E", + "N", + "E", + "N", + "N", + "E", + "E" + ], + "observedPathFaces": [ + { + "patternId": "X", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "N", + "S", + "E", + "N", + "E", + "N", + "N", + "E", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "X", + "rotation": 90 + }, + "FRONT": { + "patternId": "star", + "rotation": 0 + }, + "RIGHT": { + "patternId": "E", + "rotation": 90 + }, + "BACK": { + "patternId": "X", + "rotation": 90 + }, + "LEFT": { + "patternId": "B", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "D", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C427\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=X, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=X, rotation=90]\n[LEFT: patternId=B, rotation=270] [TOP: patternId=X, rotation=90] [RIGHT: patternId=E, rotation=90]\n [FRONT: patternId=star, rotation=0]\n [BOTTOM: patternId=D, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=X, rotation=90\n- LEFT: patternId=B, rotation=270\n- TOP: patternId=X, rotation=90\n- RIGHT: patternId=E, rotation=90\n- FRONT: patternId=star, rotation=0\n- BOTTOM: patternId=D, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C428.json b/cube2/data/C428.json new file mode 100644 index 0000000000000000000000000000000000000000..36d5b8f9ae27cdc60bbb6597e3bb993c831d7440 --- /dev/null +++ b/cube2/data/C428.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C428", + "name": "Goal Roll C428", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "star", + "rotation": 180 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "square", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "A", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "Q", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "diamond", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "R", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "star", + "rotation": 180 + }, + "FRONT": { + "patternId": "square", + "rotation": 270 + }, + "RIGHT": { + "patternId": "A", + "rotation": 0 + }, + "BACK": { + "patternId": "Q", + "rotation": 270 + }, + "LEFT": { + "patternId": "diamond", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "R", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 7, + "stepNumber": 8, + "patternId": "square", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C428/initial_net.png", + "targetTopFaceImage": "../images/C428/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 8, + "targetRotationOffset": 90, + "levelId": 428, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-428.json" + }, + "rollSequence": [ + "S", + "N", + "N", + "E", + "N", + "E", + "N", + "N", + "W", + "W" + ], + "observedPathFaces": [ + { + "patternId": "square", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "N", + "N", + "E", + "N", + "E", + "N", + "N", + "W", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "star", + "rotation": 180 + }, + "FRONT": { + "patternId": "square", + "rotation": 270 + }, + "RIGHT": { + "patternId": "A", + "rotation": 0 + }, + "BACK": { + "patternId": "Q", + "rotation": 270 + }, + "LEFT": { + "patternId": "diamond", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "R", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C428\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=square, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=Q, rotation=270]\n[LEFT: patternId=diamond, rotation=0] [TOP: patternId=star, rotation=180] [RIGHT: patternId=A, rotation=0]\n [FRONT: patternId=square, rotation=270]\n [BOTTOM: patternId=R, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=Q, rotation=270\n- LEFT: patternId=diamond, rotation=0\n- TOP: patternId=star, rotation=180\n- RIGHT: patternId=A, rotation=0\n- FRONT: patternId=square, rotation=270\n- BOTTOM: patternId=R, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C429.json b/cube2/data/C429.json new file mode 100644 index 0000000000000000000000000000000000000000..533963c6a5ff60c217620443cd22e56f9aa4f215 --- /dev/null +++ b/cube2/data/C429.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C429", + "name": "Goal Roll C429", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "6", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "P", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "6", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "E", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "circle", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "E", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "6", + "rotation": 270 + }, + "FRONT": { + "patternId": "P", + "rotation": 90 + }, + "RIGHT": { + "patternId": "6", + "rotation": 180 + }, + "BACK": { + "patternId": "E", + "rotation": 0 + }, + "LEFT": { + "patternId": "circle", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "E", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 3, + "stepNumber": 4, + "patternId": "E", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C429/initial_net.png", + "targetTopFaceImage": "../images/C429/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 4, + "targetRotationOffset": 270, + "levelId": 429, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-429.json" + }, + "rollSequence": [ + "W", + "N", + "N", + "W", + "N", + "N", + "S", + "N", + "S", + "E" + ], + "observedPathFaces": [ + { + "patternId": "circle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "N", + "N", + "W", + "N", + "N", + "S", + "N", + "S", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "6", + "rotation": 270 + }, + "FRONT": { + "patternId": "P", + "rotation": 90 + }, + "RIGHT": { + "patternId": "6", + "rotation": 180 + }, + "BACK": { + "patternId": "E", + "rotation": 0 + }, + "LEFT": { + "patternId": "circle", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "E", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C429\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=E, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=E, rotation=0]\n[LEFT: patternId=circle, rotation=0] [TOP: patternId=6, rotation=270] [RIGHT: patternId=6, rotation=180]\n [FRONT: patternId=P, rotation=90]\n [BOTTOM: patternId=E, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=E, rotation=0\n- LEFT: patternId=circle, rotation=0\n- TOP: patternId=6, rotation=270\n- RIGHT: patternId=6, rotation=180\n- FRONT: patternId=P, rotation=90\n- BOTTOM: patternId=E, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C430.json b/cube2/data/C430.json new file mode 100644 index 0000000000000000000000000000000000000000..b33f309ce40ecf90859e4139a740b0a80eaff9db --- /dev/null +++ b/cube2/data/C430.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C430", + "name": "Goal Roll C430", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "heart", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "arrow_up", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "9", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "smile", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "K", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "heart", + "rotation": 90 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "arrow_up", + "rotation": 0 + }, + "BACK": { + "patternId": "9", + "rotation": 0 + }, + "LEFT": { + "patternId": "smile", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "K", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 4, + "stepNumber": 5, + "patternId": "smile", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C430/initial_net.png", + "targetTopFaceImage": "../images/C430/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 5, + "targetRotationOffset": 270, + "levelId": 430, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-430.json" + }, + "rollSequence": [ + "W", + "W", + "N", + "N", + "W", + "S", + "E", + "N", + "W", + "N" + ], + "observedPathFaces": [ + { + "patternId": "smile", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "W", + "N", + "N", + "W", + "S", + "E", + "N", + "W", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "heart", + "rotation": 90 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "arrow_up", + "rotation": 0 + }, + "BACK": { + "patternId": "9", + "rotation": 0 + }, + "LEFT": { + "patternId": "smile", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "K", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C430\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=smile, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=9, rotation=0]\n[LEFT: patternId=smile, rotation=90] [TOP: patternId=heart, rotation=90] [RIGHT: patternId=arrow_up, rotation=0]\n [FRONT: patternId=?, rotation=0]\n [BOTTOM: patternId=K, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=9, rotation=0\n- LEFT: patternId=smile, rotation=90\n- TOP: patternId=heart, rotation=90\n- RIGHT: patternId=arrow_up, rotation=0\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=K, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C431.json b/cube2/data/C431.json new file mode 100644 index 0000000000000000000000000000000000000000..578d1c4caa33adefb18a8cae7b1eb10f1da9d03b --- /dev/null +++ b/cube2/data/C431.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C431", + "name": "Goal Roll C431", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "9", + "rotation": 180 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "arrow_left", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "heart", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "1", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "O", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "9", + "rotation": 180 + }, + "FRONT": { + "patternId": "arrow_left", + "rotation": 90 + }, + "RIGHT": { + "patternId": "heart", + "rotation": 270 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "1", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "O", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "1", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C431/initial_net.png", + "targetTopFaceImage": "../images/C431/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 180, + "levelId": 431, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-431.json" + }, + "rollSequence": [ + "S", + "N", + "W", + "S", + "S", + "W", + "W", + "E", + "E", + "N" + ], + "observedPathFaces": [ + { + "patternId": "arrow_left", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "N", + "W", + "S", + "S", + "W", + "W", + "E", + "E", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "9", + "rotation": 180 + }, + "FRONT": { + "patternId": "arrow_left", + "rotation": 90 + }, + "RIGHT": { + "patternId": "heart", + "rotation": 270 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "1", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "O", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C431\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=1, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=?, rotation=0]\n[LEFT: patternId=1, rotation=90] [TOP: patternId=9, rotation=180] [RIGHT: patternId=heart, rotation=270]\n [FRONT: patternId=arrow_left, rotation=90]\n [BOTTOM: patternId=O, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=1, rotation=90\n- TOP: patternId=9, rotation=180\n- RIGHT: patternId=heart, rotation=270\n- FRONT: patternId=arrow_left, rotation=90\n- BOTTOM: patternId=O, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C432.json b/cube2/data/C432.json new file mode 100644 index 0000000000000000000000000000000000000000..b6cd89a7ef8d37970002ae1751ea77d1267ab484 --- /dev/null +++ b/cube2/data/C432.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C432", + "name": "Goal Roll C432", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "9", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "V", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "M", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "4", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "I", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "9", + "rotation": 270 + }, + "FRONT": { + "patternId": "V", + "rotation": 180 + }, + "RIGHT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "M", + "rotation": 90 + }, + "LEFT": { + "patternId": "4", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "I", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 5, + "stepNumber": 6, + "patternId": "I", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C432/initial_net.png", + "targetTopFaceImage": "../images/C432/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 6, + "targetRotationOffset": 270, + "levelId": 432, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-432.json" + }, + "rollSequence": [ + "W", + "N", + "W", + "S", + "W", + "N", + "S", + "S", + "S", + "N" + ], + "observedPathFaces": [ + { + "patternId": "4", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "V", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "V", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "N", + "W", + "S", + "W", + "N", + "S", + "S", + "S", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "9", + "rotation": 270 + }, + "FRONT": { + "patternId": "V", + "rotation": 180 + }, + "RIGHT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "M", + "rotation": 90 + }, + "LEFT": { + "patternId": "4", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "I", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C432\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=I, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=M, rotation=90]\n[LEFT: patternId=4, rotation=90] [TOP: patternId=9, rotation=270] [RIGHT: patternId=?, rotation=0]\n [FRONT: patternId=V, rotation=180]\n [BOTTOM: patternId=I, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=M, rotation=90\n- LEFT: patternId=4, rotation=90\n- TOP: patternId=9, rotation=270\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=V, rotation=180\n- BOTTOM: patternId=I, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C433.json b/cube2/data/C433.json new file mode 100644 index 0000000000000000000000000000000000000000..f34824ac959f04596d034c63c86af7c477540ada --- /dev/null +++ b/cube2/data/C433.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C433", + "name": "Goal Roll C433", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "diamond", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "arrow_up", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "S", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "1", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "diamond", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "diamond", + "rotation": 180 + }, + "RIGHT": { + "patternId": "arrow_up", + "rotation": 180 + }, + "BACK": { + "patternId": "S", + "rotation": 90 + }, + "LEFT": { + "patternId": "1", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "diamond", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 3, + "stepNumber": 4, + "patternId": "1", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C433/initial_net.png", + "targetTopFaceImage": "../images/C433/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 4, + "targetRotationOffset": 90, + "levelId": 433, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-433.json" + }, + "rollSequence": [ + "S", + "N", + "N", + "E", + "S", + "E", + "S", + "W", + "W", + "N" + ], + "observedPathFaces": [ + { + "patternId": "diamond", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "N", + "N", + "E", + "S", + "E", + "S", + "W", + "W", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "diamond", + "rotation": 180 + }, + "RIGHT": { + "patternId": "arrow_up", + "rotation": 180 + }, + "BACK": { + "patternId": "S", + "rotation": 90 + }, + "LEFT": { + "patternId": "1", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "diamond", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C433\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=1, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=S, rotation=90]\n[LEFT: patternId=1, rotation=90] [TOP: patternId=?, rotation=0] [RIGHT: patternId=arrow_up, rotation=180]\n [FRONT: patternId=diamond, rotation=180]\n [BOTTOM: patternId=diamond, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=S, rotation=90\n- LEFT: patternId=1, rotation=90\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=arrow_up, rotation=180\n- FRONT: patternId=diamond, rotation=180\n- BOTTOM: patternId=diamond, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C434.json b/cube2/data/C434.json new file mode 100644 index 0000000000000000000000000000000000000000..d903c3103907b372011b729787bca5f042b3b683 --- /dev/null +++ b/cube2/data/C434.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C434", + "name": "Goal Roll C434", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "heart", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "L", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "8", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "N", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "G", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "heart", + "rotation": 180 + }, + "RIGHT": { + "patternId": "L", + "rotation": 90 + }, + "BACK": { + "patternId": "8", + "rotation": 270 + }, + "LEFT": { + "patternId": "N", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "8", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C434/initial_net.png", + "targetTopFaceImage": "../images/C434/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 90, + "levelId": 434, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-434.json" + }, + "rollSequence": [ + "E", + "N", + "W", + "N", + "W", + "S", + "S", + "W", + "W", + "N" + ], + "observedPathFaces": [ + { + "patternId": "L", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "8", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "8", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "N", + "W", + "N", + "W", + "S", + "S", + "W", + "W", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "heart", + "rotation": 180 + }, + "RIGHT": { + "patternId": "L", + "rotation": 90 + }, + "BACK": { + "patternId": "8", + "rotation": 270 + }, + "LEFT": { + "patternId": "N", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C434\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=8, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=8, rotation=270]\n[LEFT: patternId=N, rotation=270] [TOP: patternId=?, rotation=0] [RIGHT: patternId=L, rotation=90]\n [FRONT: patternId=heart, rotation=180]\n [BOTTOM: patternId=G, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=8, rotation=270\n- LEFT: patternId=N, rotation=270\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=L, rotation=90\n- FRONT: patternId=heart, rotation=180\n- BOTTOM: patternId=G, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C435.json b/cube2/data/C435.json new file mode 100644 index 0000000000000000000000000000000000000000..21bfc38f49c0bbe22f671e17f865ea1f3b41dbfa --- /dev/null +++ b/cube2/data/C435.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C435", + "name": "Goal Roll C435", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "7", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "star", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "arrow_right", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "U", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "B", + "rotation": 180 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "7", + "rotation": 90 + }, + "FRONT": { + "patternId": "star", + "rotation": 270 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 270 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "U", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "B", + "rotation": 180 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 9, + "stepNumber": 10, + "patternId": "B", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C435/initial_net.png", + "targetTopFaceImage": "../images/C435/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 10, + "targetRotationOffset": 270, + "levelId": 435, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-435.json" + }, + "rollSequence": [ + "S", + "W", + "S", + "E", + "E", + "S", + "W", + "E", + "W", + "S" + ], + "observedPathFaces": [ + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "U", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "7", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "7", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "W", + "S", + "E", + "E", + "S", + "W", + "E", + "W", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "7", + "rotation": 90 + }, + "FRONT": { + "patternId": "star", + "rotation": 270 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 270 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "U", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "B", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C435\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=B, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=?, rotation=0]\n[LEFT: patternId=U, rotation=180] [TOP: patternId=7, rotation=90] [RIGHT: patternId=arrow_right, rotation=270]\n [FRONT: patternId=star, rotation=270]\n [BOTTOM: patternId=B, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=U, rotation=180\n- TOP: patternId=7, rotation=90\n- RIGHT: patternId=arrow_right, rotation=270\n- FRONT: patternId=star, rotation=270\n- BOTTOM: patternId=B, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C436.json b/cube2/data/C436.json new file mode 100644 index 0000000000000000000000000000000000000000..b3acd9063c917fad78316b56ef7bce0f6c735292 --- /dev/null +++ b/cube2/data/C436.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C436", + "name": "Goal Roll C436", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "8", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "4", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "E", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "5", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "heart", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "3", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "8", + "rotation": 0 + }, + "FRONT": { + "patternId": "4", + "rotation": 180 + }, + "RIGHT": { + "patternId": "E", + "rotation": 180 + }, + "BACK": { + "patternId": "5", + "rotation": 270 + }, + "LEFT": { + "patternId": "heart", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "3", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 0, + "stepNumber": 1, + "patternId": "heart", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C436/initial_net.png", + "targetTopFaceImage": "../images/C436/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 1, + "targetRotationOffset": 180, + "levelId": 436, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-436.json" + }, + "rollSequence": [ + "E", + "S", + "W", + "E", + "S", + "S", + "W", + "N", + "N", + "S" + ], + "observedPathFaces": [ + { + "patternId": "E", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "3", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "3", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "8", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "S", + "W", + "E", + "S", + "S", + "W", + "N", + "N", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "8", + "rotation": 0 + }, + "FRONT": { + "patternId": "4", + "rotation": 180 + }, + "RIGHT": { + "patternId": "E", + "rotation": 180 + }, + "BACK": { + "patternId": "5", + "rotation": 270 + }, + "LEFT": { + "patternId": "heart", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "3", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C436\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=heart, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=5, rotation=270]\n[LEFT: patternId=heart, rotation=90] [TOP: patternId=8, rotation=0] [RIGHT: patternId=E, rotation=180]\n [FRONT: patternId=4, rotation=180]\n [BOTTOM: patternId=3, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=5, rotation=270\n- LEFT: patternId=heart, rotation=90\n- TOP: patternId=8, rotation=0\n- RIGHT: patternId=E, rotation=180\n- FRONT: patternId=4, rotation=180\n- BOTTOM: patternId=3, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C437.json b/cube2/data/C437.json new file mode 100644 index 0000000000000000000000000000000000000000..9c12f7e9cc60fa5d5ad26ace9c954f89b57edee2 --- /dev/null +++ b/cube2/data/C437.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C437", + "name": "Goal Roll C437", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "5", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "2", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "N", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "C", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "U", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "2", + "rotation": 270 + }, + "RIGHT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "N", + "rotation": 90 + }, + "LEFT": { + "patternId": "C", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "U", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 1, + "stepNumber": 2, + "patternId": "2", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C437/initial_net.png", + "targetTopFaceImage": "../images/C437/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 2, + "targetRotationOffset": 90, + "levelId": 437, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-437.json" + }, + "rollSequence": [ + "W", + "N", + "W", + "S", + "S", + "W", + "W", + "E", + "N", + "N" + ], + "observedPathFaces": [ + { + "patternId": "C", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "U", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "N", + "W", + "S", + "S", + "W", + "W", + "E", + "N", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "2", + "rotation": 270 + }, + "RIGHT": { + "patternId": "?", + "rotation": 0 + }, + "BACK": { + "patternId": "N", + "rotation": 90 + }, + "LEFT": { + "patternId": "C", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "U", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C437\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=2, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=N, rotation=90]\n[LEFT: patternId=C, rotation=180] [TOP: patternId=5, rotation=90] [RIGHT: patternId=?, rotation=0]\n [FRONT: patternId=2, rotation=270]\n [BOTTOM: patternId=U, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=N, rotation=90\n- LEFT: patternId=C, rotation=180\n- TOP: patternId=5, rotation=90\n- RIGHT: patternId=?, rotation=0\n- FRONT: patternId=2, rotation=270\n- BOTTOM: patternId=U, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C438.json b/cube2/data/C438.json new file mode 100644 index 0000000000000000000000000000000000000000..6edbfa31a70ca1a851ed4d4532635aa449527b6c --- /dev/null +++ b/cube2/data/C438.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C438", + "name": "Goal Roll C438", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "T", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "L", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "smile", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "circle", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "N", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "F", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "T", + "rotation": 0 + }, + "FRONT": { + "patternId": "L", + "rotation": 0 + }, + "RIGHT": { + "patternId": "smile", + "rotation": 90 + }, + "BACK": { + "patternId": "circle", + "rotation": 180 + }, + "LEFT": { + "patternId": "N", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "F", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 6, + "stepNumber": 7, + "patternId": "F", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C438/initial_net.png", + "targetTopFaceImage": "../images/C438/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 7, + "targetRotationOffset": 270, + "levelId": 438, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-438.json" + }, + "rollSequence": [ + "E", + "S", + "W", + "E", + "E", + "S", + "N", + "S", + "E", + "N" + ], + "observedPathFaces": [ + { + "patternId": "smile", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "T", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "T", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "T", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "S", + "W", + "E", + "E", + "S", + "N", + "S", + "E", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "T", + "rotation": 0 + }, + "FRONT": { + "patternId": "L", + "rotation": 0 + }, + "RIGHT": { + "patternId": "smile", + "rotation": 90 + }, + "BACK": { + "patternId": "circle", + "rotation": 180 + }, + "LEFT": { + "patternId": "N", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "F", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C438\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=F, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=circle, rotation=180]\n[LEFT: patternId=N, rotation=180] [TOP: patternId=T, rotation=0] [RIGHT: patternId=smile, rotation=90]\n [FRONT: patternId=L, rotation=0]\n [BOTTOM: patternId=F, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=circle, rotation=180\n- LEFT: patternId=N, rotation=180\n- TOP: patternId=T, rotation=0\n- RIGHT: patternId=smile, rotation=90\n- FRONT: patternId=L, rotation=0\n- BOTTOM: patternId=F, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C439.json b/cube2/data/C439.json new file mode 100644 index 0000000000000000000000000000000000000000..24587f0a4d1658b98bb82da1a2c68011237a1453 --- /dev/null +++ b/cube2/data/C439.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C439", + "name": "Goal Roll C439", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "5", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "X", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "D", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "arrow_right", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "Z", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "X", + "rotation": 180 + }, + "BACK": { + "patternId": "D", + "rotation": 0 + }, + "LEFT": { + "patternId": "arrow_right", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "Z", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 7, + "stepNumber": 8, + "patternId": "Z", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C439/initial_net.png", + "targetTopFaceImage": "../images/C439/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 8, + "targetRotationOffset": 270, + "levelId": 439, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-439.json" + }, + "rollSequence": [ + "N", + "N", + "W", + "S", + "N", + "W", + "W", + "W", + "S", + "E" + ], + "observedPathFaces": [ + { + "patternId": "D", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "N", + "W", + "S", + "N", + "W", + "W", + "W", + "S", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "X", + "rotation": 180 + }, + "BACK": { + "patternId": "D", + "rotation": 0 + }, + "LEFT": { + "patternId": "arrow_right", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "Z", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C439\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=Z, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=D, rotation=0]\n[LEFT: patternId=arrow_right, rotation=90] [TOP: patternId=5, rotation=90] [RIGHT: patternId=X, rotation=180]\n [FRONT: patternId=?, rotation=0]\n [BOTTOM: patternId=Z, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=D, rotation=0\n- LEFT: patternId=arrow_right, rotation=90\n- TOP: patternId=5, rotation=90\n- RIGHT: patternId=X, rotation=180\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=Z, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C440.json b/cube2/data/C440.json new file mode 100644 index 0000000000000000000000000000000000000000..f667dd365cb15cfc9c66e4cb4a9f552245d86c60 --- /dev/null +++ b/cube2/data/C440.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C440", + "name": "Goal Roll C440", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "T", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "arrow_up", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "A", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "W", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "star", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "?", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "T", + "rotation": 90 + }, + "FRONT": { + "patternId": "arrow_up", + "rotation": 90 + }, + "RIGHT": { + "patternId": "A", + "rotation": 270 + }, + "BACK": { + "patternId": "W", + "rotation": 180 + }, + "LEFT": { + "patternId": "star", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 1, + "stepNumber": 2, + "patternId": "arrow_up", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C440/initial_net.png", + "targetTopFaceImage": "../images/C440/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 2, + "targetRotationOffset": 180, + "levelId": 440, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-440.json" + }, + "rollSequence": [ + "E", + "N", + "E", + "N", + "E", + "E", + "S", + "W", + "N", + "N" + ], + "observedPathFaces": [ + { + "patternId": "A", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "T", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "T", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "N", + "E", + "N", + "E", + "E", + "S", + "W", + "N", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "T", + "rotation": 90 + }, + "FRONT": { + "patternId": "arrow_up", + "rotation": 90 + }, + "RIGHT": { + "patternId": "A", + "rotation": 270 + }, + "BACK": { + "patternId": "W", + "rotation": 180 + }, + "LEFT": { + "patternId": "star", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C440\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=arrow_up, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=W, rotation=180]\n[LEFT: patternId=star, rotation=0] [TOP: patternId=T, rotation=90] [RIGHT: patternId=A, rotation=270]\n [FRONT: patternId=arrow_up, rotation=90]\n [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=W, rotation=180\n- LEFT: patternId=star, rotation=0\n- TOP: patternId=T, rotation=90\n- RIGHT: patternId=A, rotation=270\n- FRONT: patternId=arrow_up, rotation=90\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C441.json b/cube2/data/C441.json new file mode 100644 index 0000000000000000000000000000000000000000..b2d187d208b36497dfa02db4c29a431c7c80a844 --- /dev/null +++ b/cube2/data/C441.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C441", + "name": "Goal Roll C441", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "arrow_up", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "B", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "V", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "Z", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_left", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "arrow_up", + "rotation": 0 + }, + "FRONT": { + "patternId": "B", + "rotation": 0 + }, + "RIGHT": { + "patternId": "V", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "Z", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 7, + "stepNumber": 8, + "patternId": "Z", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C441/initial_net.png", + "targetTopFaceImage": "../images/C441/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 8, + "targetRotationOffset": 90, + "levelId": 441, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-441.json" + }, + "rollSequence": [ + "E", + "E", + "S", + "S", + "N", + "E", + "W", + "W", + "S", + "S" + ], + "observedPathFaces": [ + { + "patternId": "V", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "V", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "E", + "S", + "S", + "N", + "E", + "W", + "W", + "S", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "arrow_up", + "rotation": 0 + }, + "FRONT": { + "patternId": "B", + "rotation": 0 + }, + "RIGHT": { + "patternId": "V", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "Z", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C441\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=Z, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=?, rotation=0]\n[LEFT: patternId=Z, rotation=180] [TOP: patternId=arrow_up, rotation=0] [RIGHT: patternId=V, rotation=0]\n [FRONT: patternId=B, rotation=0]\n [BOTTOM: patternId=arrow_left, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=Z, rotation=180\n- TOP: patternId=arrow_up, rotation=0\n- RIGHT: patternId=V, rotation=0\n- FRONT: patternId=B, rotation=0\n- BOTTOM: patternId=arrow_left, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C442.json b/cube2/data/C442.json new file mode 100644 index 0000000000000000000000000000000000000000..3f0d9174516c184f7c934718985417fc6f430000 --- /dev/null +++ b/cube2/data/C442.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C442", + "name": "Goal Roll C442", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "5", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "diamond", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "5", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "L", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "5", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_left", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "diamond", + "rotation": 90 + }, + "RIGHT": { + "patternId": "5", + "rotation": 90 + }, + "BACK": { + "patternId": "L", + "rotation": 90 + }, + "LEFT": { + "patternId": "5", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "5", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C442/initial_net.png", + "targetTopFaceImage": "../images/C442/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 270, + "levelId": 442, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-442.json" + }, + "rollSequence": [ + "W", + "N", + "W", + "N", + "E", + "N", + "E", + "N", + "W", + "N" + ], + "observedPathFaces": [ + { + "patternId": "5", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "N", + "W", + "N", + "E", + "N", + "E", + "N", + "W", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "diamond", + "rotation": 90 + }, + "RIGHT": { + "patternId": "5", + "rotation": 90 + }, + "BACK": { + "patternId": "L", + "rotation": 90 + }, + "LEFT": { + "patternId": "5", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C442\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=5, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=L, rotation=90]\n[LEFT: patternId=5, rotation=90] [TOP: patternId=5, rotation=90] [RIGHT: patternId=5, rotation=90]\n [FRONT: patternId=diamond, rotation=90]\n [BOTTOM: patternId=arrow_left, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=L, rotation=90\n- LEFT: patternId=5, rotation=90\n- TOP: patternId=5, rotation=90\n- RIGHT: patternId=5, rotation=90\n- FRONT: patternId=diamond, rotation=90\n- BOTTOM: patternId=arrow_left, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C443.json b/cube2/data/C443.json new file mode 100644 index 0000000000000000000000000000000000000000..12235b2645477524c5d0e1def6334852991eca9a --- /dev/null +++ b/cube2/data/C443.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C443", + "name": "Goal Roll C443", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "P", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "K", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "G", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "circle", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "9", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "P", + "rotation": 270 + }, + "FRONT": { + "patternId": "K", + "rotation": 270 + }, + "RIGHT": { + "patternId": "G", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "circle", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "9", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 1, + "stepNumber": 2, + "patternId": "9", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C443/initial_net.png", + "targetTopFaceImage": "../images/C443/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 2, + "targetRotationOffset": 180, + "levelId": 443, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-443.json" + }, + "rollSequence": [ + "E", + "E", + "S", + "S", + "N", + "E", + "N", + "W", + "N", + "E" + ], + "observedPathFaces": [ + { + "patternId": "G", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "E", + "S", + "S", + "N", + "E", + "N", + "W", + "N", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "P", + "rotation": 270 + }, + "FRONT": { + "patternId": "K", + "rotation": 270 + }, + "RIGHT": { + "patternId": "G", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "circle", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "9", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C443\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=9, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=?, rotation=0]\n[LEFT: patternId=circle, rotation=180] [TOP: patternId=P, rotation=270] [RIGHT: patternId=G, rotation=0]\n [FRONT: patternId=K, rotation=270]\n [BOTTOM: patternId=9, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=circle, rotation=180\n- TOP: patternId=P, rotation=270\n- RIGHT: patternId=G, rotation=0\n- FRONT: patternId=K, rotation=270\n- BOTTOM: patternId=9, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C444.json b/cube2/data/C444.json new file mode 100644 index 0000000000000000000000000000000000000000..d11fa3c853472f92d78555a33893527d43103e26 --- /dev/null +++ b/cube2/data/C444.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C444", + "name": "Goal Roll C444", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "Z", + "rotation": 180 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "arrow_right", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "D", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "8", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "1", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_left", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "Z", + "rotation": 180 + }, + "FRONT": { + "patternId": "arrow_right", + "rotation": 180 + }, + "RIGHT": { + "patternId": "D", + "rotation": 90 + }, + "BACK": { + "patternId": "8", + "rotation": 0 + }, + "LEFT": { + "patternId": "1", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 9, + "stepNumber": 10, + "patternId": "arrow_right", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C444/initial_net.png", + "targetTopFaceImage": "../images/C444/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 10, + "targetRotationOffset": 270, + "levelId": 444, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-444.json" + }, + "rollSequence": [ + "S", + "W", + "W", + "E", + "S", + "S", + "N", + "E", + "E", + "E" + ], + "observedPathFaces": [ + { + "patternId": "arrow_right", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "8", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "8", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "W", + "W", + "E", + "S", + "S", + "N", + "E", + "E", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "Z", + "rotation": 180 + }, + "FRONT": { + "patternId": "arrow_right", + "rotation": 180 + }, + "RIGHT": { + "patternId": "D", + "rotation": 90 + }, + "BACK": { + "patternId": "8", + "rotation": 0 + }, + "LEFT": { + "patternId": "1", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C444\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=arrow_right, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=8, rotation=0]\n[LEFT: patternId=1, rotation=180] [TOP: patternId=Z, rotation=180] [RIGHT: patternId=D, rotation=90]\n [FRONT: patternId=arrow_right, rotation=180]\n [BOTTOM: patternId=arrow_left, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=8, rotation=0\n- LEFT: patternId=1, rotation=180\n- TOP: patternId=Z, rotation=180\n- RIGHT: patternId=D, rotation=90\n- FRONT: patternId=arrow_right, rotation=180\n- BOTTOM: patternId=arrow_left, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C445.json b/cube2/data/C445.json new file mode 100644 index 0000000000000000000000000000000000000000..8c530ef4238203441d7c66c13ae708f6bdc82bb9 --- /dev/null +++ b/cube2/data/C445.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C445", + "name": "Goal Roll C445", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "Q", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "F", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "R", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "smile", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "plus", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "B", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "Q", + "rotation": 0 + }, + "FRONT": { + "patternId": "F", + "rotation": 90 + }, + "RIGHT": { + "patternId": "R", + "rotation": 0 + }, + "BACK": { + "patternId": "smile", + "rotation": 90 + }, + "LEFT": { + "patternId": "plus", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "B", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 1, + "stepNumber": 2, + "patternId": "B", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C445/initial_net.png", + "targetTopFaceImage": "../images/C445/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 2, + "targetRotationOffset": 90, + "levelId": 445, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-445.json" + }, + "rollSequence": [ + "S", + "S", + "E", + "W", + "W", + "W", + "S", + "S", + "W", + "S" + ], + "observedPathFaces": [ + { + "patternId": "F", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "plus", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "S", + "E", + "W", + "W", + "W", + "S", + "S", + "W", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "Q", + "rotation": 0 + }, + "FRONT": { + "patternId": "F", + "rotation": 90 + }, + "RIGHT": { + "patternId": "R", + "rotation": 0 + }, + "BACK": { + "patternId": "smile", + "rotation": 90 + }, + "LEFT": { + "patternId": "plus", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "B", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C445\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=B, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=smile, rotation=90]\n[LEFT: patternId=plus, rotation=180] [TOP: patternId=Q, rotation=0] [RIGHT: patternId=R, rotation=0]\n [FRONT: patternId=F, rotation=90]\n [BOTTOM: patternId=B, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=smile, rotation=90\n- LEFT: patternId=plus, rotation=180\n- TOP: patternId=Q, rotation=0\n- RIGHT: patternId=R, rotation=0\n- FRONT: patternId=F, rotation=90\n- BOTTOM: patternId=B, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C446.json b/cube2/data/C446.json new file mode 100644 index 0000000000000000000000000000000000000000..83922b8d84bd10a5e2e138f877e8913ae45e6c8d --- /dev/null +++ b/cube2/data/C446.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C446", + "name": "Goal Roll C446", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "M", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "triangle", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "R", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "3", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "arrow_right", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "diamond", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "M", + "rotation": 270 + }, + "FRONT": { + "patternId": "triangle", + "rotation": 270 + }, + "RIGHT": { + "patternId": "R", + "rotation": 90 + }, + "BACK": { + "patternId": "3", + "rotation": 270 + }, + "LEFT": { + "patternId": "arrow_right", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "diamond", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 0, + "stepNumber": 1, + "patternId": "3", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C446/initial_net.png", + "targetTopFaceImage": "../images/C446/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 1, + "targetRotationOffset": 180, + "levelId": 446, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-446.json" + }, + "rollSequence": [ + "S", + "W", + "S", + "S", + "W", + "S", + "S", + "E", + "N", + "W" + ], + "observedPathFaces": [ + { + "patternId": "triangle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "3", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "W", + "S", + "S", + "W", + "S", + "S", + "E", + "N", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "M", + "rotation": 270 + }, + "FRONT": { + "patternId": "triangle", + "rotation": 270 + }, + "RIGHT": { + "patternId": "R", + "rotation": 90 + }, + "BACK": { + "patternId": "3", + "rotation": 270 + }, + "LEFT": { + "patternId": "arrow_right", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "diamond", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C446\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=3, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=3, rotation=270]\n[LEFT: patternId=arrow_right, rotation=270] [TOP: patternId=M, rotation=270] [RIGHT: patternId=R, rotation=90]\n [FRONT: patternId=triangle, rotation=270]\n [BOTTOM: patternId=diamond, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=3, rotation=270\n- LEFT: patternId=arrow_right, rotation=270\n- TOP: patternId=M, rotation=270\n- RIGHT: patternId=R, rotation=90\n- FRONT: patternId=triangle, rotation=270\n- BOTTOM: patternId=diamond, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C447.json b/cube2/data/C447.json new file mode 100644 index 0000000000000000000000000000000000000000..4098b764d110faec5be0a67839854c192b23f074 --- /dev/null +++ b/cube2/data/C447.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C447", + "name": "Goal Roll C447", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "smile", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "W", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "L", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "arrow_left", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "Y", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_up", + "rotation": 180 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "smile", + "rotation": 90 + }, + "FRONT": { + "patternId": "W", + "rotation": 90 + }, + "RIGHT": { + "patternId": "L", + "rotation": 90 + }, + "BACK": { + "patternId": "arrow_left", + "rotation": 180 + }, + "LEFT": { + "patternId": "Y", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 180 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 4, + "stepNumber": 5, + "patternId": "W", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C447/initial_net.png", + "targetTopFaceImage": "../images/C447/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 5, + "targetRotationOffset": 90, + "levelId": 447, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-447.json" + }, + "rollSequence": [ + "S", + "E", + "E", + "N", + "S", + "W", + "W", + "N", + "W", + "W" + ], + "observedPathFaces": [ + { + "patternId": "W", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Y", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "E", + "E", + "N", + "S", + "W", + "W", + "N", + "W", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "smile", + "rotation": 90 + }, + "FRONT": { + "patternId": "W", + "rotation": 90 + }, + "RIGHT": { + "patternId": "L", + "rotation": 90 + }, + "BACK": { + "patternId": "arrow_left", + "rotation": 180 + }, + "LEFT": { + "patternId": "Y", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C447\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=W, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=arrow_left, rotation=180]\n[LEFT: patternId=Y, rotation=180] [TOP: patternId=smile, rotation=90] [RIGHT: patternId=L, rotation=90]\n [FRONT: patternId=W, rotation=90]\n [BOTTOM: patternId=arrow_up, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=arrow_left, rotation=180\n- LEFT: patternId=Y, rotation=180\n- TOP: patternId=smile, rotation=90\n- RIGHT: patternId=L, rotation=90\n- FRONT: patternId=W, rotation=90\n- BOTTOM: patternId=arrow_up, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C448.json b/cube2/data/C448.json new file mode 100644 index 0000000000000000000000000000000000000000..f5d02c4b551262519956c0ec03d4092e00f722ab --- /dev/null +++ b/cube2/data/C448.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C448", + "name": "Goal Roll C448", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "circle", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "arrow_left", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "X", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "6", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "4", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "I", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "circle", + "rotation": 0 + }, + "FRONT": { + "patternId": "arrow_left", + "rotation": 0 + }, + "RIGHT": { + "patternId": "X", + "rotation": 90 + }, + "BACK": { + "patternId": "6", + "rotation": 0 + }, + "LEFT": { + "patternId": "4", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "I", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 1, + "stepNumber": 2, + "patternId": "6", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C448/initial_net.png", + "targetTopFaceImage": "../images/C448/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 2, + "targetRotationOffset": 90, + "levelId": 448, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-448.json" + }, + "rollSequence": [ + "W", + "S", + "E", + "S", + "N", + "E", + "E", + "S", + "W", + "S" + ], + "observedPathFaces": [ + { + "patternId": "4", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "S", + "E", + "S", + "N", + "E", + "E", + "S", + "W", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "circle", + "rotation": 0 + }, + "FRONT": { + "patternId": "arrow_left", + "rotation": 0 + }, + "RIGHT": { + "patternId": "X", + "rotation": 90 + }, + "BACK": { + "patternId": "6", + "rotation": 0 + }, + "LEFT": { + "patternId": "4", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "I", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C448\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=6, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=6, rotation=0]\n[LEFT: patternId=4, rotation=270] [TOP: patternId=circle, rotation=0] [RIGHT: patternId=X, rotation=90]\n [FRONT: patternId=arrow_left, rotation=0]\n [BOTTOM: patternId=I, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=6, rotation=0\n- LEFT: patternId=4, rotation=270\n- TOP: patternId=circle, rotation=0\n- RIGHT: patternId=X, rotation=90\n- FRONT: patternId=arrow_left, rotation=0\n- BOTTOM: patternId=I, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C449.json b/cube2/data/C449.json new file mode 100644 index 0000000000000000000000000000000000000000..864ec599399356a40c33a3dfb6ed7510f140d605 --- /dev/null +++ b/cube2/data/C449.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C449", + "name": "Goal Roll C449", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "square", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "star", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "smile", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "smile", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "N", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "square", + "rotation": 0 + }, + "RIGHT": { + "patternId": "star", + "rotation": 270 + }, + "BACK": { + "patternId": "smile", + "rotation": 270 + }, + "LEFT": { + "patternId": "smile", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "N", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 1, + "stepNumber": 2, + "patternId": "smile", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C449/initial_net.png", + "targetTopFaceImage": "../images/C449/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 2, + "targetRotationOffset": 180, + "levelId": 449, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-449.json" + }, + "rollSequence": [ + "E", + "S", + "W", + "W", + "E", + "E", + "S", + "W", + "N", + "E" + ], + "observedPathFaces": [ + { + "patternId": "star", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "S", + "W", + "W", + "E", + "E", + "S", + "W", + "N", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "square", + "rotation": 0 + }, + "RIGHT": { + "patternId": "star", + "rotation": 270 + }, + "BACK": { + "patternId": "smile", + "rotation": 270 + }, + "LEFT": { + "patternId": "smile", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "N", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C449\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=smile, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=smile, rotation=270]\n[LEFT: patternId=smile, rotation=270] [TOP: patternId=?, rotation=0] [RIGHT: patternId=star, rotation=270]\n [FRONT: patternId=square, rotation=0]\n [BOTTOM: patternId=N, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=smile, rotation=270\n- LEFT: patternId=smile, rotation=270\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=star, rotation=270\n- FRONT: patternId=square, rotation=0\n- BOTTOM: patternId=N, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C450.json b/cube2/data/C450.json new file mode 100644 index 0000000000000000000000000000000000000000..efd9673059a4ee6655e5c710a76fcaf0460f9008 --- /dev/null +++ b/cube2/data/C450.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C450", + "name": "Goal Roll C450", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "C", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "R", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "Q", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "8", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "W", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "?", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "C", + "rotation": 270 + }, + "FRONT": { + "patternId": "R", + "rotation": 90 + }, + "RIGHT": { + "patternId": "Q", + "rotation": 270 + }, + "BACK": { + "patternId": "8", + "rotation": 0 + }, + "LEFT": { + "patternId": "W", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 2, + "stepNumber": 3, + "patternId": "8", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C450/initial_net.png", + "targetTopFaceImage": "../images/C450/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 3, + "targetRotationOffset": 90, + "levelId": 450, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-450.json" + }, + "rollSequence": [ + "S", + "W", + "E", + "S", + "S", + "W", + "N", + "W", + "N", + "E" + ], + "observedPathFaces": [ + { + "patternId": "R", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "8", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "W", + "E", + "S", + "S", + "W", + "N", + "W", + "N", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "C", + "rotation": 270 + }, + "FRONT": { + "patternId": "R", + "rotation": 90 + }, + "RIGHT": { + "patternId": "Q", + "rotation": 270 + }, + "BACK": { + "patternId": "8", + "rotation": 0 + }, + "LEFT": { + "patternId": "W", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C450\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=8, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=8, rotation=0]\n[LEFT: patternId=W, rotation=0] [TOP: patternId=C, rotation=270] [RIGHT: patternId=Q, rotation=270]\n [FRONT: patternId=R, rotation=90]\n [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=8, rotation=0\n- LEFT: patternId=W, rotation=0\n- TOP: patternId=C, rotation=270\n- RIGHT: patternId=Q, rotation=270\n- FRONT: patternId=R, rotation=90\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C451.json b/cube2/data/C451.json new file mode 100644 index 0000000000000000000000000000000000000000..6c20ae492dffa31f3e251a90e7faf890c5a3378b --- /dev/null +++ b/cube2/data/C451.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C451", + "name": "Goal Roll C451", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "I", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "F", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "U", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "M", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "circle", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_down", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "I", + "rotation": 270 + }, + "FRONT": { + "patternId": "F", + "rotation": 270 + }, + "RIGHT": { + "patternId": "U", + "rotation": 270 + }, + "BACK": { + "patternId": "M", + "rotation": 90 + }, + "LEFT": { + "patternId": "circle", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_down", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 4, + "stepNumber": 5, + "patternId": "circle", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C451/initial_net.png", + "targetTopFaceImage": "../images/C451/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 5, + "targetRotationOffset": 90, + "levelId": 451, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-451.json" + }, + "rollSequence": [ + "W", + "W", + "N", + "S", + "W", + "E", + "N", + "N", + "E", + "N" + ], + "observedPathFaces": [ + { + "patternId": "circle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "U", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_down", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "W", + "N", + "S", + "W", + "E", + "N", + "N", + "E", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "I", + "rotation": 270 + }, + "FRONT": { + "patternId": "F", + "rotation": 270 + }, + "RIGHT": { + "patternId": "U", + "rotation": 270 + }, + "BACK": { + "patternId": "M", + "rotation": 90 + }, + "LEFT": { + "patternId": "circle", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_down", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C451\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=circle, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=M, rotation=90]\n[LEFT: patternId=circle, rotation=270] [TOP: patternId=I, rotation=270] [RIGHT: patternId=U, rotation=270]\n [FRONT: patternId=F, rotation=270]\n [BOTTOM: patternId=arrow_down, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=M, rotation=90\n- LEFT: patternId=circle, rotation=270\n- TOP: patternId=I, rotation=270\n- RIGHT: patternId=U, rotation=270\n- FRONT: patternId=F, rotation=270\n- BOTTOM: patternId=arrow_down, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C452.json b/cube2/data/C452.json new file mode 100644 index 0000000000000000000000000000000000000000..e5ab35a2775202622e33750f6cd754a12c98a8b5 --- /dev/null +++ b/cube2/data/C452.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C452", + "name": "Goal Roll C452", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "X", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "W", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "L", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "4", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "R", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "B", + "rotation": 180 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "X", + "rotation": 0 + }, + "FRONT": { + "patternId": "W", + "rotation": 90 + }, + "RIGHT": { + "patternId": "L", + "rotation": 180 + }, + "BACK": { + "patternId": "4", + "rotation": 0 + }, + "LEFT": { + "patternId": "R", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "B", + "rotation": 180 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 9, + "stepNumber": 10, + "patternId": "X", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C452/initial_net.png", + "targetTopFaceImage": "../images/C452/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 10, + "targetRotationOffset": 90, + "levelId": 452, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-452.json" + }, + "rollSequence": [ + "S", + "W", + "S", + "S", + "E", + "N", + "N", + "S", + "W", + "W" + ], + "observedPathFaces": [ + { + "patternId": "W", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "W", + "S", + "S", + "E", + "N", + "N", + "S", + "W", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "X", + "rotation": 0 + }, + "FRONT": { + "patternId": "W", + "rotation": 90 + }, + "RIGHT": { + "patternId": "L", + "rotation": 180 + }, + "BACK": { + "patternId": "4", + "rotation": 0 + }, + "LEFT": { + "patternId": "R", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "B", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C452\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=X, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=4, rotation=0]\n[LEFT: patternId=R, rotation=180] [TOP: patternId=X, rotation=0] [RIGHT: patternId=L, rotation=180]\n [FRONT: patternId=W, rotation=90]\n [BOTTOM: patternId=B, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=4, rotation=0\n- LEFT: patternId=R, rotation=180\n- TOP: patternId=X, rotation=0\n- RIGHT: patternId=L, rotation=180\n- FRONT: patternId=W, rotation=90\n- BOTTOM: patternId=B, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C453.json b/cube2/data/C453.json new file mode 100644 index 0000000000000000000000000000000000000000..9fd3c80e1f799911eb4b5a14d85e2aed53d0795c --- /dev/null +++ b/cube2/data/C453.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C453", + "name": "Goal Roll C453", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "plus", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "A", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "O", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "4", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "9", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "plus", + "rotation": 90 + }, + "FRONT": { + "patternId": "A", + "rotation": 270 + }, + "RIGHT": { + "patternId": "O", + "rotation": 270 + }, + "BACK": { + "patternId": "4", + "rotation": 180 + }, + "LEFT": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "9", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 6, + "stepNumber": 7, + "patternId": "4", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C453/initial_net.png", + "targetTopFaceImage": "../images/C453/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 7, + "targetRotationOffset": 90, + "levelId": 453, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-453.json" + }, + "rollSequence": [ + "S", + "N", + "E", + "W", + "N", + "E", + "E", + "S", + "S", + "S" + ], + "observedPathFaces": [ + { + "patternId": "A", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "plus", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "N", + "E", + "W", + "N", + "E", + "E", + "S", + "S", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "plus", + "rotation": 90 + }, + "FRONT": { + "patternId": "A", + "rotation": 270 + }, + "RIGHT": { + "patternId": "O", + "rotation": 270 + }, + "BACK": { + "patternId": "4", + "rotation": 180 + }, + "LEFT": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "9", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C453\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=4, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=4, rotation=180]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=plus, rotation=90] [RIGHT: patternId=O, rotation=270]\n [FRONT: patternId=A, rotation=270]\n [BOTTOM: patternId=9, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=4, rotation=180\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=plus, rotation=90\n- RIGHT: patternId=O, rotation=270\n- FRONT: patternId=A, rotation=270\n- BOTTOM: patternId=9, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C454.json b/cube2/data/C454.json new file mode 100644 index 0000000000000000000000000000000000000000..3dbe78d2407cb06f3828b5661ee272b444421213 --- /dev/null +++ b/cube2/data/C454.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C454", + "name": "Goal Roll C454", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "N", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "J", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "arrow_left", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "R", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "W", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_left", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "N", + "rotation": 270 + }, + "FRONT": { + "patternId": "J", + "rotation": 0 + }, + "RIGHT": { + "patternId": "arrow_left", + "rotation": 90 + }, + "BACK": { + "patternId": "R", + "rotation": 270 + }, + "LEFT": { + "patternId": "W", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 7, + "stepNumber": 8, + "patternId": "N", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C454/initial_net.png", + "targetTopFaceImage": "../images/C454/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 8, + "targetRotationOffset": 90, + "levelId": 454, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-454.json" + }, + "rollSequence": [ + "N", + "N", + "E", + "S", + "E", + "W", + "S", + "E", + "S", + "W" + ], + "observedPathFaces": [ + { + "patternId": "R", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "J", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "N", + "E", + "S", + "E", + "W", + "S", + "E", + "S", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "N", + "rotation": 270 + }, + "FRONT": { + "patternId": "J", + "rotation": 0 + }, + "RIGHT": { + "patternId": "arrow_left", + "rotation": 90 + }, + "BACK": { + "patternId": "R", + "rotation": 270 + }, + "LEFT": { + "patternId": "W", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C454\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=N, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=R, rotation=270]\n[LEFT: patternId=W, rotation=90] [TOP: patternId=N, rotation=270] [RIGHT: patternId=arrow_left, rotation=90]\n [FRONT: patternId=J, rotation=0]\n [BOTTOM: patternId=arrow_left, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=R, rotation=270\n- LEFT: patternId=W, rotation=90\n- TOP: patternId=N, rotation=270\n- RIGHT: patternId=arrow_left, rotation=90\n- FRONT: patternId=J, rotation=0\n- BOTTOM: patternId=arrow_left, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C455.json b/cube2/data/C455.json new file mode 100644 index 0000000000000000000000000000000000000000..11d0541cd157b89524ef408683fcfc5660d1e8da --- /dev/null +++ b/cube2/data/C455.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C455", + "name": "Goal Roll C455", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "star", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "G", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "diamond", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "star", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "star", + "rotation": 180 + }, + "RIGHT": { + "patternId": "G", + "rotation": 0 + }, + "BACK": { + "patternId": "diamond", + "rotation": 180 + }, + "LEFT": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "star", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 3, + "stepNumber": 4, + "patternId": "star", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C455/initial_net.png", + "targetTopFaceImage": "../images/C455/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 4, + "targetRotationOffset": 270, + "levelId": 455, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-455.json" + }, + "rollSequence": [ + "E", + "S", + "N", + "N", + "W", + "S", + "N", + "W", + "S", + "S" + ], + "observedPathFaces": [ + { + "patternId": "G", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "S", + "N", + "N", + "W", + "S", + "N", + "W", + "S", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "star", + "rotation": 180 + }, + "RIGHT": { + "patternId": "G", + "rotation": 0 + }, + "BACK": { + "patternId": "diamond", + "rotation": 180 + }, + "LEFT": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "star", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C455\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=star, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=diamond, rotation=180]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=G, rotation=0]\n [FRONT: patternId=star, rotation=180]\n [BOTTOM: patternId=star, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=diamond, rotation=180\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=G, rotation=0\n- FRONT: patternId=star, rotation=180\n- BOTTOM: patternId=star, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C456.json b/cube2/data/C456.json new file mode 100644 index 0000000000000000000000000000000000000000..e1952261ab8f85c0776d2dc53a1272dfc0cbea75 --- /dev/null +++ b/cube2/data/C456.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C456", + "name": "Goal Roll C456", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "B", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "9", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "star", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "Z", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "smile", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "B", + "rotation": 270 + }, + "RIGHT": { + "patternId": "9", + "rotation": 270 + }, + "BACK": { + "patternId": "star", + "rotation": 90 + }, + "LEFT": { + "patternId": "Z", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "smile", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 3, + "stepNumber": 4, + "patternId": "Z", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C456/initial_net.png", + "targetTopFaceImage": "../images/C456/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 4, + "targetRotationOffset": 90, + "levelId": 456, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-456.json" + }, + "rollSequence": [ + "S", + "W", + "E", + "E", + "N", + "E", + "W", + "N", + "E", + "E" + ], + "observedPathFaces": [ + { + "patternId": "B", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "W", + "E", + "E", + "N", + "E", + "W", + "N", + "E", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "B", + "rotation": 270 + }, + "RIGHT": { + "patternId": "9", + "rotation": 270 + }, + "BACK": { + "patternId": "star", + "rotation": 90 + }, + "LEFT": { + "patternId": "Z", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "smile", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C456\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=Z, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=star, rotation=90]\n[LEFT: patternId=Z, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=9, rotation=270]\n [FRONT: patternId=B, rotation=270]\n [BOTTOM: patternId=smile, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=star, rotation=90\n- LEFT: patternId=Z, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=9, rotation=270\n- FRONT: patternId=B, rotation=270\n- BOTTOM: patternId=smile, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C457.json b/cube2/data/C457.json new file mode 100644 index 0000000000000000000000000000000000000000..40d4ff41d88b19d616e06c8dc8cb5c173140514c --- /dev/null +++ b/cube2/data/C457.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C457", + "name": "Goal Roll C457", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "X", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "arrow_up", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "smile", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "7", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "3", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "K", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "X", + "rotation": 0 + }, + "FRONT": { + "patternId": "arrow_up", + "rotation": 270 + }, + "RIGHT": { + "patternId": "smile", + "rotation": 0 + }, + "BACK": { + "patternId": "7", + "rotation": 270 + }, + "LEFT": { + "patternId": "3", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "K", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 3, + "stepNumber": 4, + "patternId": "K", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C457/initial_net.png", + "targetTopFaceImage": "../images/C457/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 4, + "targetRotationOffset": 180, + "levelId": 457, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-457.json" + }, + "rollSequence": [ + "W", + "S", + "S", + "W", + "S", + "S", + "S", + "E", + "S", + "W" + ], + "observedPathFaces": [ + { + "patternId": "3", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "7", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "S", + "S", + "W", + "S", + "S", + "S", + "E", + "S", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "X", + "rotation": 0 + }, + "FRONT": { + "patternId": "arrow_up", + "rotation": 270 + }, + "RIGHT": { + "patternId": "smile", + "rotation": 0 + }, + "BACK": { + "patternId": "7", + "rotation": 270 + }, + "LEFT": { + "patternId": "3", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "K", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C457\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=K, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=7, rotation=270]\n[LEFT: patternId=3, rotation=180] [TOP: patternId=X, rotation=0] [RIGHT: patternId=smile, rotation=0]\n [FRONT: patternId=arrow_up, rotation=270]\n [BOTTOM: patternId=K, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=7, rotation=270\n- LEFT: patternId=3, rotation=180\n- TOP: patternId=X, rotation=0\n- RIGHT: patternId=smile, rotation=0\n- FRONT: patternId=arrow_up, rotation=270\n- BOTTOM: patternId=K, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C458.json b/cube2/data/C458.json new file mode 100644 index 0000000000000000000000000000000000000000..ec5f245ecc378f6ae916d8e73d96c402afc27014 --- /dev/null +++ b/cube2/data/C458.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C458", + "name": "Goal Roll C458", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "smile", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "F", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "P", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "heart", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "J", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "smile", + "rotation": 270 + }, + "FRONT": { + "patternId": "F", + "rotation": 180 + }, + "RIGHT": { + "patternId": "P", + "rotation": 180 + }, + "BACK": { + "patternId": "heart", + "rotation": 270 + }, + "LEFT": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "J", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 0, + "stepNumber": 1, + "patternId": "F", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C458/initial_net.png", + "targetTopFaceImage": "../images/C458/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 1, + "targetRotationOffset": 180, + "levelId": 458, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-458.json" + }, + "rollSequence": [ + "N", + "E", + "N", + "W", + "S", + "S", + "W", + "W", + "N", + "W" + ], + "observedPathFaces": [ + { + "patternId": "heart", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "J", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "E", + "N", + "W", + "S", + "S", + "W", + "W", + "N", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "smile", + "rotation": 270 + }, + "FRONT": { + "patternId": "F", + "rotation": 180 + }, + "RIGHT": { + "patternId": "P", + "rotation": 180 + }, + "BACK": { + "patternId": "heart", + "rotation": 270 + }, + "LEFT": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "J", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C458\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=F, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=heart, rotation=270]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=smile, rotation=270] [RIGHT: patternId=P, rotation=180]\n [FRONT: patternId=F, rotation=180]\n [BOTTOM: patternId=J, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=heart, rotation=270\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=smile, rotation=270\n- RIGHT: patternId=P, rotation=180\n- FRONT: patternId=F, rotation=180\n- BOTTOM: patternId=J, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C459.json b/cube2/data/C459.json new file mode 100644 index 0000000000000000000000000000000000000000..e19a158875e22ac6488ba5f0d5e31155efe3ed1f --- /dev/null +++ b/cube2/data/C459.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C459", + "name": "Goal Roll C459", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "smile", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "Z", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "S", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "star", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "L", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "X", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "smile", + "rotation": 0 + }, + "FRONT": { + "patternId": "Z", + "rotation": 270 + }, + "RIGHT": { + "patternId": "S", + "rotation": 90 + }, + "BACK": { + "patternId": "star", + "rotation": 180 + }, + "LEFT": { + "patternId": "L", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "X", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 1, + "stepNumber": 2, + "patternId": "L", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C459/initial_net.png", + "targetTopFaceImage": "../images/C459/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 2, + "targetRotationOffset": 90, + "levelId": 459, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-459.json" + }, + "rollSequence": [ + "N", + "E", + "S", + "N", + "S", + "E", + "E", + "E", + "S", + "N" + ], + "observedPathFaces": [ + { + "patternId": "star", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "E", + "S", + "N", + "S", + "E", + "E", + "E", + "S", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "smile", + "rotation": 0 + }, + "FRONT": { + "patternId": "Z", + "rotation": 270 + }, + "RIGHT": { + "patternId": "S", + "rotation": 90 + }, + "BACK": { + "patternId": "star", + "rotation": 180 + }, + "LEFT": { + "patternId": "L", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "X", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C459\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=L, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=star, rotation=180]\n[LEFT: patternId=L, rotation=270] [TOP: patternId=smile, rotation=0] [RIGHT: patternId=S, rotation=90]\n [FRONT: patternId=Z, rotation=270]\n [BOTTOM: patternId=X, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=star, rotation=180\n- LEFT: patternId=L, rotation=270\n- TOP: patternId=smile, rotation=0\n- RIGHT: patternId=S, rotation=90\n- FRONT: patternId=Z, rotation=270\n- BOTTOM: patternId=X, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C460.json b/cube2/data/C460.json new file mode 100644 index 0000000000000000000000000000000000000000..623f1d3abbce4eaaaa6a9fb8d609bbcd90203406 --- /dev/null +++ b/cube2/data/C460.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C460", + "name": "Goal Roll C460", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "7", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "H", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "B", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "1", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "P", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "D", + "rotation": 180 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "7", + "rotation": 0 + }, + "FRONT": { + "patternId": "H", + "rotation": 0 + }, + "RIGHT": { + "patternId": "B", + "rotation": 270 + }, + "BACK": { + "patternId": "1", + "rotation": 0 + }, + "LEFT": { + "patternId": "P", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "D", + "rotation": 180 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 1, + "stepNumber": 2, + "patternId": "D", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C460/initial_net.png", + "targetTopFaceImage": "../images/C460/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 2, + "targetRotationOffset": 180, + "levelId": 460, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-460.json" + }, + "rollSequence": [ + "N", + "N", + "N", + "S", + "E", + "S", + "E", + "S", + "S", + "N" + ], + "observedPathFaces": [ + { + "patternId": "1", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "7", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "H", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "7", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "7", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "N", + "N", + "S", + "E", + "S", + "E", + "S", + "S", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "7", + "rotation": 0 + }, + "FRONT": { + "patternId": "H", + "rotation": 0 + }, + "RIGHT": { + "patternId": "B", + "rotation": 270 + }, + "BACK": { + "patternId": "1", + "rotation": 0 + }, + "LEFT": { + "patternId": "P", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "D", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C460\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=D, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=1, rotation=0]\n[LEFT: patternId=P, rotation=0] [TOP: patternId=7, rotation=0] [RIGHT: patternId=B, rotation=270]\n [FRONT: patternId=H, rotation=0]\n [BOTTOM: patternId=D, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=1, rotation=0\n- LEFT: patternId=P, rotation=0\n- TOP: patternId=7, rotation=0\n- RIGHT: patternId=B, rotation=270\n- FRONT: patternId=H, rotation=0\n- BOTTOM: patternId=D, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C461.json b/cube2/data/C461.json new file mode 100644 index 0000000000000000000000000000000000000000..31a0a031647b6b39ab23dcff584fbc5172473188 --- /dev/null +++ b/cube2/data/C461.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C461", + "name": "Goal Roll C461", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "plus", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "K", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "A", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "diamond", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "diamond", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "triangle", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "plus", + "rotation": 90 + }, + "FRONT": { + "patternId": "K", + "rotation": 90 + }, + "RIGHT": { + "patternId": "A", + "rotation": 270 + }, + "BACK": { + "patternId": "diamond", + "rotation": 180 + }, + "LEFT": { + "patternId": "diamond", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "triangle", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 7, + "stepNumber": 8, + "patternId": "A", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C461/initial_net.png", + "targetTopFaceImage": "../images/C461/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 8, + "targetRotationOffset": 90, + "levelId": 461, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-461.json" + }, + "rollSequence": [ + "E", + "E", + "N", + "E", + "N", + "N", + "E", + "E", + "N", + "S" + ], + "observedPathFaces": [ + { + "patternId": "A", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "plus", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "plus", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "E", + "N", + "E", + "N", + "N", + "E", + "E", + "N", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "plus", + "rotation": 90 + }, + "FRONT": { + "patternId": "K", + "rotation": 90 + }, + "RIGHT": { + "patternId": "A", + "rotation": 270 + }, + "BACK": { + "patternId": "diamond", + "rotation": 180 + }, + "LEFT": { + "patternId": "diamond", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "triangle", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C461\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=A, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=diamond, rotation=180]\n[LEFT: patternId=diamond, rotation=270] [TOP: patternId=plus, rotation=90] [RIGHT: patternId=A, rotation=270]\n [FRONT: patternId=K, rotation=90]\n [BOTTOM: patternId=triangle, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=diamond, rotation=180\n- LEFT: patternId=diamond, rotation=270\n- TOP: patternId=plus, rotation=90\n- RIGHT: patternId=A, rotation=270\n- FRONT: patternId=K, rotation=90\n- BOTTOM: patternId=triangle, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C462.json b/cube2/data/C462.json new file mode 100644 index 0000000000000000000000000000000000000000..bac71c21b8c21d4b59b21fb7ccd64255da4bc935 --- /dev/null +++ b/cube2/data/C462.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C462", + "name": "Goal Roll C462", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "E", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "1", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "arrow_right", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "8", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "5", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "E", + "rotation": 0 + }, + "FRONT": { + "patternId": "1", + "rotation": 90 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 270 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "8", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "5", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "8", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C462/initial_net.png", + "targetTopFaceImage": "../images/C462/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 180, + "levelId": 462, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-462.json" + }, + "rollSequence": [ + "W", + "S", + "N", + "S", + "W", + "S", + "E", + "S", + "W", + "N" + ], + "observedPathFaces": [ + { + "patternId": "8", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "8", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "S", + "N", + "S", + "W", + "S", + "E", + "S", + "W", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "E", + "rotation": 0 + }, + "FRONT": { + "patternId": "1", + "rotation": 90 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 270 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "8", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "5", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C462\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=8, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=?, rotation=0]\n[LEFT: patternId=8, rotation=270] [TOP: patternId=E, rotation=0] [RIGHT: patternId=arrow_right, rotation=270]\n [FRONT: patternId=1, rotation=90]\n [BOTTOM: patternId=5, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=8, rotation=270\n- TOP: patternId=E, rotation=0\n- RIGHT: patternId=arrow_right, rotation=270\n- FRONT: patternId=1, rotation=90\n- BOTTOM: patternId=5, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C463.json b/cube2/data/C463.json new file mode 100644 index 0000000000000000000000000000000000000000..493257121bdac4883de94ef49ebb237a1c3d3e35 --- /dev/null +++ b/cube2/data/C463.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C463", + "name": "Goal Roll C463", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "D", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "I", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "D", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "T", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "circle", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "J", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "D", + "rotation": 0 + }, + "FRONT": { + "patternId": "I", + "rotation": 270 + }, + "RIGHT": { + "patternId": "D", + "rotation": 180 + }, + "BACK": { + "patternId": "T", + "rotation": 90 + }, + "LEFT": { + "patternId": "circle", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "J", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 0, + "stepNumber": 1, + "patternId": "T", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C463/initial_net.png", + "targetTopFaceImage": "../images/C463/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 1, + "targetRotationOffset": 180, + "levelId": 463, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-463.json" + }, + "rollSequence": [ + "S", + "S", + "N", + "W", + "S", + "S", + "E", + "S", + "E", + "S" + ], + "observedPathFaces": [ + { + "patternId": "I", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "J", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "T", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "S", + "N", + "W", + "S", + "S", + "E", + "S", + "E", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "D", + "rotation": 0 + }, + "FRONT": { + "patternId": "I", + "rotation": 270 + }, + "RIGHT": { + "patternId": "D", + "rotation": 180 + }, + "BACK": { + "patternId": "T", + "rotation": 90 + }, + "LEFT": { + "patternId": "circle", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "J", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C463\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=T, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=T, rotation=90]\n[LEFT: patternId=circle, rotation=90] [TOP: patternId=D, rotation=0] [RIGHT: patternId=D, rotation=180]\n [FRONT: patternId=I, rotation=270]\n [BOTTOM: patternId=J, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=T, rotation=90\n- LEFT: patternId=circle, rotation=90\n- TOP: patternId=D, rotation=0\n- RIGHT: patternId=D, rotation=180\n- FRONT: patternId=I, rotation=270\n- BOTTOM: patternId=J, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C464.json b/cube2/data/C464.json new file mode 100644 index 0000000000000000000000000000000000000000..9a6ffb480c405e28b3f121b06af0a2c5f696cc24 --- /dev/null +++ b/cube2/data/C464.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C464", + "name": "Goal Roll C464", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "O", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "square", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "T", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "U", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "?", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "O", + "rotation": 90 + }, + "FRONT": { + "patternId": "square", + "rotation": 180 + }, + "RIGHT": { + "patternId": "T", + "rotation": 90 + }, + "BACK": { + "patternId": "U", + "rotation": 180 + }, + "LEFT": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "square", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C464/initial_net.png", + "targetTopFaceImage": "../images/C464/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 90, + "levelId": 464, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-464.json" + }, + "rollSequence": [ + "S", + "S", + "E", + "N", + "S", + "W", + "E", + "W", + "S", + "N" + ], + "observedPathFaces": [ + { + "patternId": "square", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "T", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "T", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "T", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "U", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "S", + "E", + "N", + "S", + "W", + "E", + "W", + "S", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "O", + "rotation": 90 + }, + "FRONT": { + "patternId": "square", + "rotation": 180 + }, + "RIGHT": { + "patternId": "T", + "rotation": 90 + }, + "BACK": { + "patternId": "U", + "rotation": 180 + }, + "LEFT": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C464\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=square, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=U, rotation=180]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=O, rotation=90] [RIGHT: patternId=T, rotation=90]\n [FRONT: patternId=square, rotation=180]\n [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=U, rotation=180\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=O, rotation=90\n- RIGHT: patternId=T, rotation=90\n- FRONT: patternId=square, rotation=180\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C465.json b/cube2/data/C465.json new file mode 100644 index 0000000000000000000000000000000000000000..5cb761a2a18a16638bf7cc19aa7cc4d0a0e8ad1f --- /dev/null +++ b/cube2/data/C465.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C465", + "name": "Goal Roll C465", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "U", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "G", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "I", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "B", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "M", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "G", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "U", + "rotation": 270 + }, + "FRONT": { + "patternId": "G", + "rotation": 270 + }, + "RIGHT": { + "patternId": "I", + "rotation": 180 + }, + "BACK": { + "patternId": "B", + "rotation": 180 + }, + "LEFT": { + "patternId": "M", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 9, + "stepNumber": 10, + "patternId": "G", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C465/initial_net.png", + "targetTopFaceImage": "../images/C465/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 10, + "targetRotationOffset": 90, + "levelId": 465, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-465.json" + }, + "rollSequence": [ + "N", + "W", + "S", + "S", + "E", + "S", + "N", + "E", + "E", + "S" + ], + "observedPathFaces": [ + { + "patternId": "B", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "U", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "U", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "W", + "S", + "S", + "E", + "S", + "N", + "E", + "E", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "U", + "rotation": 270 + }, + "FRONT": { + "patternId": "G", + "rotation": 270 + }, + "RIGHT": { + "patternId": "I", + "rotation": 180 + }, + "BACK": { + "patternId": "B", + "rotation": 180 + }, + "LEFT": { + "patternId": "M", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C465\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=G, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=B, rotation=180]\n[LEFT: patternId=M, rotation=90] [TOP: patternId=U, rotation=270] [RIGHT: patternId=I, rotation=180]\n [FRONT: patternId=G, rotation=270]\n [BOTTOM: patternId=G, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=B, rotation=180\n- LEFT: patternId=M, rotation=90\n- TOP: patternId=U, rotation=270\n- RIGHT: patternId=I, rotation=180\n- FRONT: patternId=G, rotation=270\n- BOTTOM: patternId=G, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C466.json b/cube2/data/C466.json new file mode 100644 index 0000000000000000000000000000000000000000..73864bcfc57b09ecdd71c5cd6c514d2d98f022b9 --- /dev/null +++ b/cube2/data/C466.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C466", + "name": "Goal Roll C466", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "P", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "8", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "smile", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "smile", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "E", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "E", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "P", + "rotation": 270 + }, + "FRONT": { + "patternId": "8", + "rotation": 0 + }, + "RIGHT": { + "patternId": "smile", + "rotation": 180 + }, + "BACK": { + "patternId": "smile", + "rotation": 90 + }, + "LEFT": { + "patternId": "E", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "E", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 1, + "stepNumber": 2, + "patternId": "E", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C466/initial_net.png", + "targetTopFaceImage": "../images/C466/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 2, + "targetRotationOffset": 90, + "levelId": 466, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-466.json" + }, + "rollSequence": [ + "S", + "E", + "E", + "N", + "E", + "S", + "E", + "E", + "S", + "W" + ], + "observedPathFaces": [ + { + "patternId": "8", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "8", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "E", + "E", + "N", + "E", + "S", + "E", + "E", + "S", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "P", + "rotation": 270 + }, + "FRONT": { + "patternId": "8", + "rotation": 0 + }, + "RIGHT": { + "patternId": "smile", + "rotation": 180 + }, + "BACK": { + "patternId": "smile", + "rotation": 90 + }, + "LEFT": { + "patternId": "E", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "E", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C466\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=E, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=smile, rotation=90]\n[LEFT: patternId=E, rotation=270] [TOP: patternId=P, rotation=270] [RIGHT: patternId=smile, rotation=180]\n [FRONT: patternId=8, rotation=0]\n [BOTTOM: patternId=E, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=smile, rotation=90\n- LEFT: patternId=E, rotation=270\n- TOP: patternId=P, rotation=270\n- RIGHT: patternId=smile, rotation=180\n- FRONT: patternId=8, rotation=0\n- BOTTOM: patternId=E, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C467.json b/cube2/data/C467.json new file mode 100644 index 0000000000000000000000000000000000000000..f505f2d4660f31f20b30c756eafe860c5fb88973 --- /dev/null +++ b/cube2/data/C467.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C467", + "name": "Goal Roll C467", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "2", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "A", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "2", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "arrow_left", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "D", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "H", + "rotation": 180 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "2", + "rotation": 90 + }, + "FRONT": { + "patternId": "A", + "rotation": 180 + }, + "RIGHT": { + "patternId": "2", + "rotation": 0 + }, + "BACK": { + "patternId": "arrow_left", + "rotation": 270 + }, + "LEFT": { + "patternId": "D", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "H", + "rotation": 180 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 9, + "stepNumber": 10, + "patternId": "D", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C467/initial_net.png", + "targetTopFaceImage": "../images/C467/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 10, + "targetRotationOffset": 180, + "levelId": 467, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-467.json" + }, + "rollSequence": [ + "N", + "E", + "E", + "S", + "N", + "S", + "N", + "E", + "N", + "N" + ], + "observedPathFaces": [ + { + "patternId": "arrow_left", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "H", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "H", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "E", + "E", + "S", + "N", + "S", + "N", + "E", + "N", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "2", + "rotation": 90 + }, + "FRONT": { + "patternId": "A", + "rotation": 180 + }, + "RIGHT": { + "patternId": "2", + "rotation": 0 + }, + "BACK": { + "patternId": "arrow_left", + "rotation": 270 + }, + "LEFT": { + "patternId": "D", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "H", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C467\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=D, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=arrow_left, rotation=270]\n[LEFT: patternId=D, rotation=90] [TOP: patternId=2, rotation=90] [RIGHT: patternId=2, rotation=0]\n [FRONT: patternId=A, rotation=180]\n [BOTTOM: patternId=H, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=arrow_left, rotation=270\n- LEFT: patternId=D, rotation=90\n- TOP: patternId=2, rotation=90\n- RIGHT: patternId=2, rotation=0\n- FRONT: patternId=A, rotation=180\n- BOTTOM: patternId=H, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C468.json b/cube2/data/C468.json new file mode 100644 index 0000000000000000000000000000000000000000..ed8722076111c0df680a91a4f8bfd2d7cd65064a --- /dev/null +++ b/cube2/data/C468.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C468", + "name": "Goal Roll C468", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "circle", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "3", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "2", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "V", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "arrow_down", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "4", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "circle", + "rotation": 270 + }, + "FRONT": { + "patternId": "3", + "rotation": 180 + }, + "RIGHT": { + "patternId": "2", + "rotation": 90 + }, + "BACK": { + "patternId": "V", + "rotation": 0 + }, + "LEFT": { + "patternId": "arrow_down", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "4", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "3", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C468/initial_net.png", + "targetTopFaceImage": "../images/C468/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 270, + "levelId": 468, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-468.json" + }, + "rollSequence": [ + "E", + "E", + "S", + "W", + "W", + "S", + "E", + "E", + "N", + "E" + ], + "observedPathFaces": [ + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "3", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "V", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "V", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_down", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "E", + "S", + "W", + "W", + "S", + "E", + "E", + "N", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "circle", + "rotation": 270 + }, + "FRONT": { + "patternId": "3", + "rotation": 180 + }, + "RIGHT": { + "patternId": "2", + "rotation": 90 + }, + "BACK": { + "patternId": "V", + "rotation": 0 + }, + "LEFT": { + "patternId": "arrow_down", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "4", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C468\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=3, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=V, rotation=0]\n[LEFT: patternId=arrow_down, rotation=0] [TOP: patternId=circle, rotation=270] [RIGHT: patternId=2, rotation=90]\n [FRONT: patternId=3, rotation=180]\n [BOTTOM: patternId=4, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=V, rotation=0\n- LEFT: patternId=arrow_down, rotation=0\n- TOP: patternId=circle, rotation=270\n- RIGHT: patternId=2, rotation=90\n- FRONT: patternId=3, rotation=180\n- BOTTOM: patternId=4, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C469.json b/cube2/data/C469.json new file mode 100644 index 0000000000000000000000000000000000000000..8d65e9e7e27d1f0c44044b57f62bf2da965a2651 --- /dev/null +++ b/cube2/data/C469.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C469", + "name": "Goal Roll C469", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "smile", + "rotation": 180 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "O", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "Z", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "7", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "N", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "G", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "smile", + "rotation": 180 + }, + "FRONT": { + "patternId": "O", + "rotation": 270 + }, + "RIGHT": { + "patternId": "Z", + "rotation": 90 + }, + "BACK": { + "patternId": "7", + "rotation": 180 + }, + "LEFT": { + "patternId": "N", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 4, + "stepNumber": 5, + "patternId": "Z", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C469/initial_net.png", + "targetTopFaceImage": "../images/C469/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 5, + "targetRotationOffset": 90, + "levelId": 469, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-469.json" + }, + "rollSequence": [ + "S", + "W", + "S", + "W", + "N", + "E", + "E", + "N", + "E", + "E" + ], + "observedPathFaces": [ + { + "patternId": "O", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "7", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "7", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "W", + "S", + "W", + "N", + "E", + "E", + "N", + "E", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "smile", + "rotation": 180 + }, + "FRONT": { + "patternId": "O", + "rotation": 270 + }, + "RIGHT": { + "patternId": "Z", + "rotation": 90 + }, + "BACK": { + "patternId": "7", + "rotation": 180 + }, + "LEFT": { + "patternId": "N", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C469\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=Z, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=7, rotation=180]\n[LEFT: patternId=N, rotation=180] [TOP: patternId=smile, rotation=180] [RIGHT: patternId=Z, rotation=90]\n [FRONT: patternId=O, rotation=270]\n [BOTTOM: patternId=G, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=7, rotation=180\n- LEFT: patternId=N, rotation=180\n- TOP: patternId=smile, rotation=180\n- RIGHT: patternId=Z, rotation=90\n- FRONT: patternId=O, rotation=270\n- BOTTOM: patternId=G, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C470.json b/cube2/data/C470.json new file mode 100644 index 0000000000000000000000000000000000000000..79f59140ba3bb198fff7b5be01ef5230ecfa354f --- /dev/null +++ b/cube2/data/C470.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C470", + "name": "Goal Roll C470", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "heart", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "circle", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "A", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "5", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_down", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "heart", + "rotation": 270 + }, + "RIGHT": { + "patternId": "circle", + "rotation": 0 + }, + "BACK": { + "patternId": "A", + "rotation": 90 + }, + "LEFT": { + "patternId": "5", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "arrow_down", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 9, + "stepNumber": 10, + "patternId": "5", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C470/initial_net.png", + "targetTopFaceImage": "../images/C470/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 10, + "targetRotationOffset": 270, + "levelId": 470, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-470.json" + }, + "rollSequence": [ + "S", + "E", + "E", + "N", + "W", + "S", + "E", + "S", + "W", + "W" + ], + "observedPathFaces": [ + { + "patternId": "heart", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_down", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_down", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "E", + "E", + "N", + "W", + "S", + "E", + "S", + "W", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "heart", + "rotation": 270 + }, + "RIGHT": { + "patternId": "circle", + "rotation": 0 + }, + "BACK": { + "patternId": "A", + "rotation": 90 + }, + "LEFT": { + "patternId": "5", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "arrow_down", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C470\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=5, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=A, rotation=90]\n[LEFT: patternId=5, rotation=180] [TOP: patternId=?, rotation=0] [RIGHT: patternId=circle, rotation=0]\n [FRONT: patternId=heart, rotation=270]\n [BOTTOM: patternId=arrow_down, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=A, rotation=90\n- LEFT: patternId=5, rotation=180\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=circle, rotation=0\n- FRONT: patternId=heart, rotation=270\n- BOTTOM: patternId=arrow_down, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C471.json b/cube2/data/C471.json new file mode 100644 index 0000000000000000000000000000000000000000..9aca5ba20a690269f5bc43031e86aac3bf64a4be --- /dev/null +++ b/cube2/data/C471.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C471", + "name": "Goal Roll C471", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "H", + "rotation": 180 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "U", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "triangle", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "W", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "Q", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "H", + "rotation": 180 + }, + "FRONT": { + "patternId": "U", + "rotation": 180 + }, + "RIGHT": { + "patternId": "triangle", + "rotation": 90 + }, + "BACK": { + "patternId": "W", + "rotation": 0 + }, + "LEFT": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "Q", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 7, + "stepNumber": 8, + "patternId": "H", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C471/initial_net.png", + "targetTopFaceImage": "../images/C471/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 8, + "targetRotationOffset": 90, + "levelId": 471, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-471.json" + }, + "rollSequence": [ + "E", + "N", + "E", + "S", + "E", + "N", + "W", + "W", + "E", + "N" + ], + "observedPathFaces": [ + { + "patternId": "triangle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "H", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "U", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "H", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "N", + "E", + "S", + "E", + "N", + "W", + "W", + "E", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "H", + "rotation": 180 + }, + "FRONT": { + "patternId": "U", + "rotation": 180 + }, + "RIGHT": { + "patternId": "triangle", + "rotation": 90 + }, + "BACK": { + "patternId": "W", + "rotation": 0 + }, + "LEFT": { + "patternId": "?", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "Q", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C471\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=H, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=W, rotation=0]\n[LEFT: patternId=?, rotation=0] [TOP: patternId=H, rotation=180] [RIGHT: patternId=triangle, rotation=90]\n [FRONT: patternId=U, rotation=180]\n [BOTTOM: patternId=Q, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=W, rotation=0\n- LEFT: patternId=?, rotation=0\n- TOP: patternId=H, rotation=180\n- RIGHT: patternId=triangle, rotation=90\n- FRONT: patternId=U, rotation=180\n- BOTTOM: patternId=Q, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C472.json b/cube2/data/C472.json new file mode 100644 index 0000000000000000000000000000000000000000..3690c420ee7a086830e97e4de796af9dca24aed5 --- /dev/null +++ b/cube2/data/C472.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C472", + "name": "Goal Roll C472", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "5", + "rotation": 180 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "H", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "O", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "M", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "G", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "G", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "5", + "rotation": 180 + }, + "FRONT": { + "patternId": "H", + "rotation": 0 + }, + "RIGHT": { + "patternId": "O", + "rotation": 90 + }, + "BACK": { + "patternId": "M", + "rotation": 90 + }, + "LEFT": { + "patternId": "G", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 0, + "stepNumber": 1, + "patternId": "H", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C472/initial_net.png", + "targetTopFaceImage": "../images/C472/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 1, + "targetRotationOffset": 90, + "levelId": 472, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-472.json" + }, + "rollSequence": [ + "N", + "W", + "S", + "W", + "N", + "N", + "W", + "N", + "E", + "N" + ], + "observedPathFaces": [ + { + "patternId": "M", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "H", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "W", + "S", + "W", + "N", + "N", + "W", + "N", + "E", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "5", + "rotation": 180 + }, + "FRONT": { + "patternId": "H", + "rotation": 0 + }, + "RIGHT": { + "patternId": "O", + "rotation": 90 + }, + "BACK": { + "patternId": "M", + "rotation": 90 + }, + "LEFT": { + "patternId": "G", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C472\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=H, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=M, rotation=90]\n[LEFT: patternId=G, rotation=90] [TOP: patternId=5, rotation=180] [RIGHT: patternId=O, rotation=90]\n [FRONT: patternId=H, rotation=0]\n [BOTTOM: patternId=G, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=M, rotation=90\n- LEFT: patternId=G, rotation=90\n- TOP: patternId=5, rotation=180\n- RIGHT: patternId=O, rotation=90\n- FRONT: patternId=H, rotation=0\n- BOTTOM: patternId=G, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C473.json b/cube2/data/C473.json new file mode 100644 index 0000000000000000000000000000000000000000..e976f38d01b33805ca61d2eeec0a87b074e22bab --- /dev/null +++ b/cube2/data/C473.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C473", + "name": "Goal Roll C473", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "I", + "rotation": 180 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "X", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "Y", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "heart", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "triangle", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "I", + "rotation": 180 + }, + "FRONT": { + "patternId": "X", + "rotation": 270 + }, + "RIGHT": { + "patternId": "Y", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "heart", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "triangle", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "heart", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C473/initial_net.png", + "targetTopFaceImage": "../images/C473/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 180, + "levelId": 473, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-473.json" + }, + "rollSequence": [ + "E", + "S", + "W", + "E", + "S", + "N", + "S", + "E", + "E", + "E" + ], + "observedPathFaces": [ + { + "patternId": "Y", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Y", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "S", + "W", + "E", + "S", + "N", + "S", + "E", + "E", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "I", + "rotation": 180 + }, + "FRONT": { + "patternId": "X", + "rotation": 270 + }, + "RIGHT": { + "patternId": "Y", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "heart", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "triangle", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C473\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=heart, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=?, rotation=0]\n[LEFT: patternId=heart, rotation=90] [TOP: patternId=I, rotation=180] [RIGHT: patternId=Y, rotation=0]\n [FRONT: patternId=X, rotation=270]\n [BOTTOM: patternId=triangle, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=heart, rotation=90\n- TOP: patternId=I, rotation=180\n- RIGHT: patternId=Y, rotation=0\n- FRONT: patternId=X, rotation=270\n- BOTTOM: patternId=triangle, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C474.json b/cube2/data/C474.json new file mode 100644 index 0000000000000000000000000000000000000000..69c324f1117ae52c218ce452932c6856ab197e4a --- /dev/null +++ b/cube2/data/C474.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C474", + "name": "Goal Roll C474", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "arrow_right", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "L", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "plus", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "N", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "triangle", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "arrow_right", + "rotation": 270 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "L", + "rotation": 180 + }, + "BACK": { + "patternId": "plus", + "rotation": 180 + }, + "LEFT": { + "patternId": "N", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "triangle", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 4, + "stepNumber": 5, + "patternId": "triangle", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C474/initial_net.png", + "targetTopFaceImage": "../images/C474/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 5, + "targetRotationOffset": 180, + "levelId": 474, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-474.json" + }, + "rollSequence": [ + "N", + "W", + "E", + "E", + "N", + "N", + "W", + "N", + "S", + "N" + ], + "observedPathFaces": [ + { + "patternId": "plus", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "plus", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "plus", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "plus", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "W", + "E", + "E", + "N", + "N", + "W", + "N", + "S", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "arrow_right", + "rotation": 270 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "L", + "rotation": 180 + }, + "BACK": { + "patternId": "plus", + "rotation": 180 + }, + "LEFT": { + "patternId": "N", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "triangle", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C474\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=triangle, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=plus, rotation=180]\n[LEFT: patternId=N, rotation=180] [TOP: patternId=arrow_right, rotation=270] [RIGHT: patternId=L, rotation=180]\n [FRONT: patternId=?, rotation=0]\n [BOTTOM: patternId=triangle, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=plus, rotation=180\n- LEFT: patternId=N, rotation=180\n- TOP: patternId=arrow_right, rotation=270\n- RIGHT: patternId=L, rotation=180\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=triangle, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C475.json b/cube2/data/C475.json new file mode 100644 index 0000000000000000000000000000000000000000..7317b4c6503336f8cd1b2d1410d73e3870a77505 --- /dev/null +++ b/cube2/data/C475.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C475", + "name": "Goal Roll C475", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "C", + "rotation": 180 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "9", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "arrow_right", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "R", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "1", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "triangle", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "C", + "rotation": 180 + }, + "FRONT": { + "patternId": "9", + "rotation": 270 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 180 + }, + "BACK": { + "patternId": "R", + "rotation": 180 + }, + "LEFT": { + "patternId": "1", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "triangle", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 6, + "stepNumber": 7, + "patternId": "triangle", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C475/initial_net.png", + "targetTopFaceImage": "../images/C475/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 7, + "targetRotationOffset": 180, + "levelId": 475, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-475.json" + }, + "rollSequence": [ + "S", + "S", + "W", + "N", + "N", + "N", + "E", + "N", + "N", + "E" + ], + "observedPathFaces": [ + { + "patternId": "9", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "S", + "W", + "N", + "N", + "N", + "E", + "N", + "N", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "C", + "rotation": 180 + }, + "FRONT": { + "patternId": "9", + "rotation": 270 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 180 + }, + "BACK": { + "patternId": "R", + "rotation": 180 + }, + "LEFT": { + "patternId": "1", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "triangle", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C475\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=triangle, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=R, rotation=180]\n[LEFT: patternId=1, rotation=90] [TOP: patternId=C, rotation=180] [RIGHT: patternId=arrow_right, rotation=180]\n [FRONT: patternId=9, rotation=270]\n [BOTTOM: patternId=triangle, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=R, rotation=180\n- LEFT: patternId=1, rotation=90\n- TOP: patternId=C, rotation=180\n- RIGHT: patternId=arrow_right, rotation=180\n- FRONT: patternId=9, rotation=270\n- BOTTOM: patternId=triangle, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C476.json b/cube2/data/C476.json new file mode 100644 index 0000000000000000000000000000000000000000..0c20403d5dcc718497d7612d5707db8fcbfb3cf3 --- /dev/null +++ b/cube2/data/C476.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C476", + "name": "Goal Roll C476", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "5", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "F", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "Q", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "circle", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "I", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "9", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "F", + "rotation": 90 + }, + "RIGHT": { + "patternId": "Q", + "rotation": 270 + }, + "BACK": { + "patternId": "circle", + "rotation": 180 + }, + "LEFT": { + "patternId": "I", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "9", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "Q", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C476/initial_net.png", + "targetTopFaceImage": "../images/C476/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 270, + "levelId": 476, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-476.json" + }, + "rollSequence": [ + "W", + "W", + "S", + "W", + "S", + "N", + "N", + "W", + "N", + "N" + ], + "observedPathFaces": [ + { + "patternId": "I", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "I", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "W", + "S", + "W", + "S", + "N", + "N", + "W", + "N", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "F", + "rotation": 90 + }, + "RIGHT": { + "patternId": "Q", + "rotation": 270 + }, + "BACK": { + "patternId": "circle", + "rotation": 180 + }, + "LEFT": { + "patternId": "I", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "9", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C476\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=Q, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=circle, rotation=180]\n[LEFT: patternId=I, rotation=270] [TOP: patternId=5, rotation=90] [RIGHT: patternId=Q, rotation=270]\n [FRONT: patternId=F, rotation=90]\n [BOTTOM: patternId=9, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=circle, rotation=180\n- LEFT: patternId=I, rotation=270\n- TOP: patternId=5, rotation=90\n- RIGHT: patternId=Q, rotation=270\n- FRONT: patternId=F, rotation=90\n- BOTTOM: patternId=9, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C477.json b/cube2/data/C477.json new file mode 100644 index 0000000000000000000000000000000000000000..a2d155d3e1373ef5681ea17f8db192b639467551 --- /dev/null +++ b/cube2/data/C477.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C477", + "name": "Goal Roll C477", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "C", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "O", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "C", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "D", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "6", + "rotation": 180 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "C", + "rotation": 0 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "O", + "rotation": 270 + }, + "BACK": { + "patternId": "C", + "rotation": 90 + }, + "LEFT": { + "patternId": "D", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "6", + "rotation": 180 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 6, + "stepNumber": 7, + "patternId": "O", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C477/initial_net.png", + "targetTopFaceImage": "../images/C477/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 7, + "targetRotationOffset": 180, + "levelId": 477, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-477.json" + }, + "rollSequence": [ + "W", + "W", + "N", + "W", + "E", + "N", + "E", + "E", + "E", + "W" + ], + "observedPathFaces": [ + { + "patternId": "D", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "W", + "N", + "W", + "E", + "N", + "E", + "E", + "E", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "C", + "rotation": 0 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "O", + "rotation": 270 + }, + "BACK": { + "patternId": "C", + "rotation": 90 + }, + "LEFT": { + "patternId": "D", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "6", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C477\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=O, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=C, rotation=90]\n[LEFT: patternId=D, rotation=270] [TOP: patternId=C, rotation=0] [RIGHT: patternId=O, rotation=270]\n [FRONT: patternId=?, rotation=0]\n [BOTTOM: patternId=6, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=C, rotation=90\n- LEFT: patternId=D, rotation=270\n- TOP: patternId=C, rotation=0\n- RIGHT: patternId=O, rotation=270\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=6, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C478.json b/cube2/data/C478.json new file mode 100644 index 0000000000000000000000000000000000000000..6315b17677820729a9be31430c9f3ebea27822f7 --- /dev/null +++ b/cube2/data/C478.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C478", + "name": "Goal Roll C478", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "triangle", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "C", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "O", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "Y", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "D", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "?", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "triangle", + "rotation": 0 + }, + "FRONT": { + "patternId": "C", + "rotation": 0 + }, + "RIGHT": { + "patternId": "O", + "rotation": 270 + }, + "BACK": { + "patternId": "Y", + "rotation": 180 + }, + "LEFT": { + "patternId": "D", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 2, + "stepNumber": 3, + "patternId": "O", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C478/initial_net.png", + "targetTopFaceImage": "../images/C478/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 3, + "targetRotationOffset": 180, + "levelId": 478, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-478.json" + }, + "rollSequence": [ + "E", + "E", + "E", + "S", + "S", + "W", + "W", + "S", + "E", + "W" + ], + "observedPathFaces": [ + { + "patternId": "O", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "O", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Y", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Y", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "E", + "E", + "S", + "S", + "W", + "W", + "S", + "E", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "triangle", + "rotation": 0 + }, + "FRONT": { + "patternId": "C", + "rotation": 0 + }, + "RIGHT": { + "patternId": "O", + "rotation": 270 + }, + "BACK": { + "patternId": "Y", + "rotation": 180 + }, + "LEFT": { + "patternId": "D", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C478\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=O, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=Y, rotation=180]\n[LEFT: patternId=D, rotation=90] [TOP: patternId=triangle, rotation=0] [RIGHT: patternId=O, rotation=270]\n [FRONT: patternId=C, rotation=0]\n [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=Y, rotation=180\n- LEFT: patternId=D, rotation=90\n- TOP: patternId=triangle, rotation=0\n- RIGHT: patternId=O, rotation=270\n- FRONT: patternId=C, rotation=0\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C479.json b/cube2/data/C479.json new file mode 100644 index 0000000000000000000000000000000000000000..ec896e371d1cb79f073d1519b016298c7de97c41 --- /dev/null +++ b/cube2/data/C479.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C479", + "name": "Goal Roll C479", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "Z", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "Y", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "E", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "G", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "E", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "?", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "Z", + "rotation": 0 + }, + "FRONT": { + "patternId": "Y", + "rotation": 90 + }, + "RIGHT": { + "patternId": "E", + "rotation": 0 + }, + "BACK": { + "patternId": "G", + "rotation": 180 + }, + "LEFT": { + "patternId": "E", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 1, + "stepNumber": 2, + "patternId": "E", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C479/initial_net.png", + "targetTopFaceImage": "../images/C479/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 2, + "targetRotationOffset": 180, + "levelId": 479, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-479.json" + }, + "rollSequence": [ + "S", + "W", + "E", + "S", + "N", + "W", + "W", + "W", + "S", + "W" + ], + "observedPathFaces": [ + { + "patternId": "Y", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Y", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Y", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Y", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "W", + "E", + "S", + "N", + "W", + "W", + "W", + "S", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "Z", + "rotation": 0 + }, + "FRONT": { + "patternId": "Y", + "rotation": 90 + }, + "RIGHT": { + "patternId": "E", + "rotation": 0 + }, + "BACK": { + "patternId": "G", + "rotation": 180 + }, + "LEFT": { + "patternId": "E", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C479\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=E, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=G, rotation=180]\n[LEFT: patternId=E, rotation=0] [TOP: patternId=Z, rotation=0] [RIGHT: patternId=E, rotation=0]\n [FRONT: patternId=Y, rotation=90]\n [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=G, rotation=180\n- LEFT: patternId=E, rotation=0\n- TOP: patternId=Z, rotation=0\n- RIGHT: patternId=E, rotation=0\n- FRONT: patternId=Y, rotation=90\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C480.json b/cube2/data/C480.json new file mode 100644 index 0000000000000000000000000000000000000000..46fbc8ef89ec6f2b4a81321e813ce50c5df2d0cc --- /dev/null +++ b/cube2/data/C480.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C480", + "name": "Goal Roll C480", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "Q", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "E", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "diamond", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "N", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "F", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "8", + "rotation": 180 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "Q", + "rotation": 90 + }, + "FRONT": { + "patternId": "E", + "rotation": 180 + }, + "RIGHT": { + "patternId": "diamond", + "rotation": 180 + }, + "BACK": { + "patternId": "N", + "rotation": 90 + }, + "LEFT": { + "patternId": "F", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "8", + "rotation": 180 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 5, + "stepNumber": 6, + "patternId": "Q", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C480/initial_net.png", + "targetTopFaceImage": "../images/C480/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 6, + "targetRotationOffset": 180, + "levelId": 480, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-480.json" + }, + "rollSequence": [ + "W", + "N", + "W", + "E", + "S", + "E", + "W", + "N", + "N", + "N" + ], + "observedPathFaces": [ + { + "patternId": "F", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "8", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "N", + "W", + "E", + "S", + "E", + "W", + "N", + "N", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "Q", + "rotation": 90 + }, + "FRONT": { + "patternId": "E", + "rotation": 180 + }, + "RIGHT": { + "patternId": "diamond", + "rotation": 180 + }, + "BACK": { + "patternId": "N", + "rotation": 90 + }, + "LEFT": { + "patternId": "F", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "8", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C480\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=Q, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=N, rotation=90]\n[LEFT: patternId=F, rotation=270] [TOP: patternId=Q, rotation=90] [RIGHT: patternId=diamond, rotation=180]\n [FRONT: patternId=E, rotation=180]\n [BOTTOM: patternId=8, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=N, rotation=90\n- LEFT: patternId=F, rotation=270\n- TOP: patternId=Q, rotation=90\n- RIGHT: patternId=diamond, rotation=180\n- FRONT: patternId=E, rotation=180\n- BOTTOM: patternId=8, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C481.json b/cube2/data/C481.json new file mode 100644 index 0000000000000000000000000000000000000000..b418a9180d6452d83e4eea98f622954229bac337 --- /dev/null +++ b/cube2/data/C481.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C481", + "name": "Goal Roll C481", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "6", + "rotation": 180 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "square", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "M", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "S", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "K", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "?", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "6", + "rotation": 180 + }, + "FRONT": { + "patternId": "square", + "rotation": 270 + }, + "RIGHT": { + "patternId": "M", + "rotation": 90 + }, + "BACK": { + "patternId": "S", + "rotation": 90 + }, + "LEFT": { + "patternId": "K", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 5, + "stepNumber": 6, + "patternId": "square", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C481/initial_net.png", + "targetTopFaceImage": "../images/C481/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 6, + "targetRotationOffset": 270, + "levelId": 481, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-481.json" + }, + "rollSequence": [ + "N", + "W", + "W", + "N", + "E", + "N", + "W", + "N", + "E", + "E" + ], + "observedPathFaces": [ + { + "patternId": "S", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "W", + "W", + "N", + "E", + "N", + "W", + "N", + "E", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "6", + "rotation": 180 + }, + "FRONT": { + "patternId": "square", + "rotation": 270 + }, + "RIGHT": { + "patternId": "M", + "rotation": 90 + }, + "BACK": { + "patternId": "S", + "rotation": 90 + }, + "LEFT": { + "patternId": "K", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C481\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=square, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=S, rotation=90]\n[LEFT: patternId=K, rotation=180] [TOP: patternId=6, rotation=180] [RIGHT: patternId=M, rotation=90]\n [FRONT: patternId=square, rotation=270]\n [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=S, rotation=90\n- LEFT: patternId=K, rotation=180\n- TOP: patternId=6, rotation=180\n- RIGHT: patternId=M, rotation=90\n- FRONT: patternId=square, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C482.json b/cube2/data/C482.json new file mode 100644 index 0000000000000000000000000000000000000000..e5e6c5e5fbfda9d65492854e9f5f522a7caa1813 --- /dev/null +++ b/cube2/data/C482.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C482", + "name": "Goal Roll C482", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "L", + "rotation": 180 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "D", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "J", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "diamond", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "1", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "?", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "L", + "rotation": 180 + }, + "FRONT": { + "patternId": "D", + "rotation": 270 + }, + "RIGHT": { + "patternId": "J", + "rotation": 180 + }, + "BACK": { + "patternId": "diamond", + "rotation": 270 + }, + "LEFT": { + "patternId": "1", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 2, + "stepNumber": 3, + "patternId": "diamond", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C482/initial_net.png", + "targetTopFaceImage": "../images/C482/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 3, + "targetRotationOffset": 90, + "levelId": 482, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-482.json" + }, + "rollSequence": [ + "S", + "E", + "W", + "W", + "E", + "S", + "E", + "S", + "S", + "S" + ], + "observedPathFaces": [ + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "J", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "L", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "J", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "E", + "W", + "W", + "E", + "S", + "E", + "S", + "S", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "L", + "rotation": 180 + }, + "FRONT": { + "patternId": "D", + "rotation": 270 + }, + "RIGHT": { + "patternId": "J", + "rotation": 180 + }, + "BACK": { + "patternId": "diamond", + "rotation": 270 + }, + "LEFT": { + "patternId": "1", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C482\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=diamond, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=diamond, rotation=270]\n[LEFT: patternId=1, rotation=270] [TOP: patternId=L, rotation=180] [RIGHT: patternId=J, rotation=180]\n [FRONT: patternId=D, rotation=270]\n [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=diamond, rotation=270\n- LEFT: patternId=1, rotation=270\n- TOP: patternId=L, rotation=180\n- RIGHT: patternId=J, rotation=180\n- FRONT: patternId=D, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C483.json b/cube2/data/C483.json new file mode 100644 index 0000000000000000000000000000000000000000..200f45c94e23fb487098ed93e2ee37d4d90dfc19 --- /dev/null +++ b/cube2/data/C483.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C483", + "name": "Goal Roll C483", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "star", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "F", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "9", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "P", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "arrow_down", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "?", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "star", + "rotation": 0 + }, + "FRONT": { + "patternId": "F", + "rotation": 270 + }, + "RIGHT": { + "patternId": "9", + "rotation": 0 + }, + "BACK": { + "patternId": "P", + "rotation": 180 + }, + "LEFT": { + "patternId": "arrow_down", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 4, + "stepNumber": 5, + "patternId": "F", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C483/initial_net.png", + "targetTopFaceImage": "../images/C483/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 5, + "targetRotationOffset": 270, + "levelId": 483, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-483.json" + }, + "rollSequence": [ + "N", + "W", + "N", + "N", + "E", + "E", + "S", + "E", + "S", + "S" + ], + "observedPathFaces": [ + { + "patternId": "P", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_down", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_down", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "9", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "W", + "N", + "N", + "E", + "E", + "S", + "E", + "S", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "star", + "rotation": 0 + }, + "FRONT": { + "patternId": "F", + "rotation": 270 + }, + "RIGHT": { + "patternId": "9", + "rotation": 0 + }, + "BACK": { + "patternId": "P", + "rotation": 180 + }, + "LEFT": { + "patternId": "arrow_down", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C483\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=F, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=P, rotation=180]\n[LEFT: patternId=arrow_down, rotation=180] [TOP: patternId=star, rotation=0] [RIGHT: patternId=9, rotation=0]\n [FRONT: patternId=F, rotation=270]\n [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=P, rotation=180\n- LEFT: patternId=arrow_down, rotation=180\n- TOP: patternId=star, rotation=0\n- RIGHT: patternId=9, rotation=0\n- FRONT: patternId=F, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C484.json b/cube2/data/C484.json new file mode 100644 index 0000000000000000000000000000000000000000..7e1d74d2bb20dfe4816322c43efe18efbe8c63f0 --- /dev/null +++ b/cube2/data/C484.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C484", + "name": "Goal Roll C484", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "arrow_up", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "Q", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "diamond", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "R", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "R", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "square", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "arrow_up", + "rotation": 270 + }, + "FRONT": { + "patternId": "Q", + "rotation": 270 + }, + "RIGHT": { + "patternId": "diamond", + "rotation": 90 + }, + "BACK": { + "patternId": "R", + "rotation": 180 + }, + "LEFT": { + "patternId": "R", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 4, + "stepNumber": 5, + "patternId": "Q", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C484/initial_net.png", + "targetTopFaceImage": "../images/C484/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 5, + "targetRotationOffset": 270, + "levelId": 484, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-484.json" + }, + "rollSequence": [ + "N", + "N", + "N", + "E", + "E", + "N", + "E", + "W", + "N", + "S" + ], + "observedPathFaces": [ + { + "patternId": "R", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "N", + "N", + "E", + "E", + "N", + "E", + "W", + "N", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "arrow_up", + "rotation": 270 + }, + "FRONT": { + "patternId": "Q", + "rotation": 270 + }, + "RIGHT": { + "patternId": "diamond", + "rotation": 90 + }, + "BACK": { + "patternId": "R", + "rotation": 180 + }, + "LEFT": { + "patternId": "R", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C484\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=Q, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=R, rotation=180]\n[LEFT: patternId=R, rotation=180] [TOP: patternId=arrow_up, rotation=270] [RIGHT: patternId=diamond, rotation=90]\n [FRONT: patternId=Q, rotation=270]\n [BOTTOM: patternId=square, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=R, rotation=180\n- LEFT: patternId=R, rotation=180\n- TOP: patternId=arrow_up, rotation=270\n- RIGHT: patternId=diamond, rotation=90\n- FRONT: patternId=Q, rotation=270\n- BOTTOM: patternId=square, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C485.json b/cube2/data/C485.json new file mode 100644 index 0000000000000000000000000000000000000000..c775ccd2f229c3e868cae271b625018a92852811 --- /dev/null +++ b/cube2/data/C485.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C485", + "name": "Goal Roll C485", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "B", + "rotation": 180 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "P", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "D", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "K", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "heart", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_left", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "B", + "rotation": 180 + }, + "FRONT": { + "patternId": "P", + "rotation": 90 + }, + "RIGHT": { + "patternId": "D", + "rotation": 90 + }, + "BACK": { + "patternId": "K", + "rotation": 270 + }, + "LEFT": { + "patternId": "heart", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 9, + "stepNumber": 10, + "patternId": "D", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C485/initial_net.png", + "targetTopFaceImage": "../images/C485/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 10, + "targetRotationOffset": 90, + "levelId": 485, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-485.json" + }, + "rollSequence": [ + "S", + "E", + "E", + "S", + "W", + "S", + "W", + "N", + "N", + "N" + ], + "observedPathFaces": [ + { + "patternId": "P", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "P", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "E", + "E", + "S", + "W", + "S", + "W", + "N", + "N", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "B", + "rotation": 180 + }, + "FRONT": { + "patternId": "P", + "rotation": 90 + }, + "RIGHT": { + "patternId": "D", + "rotation": 90 + }, + "BACK": { + "patternId": "K", + "rotation": 270 + }, + "LEFT": { + "patternId": "heart", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C485\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=D, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=K, rotation=270]\n[LEFT: patternId=heart, rotation=0] [TOP: patternId=B, rotation=180] [RIGHT: patternId=D, rotation=90]\n [FRONT: patternId=P, rotation=90]\n [BOTTOM: patternId=arrow_left, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=K, rotation=270\n- LEFT: patternId=heart, rotation=0\n- TOP: patternId=B, rotation=180\n- RIGHT: patternId=D, rotation=90\n- FRONT: patternId=P, rotation=90\n- BOTTOM: patternId=arrow_left, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C486.json b/cube2/data/C486.json new file mode 100644 index 0000000000000000000000000000000000000000..39861bf5f010475cd9b0d86b8a55c6b018b97f4a --- /dev/null +++ b/cube2/data/C486.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C486", + "name": "Goal Roll C486", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "circle", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "H", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "W", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "2", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "K", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_left", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "circle", + "rotation": 270 + }, + "FRONT": { + "patternId": "H", + "rotation": 270 + }, + "RIGHT": { + "patternId": "W", + "rotation": 270 + }, + "BACK": { + "patternId": "2", + "rotation": 270 + }, + "LEFT": { + "patternId": "K", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 5, + "stepNumber": 6, + "patternId": "K", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C486/initial_net.png", + "targetTopFaceImage": "../images/C486/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 6, + "targetRotationOffset": 90, + "levelId": 486, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-486.json" + }, + "rollSequence": [ + "S", + "W", + "S", + "E", + "W", + "S", + "W", + "N", + "W", + "W" + ], + "observedPathFaces": [ + { + "patternId": "H", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "H", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "W", + "S", + "E", + "W", + "S", + "W", + "N", + "W", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "circle", + "rotation": 270 + }, + "FRONT": { + "patternId": "H", + "rotation": 270 + }, + "RIGHT": { + "patternId": "W", + "rotation": 270 + }, + "BACK": { + "patternId": "2", + "rotation": 270 + }, + "LEFT": { + "patternId": "K", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C486\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=K, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=2, rotation=270]\n[LEFT: patternId=K, rotation=270] [TOP: patternId=circle, rotation=270] [RIGHT: patternId=W, rotation=270]\n [FRONT: patternId=H, rotation=270]\n [BOTTOM: patternId=arrow_left, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=2, rotation=270\n- LEFT: patternId=K, rotation=270\n- TOP: patternId=circle, rotation=270\n- RIGHT: patternId=W, rotation=270\n- FRONT: patternId=H, rotation=270\n- BOTTOM: patternId=arrow_left, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C487.json b/cube2/data/C487.json new file mode 100644 index 0000000000000000000000000000000000000000..6ddf09e31d211fe102975ee52829e5b0158fe290 --- /dev/null +++ b/cube2/data/C487.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C487", + "name": "Goal Roll C487", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "arrow_right", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "E", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "D", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "arrow_up", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "D", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "?", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "arrow_right", + "rotation": 90 + }, + "FRONT": { + "patternId": "E", + "rotation": 90 + }, + "RIGHT": { + "patternId": "D", + "rotation": 180 + }, + "BACK": { + "patternId": "arrow_up", + "rotation": 0 + }, + "LEFT": { + "patternId": "D", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 7, + "stepNumber": 8, + "patternId": "arrow_up", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C487/initial_net.png", + "targetTopFaceImage": "../images/C487/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 8, + "targetRotationOffset": 180, + "levelId": 487, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-487.json" + }, + "rollSequence": [ + "S", + "E", + "S", + "E", + "N", + "N", + "N", + "S", + "N", + "N" + ], + "observedPathFaces": [ + { + "patternId": "E", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "D", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "E", + "S", + "E", + "N", + "N", + "N", + "S", + "N", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "arrow_right", + "rotation": 90 + }, + "FRONT": { + "patternId": "E", + "rotation": 90 + }, + "RIGHT": { + "patternId": "D", + "rotation": 180 + }, + "BACK": { + "patternId": "arrow_up", + "rotation": 0 + }, + "LEFT": { + "patternId": "D", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C487\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=arrow_up, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=arrow_up, rotation=0]\n[LEFT: patternId=D, rotation=0] [TOP: patternId=arrow_right, rotation=90] [RIGHT: patternId=D, rotation=180]\n [FRONT: patternId=E, rotation=90]\n [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=arrow_up, rotation=0\n- LEFT: patternId=D, rotation=0\n- TOP: patternId=arrow_right, rotation=90\n- RIGHT: patternId=D, rotation=180\n- FRONT: patternId=E, rotation=90\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C488.json b/cube2/data/C488.json new file mode 100644 index 0000000000000000000000000000000000000000..a207cee2d909e415b184b60fbf36d48587eb477e --- /dev/null +++ b/cube2/data/C488.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C488", + "name": "Goal Roll C488", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "Y", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "M", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "M", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "Q", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "X", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "Y", + "rotation": 0 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "M", + "rotation": 180 + }, + "BACK": { + "patternId": "M", + "rotation": 0 + }, + "LEFT": { + "patternId": "Q", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "X", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 6, + "stepNumber": 7, + "patternId": "M", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C488/initial_net.png", + "targetTopFaceImage": "../images/C488/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 7, + "targetRotationOffset": 180, + "levelId": 488, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-488.json" + }, + "rollSequence": [ + "N", + "W", + "S", + "S", + "S", + "E", + "S", + "E", + "N", + "N" + ], + "observedPathFaces": [ + { + "patternId": "M", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Y", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Q", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Y", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "W", + "S", + "S", + "S", + "E", + "S", + "E", + "N", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "Y", + "rotation": 0 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "M", + "rotation": 180 + }, + "BACK": { + "patternId": "M", + "rotation": 0 + }, + "LEFT": { + "patternId": "Q", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "X", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C488\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=M, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=M, rotation=0]\n[LEFT: patternId=Q, rotation=90] [TOP: patternId=Y, rotation=0] [RIGHT: patternId=M, rotation=180]\n [FRONT: patternId=?, rotation=0]\n [BOTTOM: patternId=X, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=M, rotation=0\n- LEFT: patternId=Q, rotation=90\n- TOP: patternId=Y, rotation=0\n- RIGHT: patternId=M, rotation=180\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=X, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C489.json b/cube2/data/C489.json new file mode 100644 index 0000000000000000000000000000000000000000..6dd0701e381ff12e4ad657b06f97cd9caa536792 --- /dev/null +++ b/cube2/data/C489.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C489", + "name": "Goal Roll C489", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "smile", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "M", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "diamond", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "X", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "6", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "smile", + "rotation": 0 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "M", + "rotation": 90 + }, + "BACK": { + "patternId": "diamond", + "rotation": 0 + }, + "LEFT": { + "patternId": "X", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "6", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 2, + "stepNumber": 3, + "patternId": "X", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C489/initial_net.png", + "targetTopFaceImage": "../images/C489/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 3, + "targetRotationOffset": 180, + "levelId": 489, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-489.json" + }, + "rollSequence": [ + "N", + "N", + "E", + "S", + "E", + "N", + "W", + "W", + "S", + "S" + ], + "observedPathFaces": [ + { + "patternId": "diamond", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "diamond", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "M", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "N", + "E", + "S", + "E", + "N", + "W", + "W", + "S", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "smile", + "rotation": 0 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "M", + "rotation": 90 + }, + "BACK": { + "patternId": "diamond", + "rotation": 0 + }, + "LEFT": { + "patternId": "X", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "6", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C489\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=X, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=diamond, rotation=0]\n[LEFT: patternId=X, rotation=0] [TOP: patternId=smile, rotation=0] [RIGHT: patternId=M, rotation=90]\n [FRONT: patternId=?, rotation=0]\n [BOTTOM: patternId=6, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=diamond, rotation=0\n- LEFT: patternId=X, rotation=0\n- TOP: patternId=smile, rotation=0\n- RIGHT: patternId=M, rotation=90\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=6, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C490.json b/cube2/data/C490.json new file mode 100644 index 0000000000000000000000000000000000000000..85d755c6b5ed2d3293c7916cf231bf4c1365068e --- /dev/null +++ b/cube2/data/C490.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C490", + "name": "Goal Roll C490", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "2", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "E", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "S", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "Z", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "N", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "5", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "2", + "rotation": 270 + }, + "FRONT": { + "patternId": "E", + "rotation": 0 + }, + "RIGHT": { + "patternId": "S", + "rotation": 90 + }, + "BACK": { + "patternId": "Z", + "rotation": 90 + }, + "LEFT": { + "patternId": "N", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "5", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 3, + "stepNumber": 4, + "patternId": "2", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C490/initial_net.png", + "targetTopFaceImage": "../images/C490/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 4, + "targetRotationOffset": 180, + "levelId": 490, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-490.json" + }, + "rollSequence": [ + "N", + "E", + "W", + "S", + "W", + "N", + "W", + "N", + "W", + "S" + ], + "observedPathFaces": [ + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "N", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "E", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "E", + "W", + "S", + "W", + "N", + "W", + "N", + "W", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "2", + "rotation": 270 + }, + "FRONT": { + "patternId": "E", + "rotation": 0 + }, + "RIGHT": { + "patternId": "S", + "rotation": 90 + }, + "BACK": { + "patternId": "Z", + "rotation": 90 + }, + "LEFT": { + "patternId": "N", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "5", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C490\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=2, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=Z, rotation=90]\n[LEFT: patternId=N, rotation=180] [TOP: patternId=2, rotation=270] [RIGHT: patternId=S, rotation=90]\n [FRONT: patternId=E, rotation=0]\n [BOTTOM: patternId=5, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=Z, rotation=90\n- LEFT: patternId=N, rotation=180\n- TOP: patternId=2, rotation=270\n- RIGHT: patternId=S, rotation=90\n- FRONT: patternId=E, rotation=0\n- BOTTOM: patternId=5, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C491.json b/cube2/data/C491.json new file mode 100644 index 0000000000000000000000000000000000000000..bac1450e7db34575d1812a69667e852112e44efb --- /dev/null +++ b/cube2/data/C491.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C491", + "name": "Goal Roll C491", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "4", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "X", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "B", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "Z", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_left", + "rotation": 180 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "4", + "rotation": 270 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "X", + "rotation": 0 + }, + "BACK": { + "patternId": "B", + "rotation": 0 + }, + "LEFT": { + "patternId": "Z", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 180 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 2, + "stepNumber": 3, + "patternId": "Z", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C491/initial_net.png", + "targetTopFaceImage": "../images/C491/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 3, + "targetRotationOffset": 270, + "levelId": 491, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-491.json" + }, + "rollSequence": [ + "E", + "E", + "W", + "W", + "N", + "W", + "N", + "E", + "E", + "S" + ], + "observedPathFaces": [ + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "E", + "W", + "W", + "N", + "W", + "N", + "E", + "E", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "4", + "rotation": 270 + }, + "FRONT": { + "patternId": "?", + "rotation": 0 + }, + "RIGHT": { + "patternId": "X", + "rotation": 0 + }, + "BACK": { + "patternId": "B", + "rotation": 0 + }, + "LEFT": { + "patternId": "Z", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "arrow_left", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C491\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=Z, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=B, rotation=0]\n[LEFT: patternId=Z, rotation=270] [TOP: patternId=4, rotation=270] [RIGHT: patternId=X, rotation=0]\n [FRONT: patternId=?, rotation=0]\n [BOTTOM: patternId=arrow_left, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=B, rotation=0\n- LEFT: patternId=Z, rotation=270\n- TOP: patternId=4, rotation=270\n- RIGHT: patternId=X, rotation=0\n- FRONT: patternId=?, rotation=0\n- BOTTOM: patternId=arrow_left, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C492.json b/cube2/data/C492.json new file mode 100644 index 0000000000000000000000000000000000000000..2e1f1176b02027d81f54c9f16708845fd406c653 --- /dev/null +++ b/cube2/data/C492.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C492", + "name": "Goal Roll C492", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "K", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "star", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "X", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "F", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "F", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "?", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "K", + "rotation": 270 + }, + "FRONT": { + "patternId": "star", + "rotation": 270 + }, + "RIGHT": { + "patternId": "X", + "rotation": 270 + }, + "BACK": { + "patternId": "F", + "rotation": 0 + }, + "LEFT": { + "patternId": "F", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "X", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C492/initial_net.png", + "targetTopFaceImage": "../images/C492/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 270, + "levelId": 492, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-492.json" + }, + "rollSequence": [ + "N", + "W", + "N", + "N", + "E", + "E", + "S", + "E", + "N", + "N" + ], + "observedPathFaces": [ + { + "patternId": "F", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "W", + "N", + "N", + "E", + "E", + "S", + "E", + "N", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "K", + "rotation": 270 + }, + "FRONT": { + "patternId": "star", + "rotation": 270 + }, + "RIGHT": { + "patternId": "X", + "rotation": 270 + }, + "BACK": { + "patternId": "F", + "rotation": 0 + }, + "LEFT": { + "patternId": "F", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C492\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=X, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=F, rotation=0]\n[LEFT: patternId=F, rotation=180] [TOP: patternId=K, rotation=270] [RIGHT: patternId=X, rotation=270]\n [FRONT: patternId=star, rotation=270]\n [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=F, rotation=0\n- LEFT: patternId=F, rotation=180\n- TOP: patternId=K, rotation=270\n- RIGHT: patternId=X, rotation=270\n- FRONT: patternId=star, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C493.json b/cube2/data/C493.json new file mode 100644 index 0000000000000000000000000000000000000000..67dcf78ed088e84f82cbaf818b079da8bb91d49f --- /dev/null +++ b/cube2/data/C493.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C493", + "name": "Goal Roll C493", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "5", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "B", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "arrow_up", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "W", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "star", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "?", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "B", + "rotation": 270 + }, + "RIGHT": { + "patternId": "arrow_up", + "rotation": 0 + }, + "BACK": { + "patternId": "W", + "rotation": 180 + }, + "LEFT": { + "patternId": "star", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "W", + "rotation": 90 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C493/initial_net.png", + "targetTopFaceImage": "../images/C493/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 270, + "levelId": 493, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-493.json" + }, + "rollSequence": [ + "E", + "N", + "N", + "N", + "S", + "E", + "S", + "W", + "W", + "N" + ], + "observedPathFaces": [ + { + "patternId": "arrow_up", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "star", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "B", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "5", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "N", + "N", + "N", + "S", + "E", + "S", + "W", + "W", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "5", + "rotation": 90 + }, + "FRONT": { + "patternId": "B", + "rotation": 270 + }, + "RIGHT": { + "patternId": "arrow_up", + "rotation": 0 + }, + "BACK": { + "patternId": "W", + "rotation": 180 + }, + "LEFT": { + "patternId": "star", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "?", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C493\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=W, rotation=90\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=W, rotation=180]\n[LEFT: patternId=star, rotation=90] [TOP: patternId=5, rotation=90] [RIGHT: patternId=arrow_up, rotation=0]\n [FRONT: patternId=B, rotation=270]\n [BOTTOM: patternId=?, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=W, rotation=180\n- LEFT: patternId=star, rotation=90\n- TOP: patternId=5, rotation=90\n- RIGHT: patternId=arrow_up, rotation=0\n- FRONT: patternId=B, rotation=270\n- BOTTOM: patternId=?, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C494.json b/cube2/data/C494.json new file mode 100644 index 0000000000000000000000000000000000000000..048028e05630d7b57226270130d251f977dc0d6b --- /dev/null +++ b/cube2/data/C494.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C494", + "name": "Goal Roll C494", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "S", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "plus", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "T", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "smile", + "rotation": 180 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "S", + "rotation": 180 + }, + "RIGHT": { + "patternId": "plus", + "rotation": 270 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "T", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "smile", + "rotation": 180 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 7, + "stepNumber": 8, + "patternId": "T", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C494/initial_net.png", + "targetTopFaceImage": "../images/C494/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 8, + "targetRotationOffset": 180, + "levelId": 494, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-494.json" + }, + "rollSequence": [ + "W", + "S", + "S", + "N", + "N", + "E", + "S", + "E", + "W", + "N" + ], + "observedPathFaces": [ + { + "patternId": "T", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "plus", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "T", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "plus", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "S", + "S", + "N", + "N", + "E", + "S", + "E", + "W", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "S", + "rotation": 180 + }, + "RIGHT": { + "patternId": "plus", + "rotation": 270 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "T", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "smile", + "rotation": 180 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C494\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=T, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=?, rotation=0]\n[LEFT: patternId=T, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=plus, rotation=270]\n [FRONT: patternId=S, rotation=180]\n [BOTTOM: patternId=smile, rotation=180]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=T, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=plus, rotation=270\n- FRONT: patternId=S, rotation=180\n- BOTTOM: patternId=smile, rotation=180\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C495.json b/cube2/data/C495.json new file mode 100644 index 0000000000000000000000000000000000000000..e08c1fa099ca2d63490b56345076083aa96ea6da --- /dev/null +++ b/cube2/data/C495.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C495", + "name": "Goal Roll C495", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "K", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "S", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "heart", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "X", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "circle", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "R", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "K", + "rotation": 270 + }, + "FRONT": { + "patternId": "S", + "rotation": 90 + }, + "RIGHT": { + "patternId": "heart", + "rotation": 180 + }, + "BACK": { + "patternId": "X", + "rotation": 0 + }, + "LEFT": { + "patternId": "circle", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "R", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "heart", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C495/initial_net.png", + "targetTopFaceImage": "../images/C495/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 90, + "levelId": 495, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-495.json" + }, + "rollSequence": [ + "N", + "N", + "S", + "W", + "S", + "S", + "N", + "W", + "N", + "W" + ], + "observedPathFaces": [ + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "X", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "R", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "K", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "N", + "S", + "W", + "S", + "S", + "N", + "W", + "N", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "K", + "rotation": 270 + }, + "FRONT": { + "patternId": "S", + "rotation": 90 + }, + "RIGHT": { + "patternId": "heart", + "rotation": 180 + }, + "BACK": { + "patternId": "X", + "rotation": 0 + }, + "LEFT": { + "patternId": "circle", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "R", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C495\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=heart, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=X, rotation=0]\n[LEFT: patternId=circle, rotation=0] [TOP: patternId=K, rotation=270] [RIGHT: patternId=heart, rotation=180]\n [FRONT: patternId=S, rotation=90]\n [BOTTOM: patternId=R, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=X, rotation=0\n- LEFT: patternId=circle, rotation=0\n- TOP: patternId=K, rotation=270\n- RIGHT: patternId=heart, rotation=180\n- FRONT: patternId=S, rotation=90\n- BOTTOM: patternId=R, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C496.json b/cube2/data/C496.json new file mode 100644 index 0000000000000000000000000000000000000000..387b0f4bc59504f20d660c0606face42d84386c8 --- /dev/null +++ b/cube2/data/C496.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C496", + "name": "Goal Roll C496", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "Z", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "6", + "rotation": 180 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "Z", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "2", + "rotation": 90 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "1", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "G", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "Z", + "rotation": 0 + }, + "FRONT": { + "patternId": "6", + "rotation": 180 + }, + "RIGHT": { + "patternId": "Z", + "rotation": 0 + }, + "BACK": { + "patternId": "2", + "rotation": 90 + }, + "LEFT": { + "patternId": "1", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 9, + "stepNumber": 10, + "patternId": "1", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C496/initial_net.png", + "targetTopFaceImage": "../images/C496/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 10, + "targetRotationOffset": 270, + "levelId": 496, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-496.json" + }, + "rollSequence": [ + "E", + "S", + "S", + "N", + "N", + "E", + "N", + "E", + "N", + "N" + ], + "observedPathFaces": [ + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "6", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "S", + "S", + "N", + "N", + "E", + "N", + "E", + "N", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "Z", + "rotation": 0 + }, + "FRONT": { + "patternId": "6", + "rotation": 180 + }, + "RIGHT": { + "patternId": "Z", + "rotation": 0 + }, + "BACK": { + "patternId": "2", + "rotation": 90 + }, + "LEFT": { + "patternId": "1", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "G", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C496\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=1, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=2, rotation=90]\n[LEFT: patternId=1, rotation=0] [TOP: patternId=Z, rotation=0] [RIGHT: patternId=Z, rotation=0]\n [FRONT: patternId=6, rotation=180]\n [BOTTOM: patternId=G, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=2, rotation=90\n- LEFT: patternId=1, rotation=0\n- TOP: patternId=Z, rotation=0\n- RIGHT: patternId=Z, rotation=0\n- FRONT: patternId=6, rotation=180\n- BOTTOM: patternId=G, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C497.json b/cube2/data/C497.json new file mode 100644 index 0000000000000000000000000000000000000000..6d8093bb24dd6284832a9e8c7103b588b9c8af45 --- /dev/null +++ b/cube2/data/C497.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C497", + "name": "Goal Roll C497", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "3", + "rotation": 270 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "Z", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "2", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "F", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "4", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "2", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "3", + "rotation": 270 + }, + "FRONT": { + "patternId": "Z", + "rotation": 0 + }, + "RIGHT": { + "patternId": "2", + "rotation": 90 + }, + "BACK": { + "patternId": "F", + "rotation": 180 + }, + "LEFT": { + "patternId": "4", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "2", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 9, + "stepNumber": 10, + "patternId": "F", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C497/initial_net.png", + "targetTopFaceImage": "../images/C497/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 10, + "targetRotationOffset": 270, + "levelId": 497, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-497.json" + }, + "rollSequence": [ + "S", + "E", + "N", + "N", + "W", + "S", + "W", + "S", + "W", + "W" + ], + "observedPathFaces": [ + { + "patternId": "Z", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "3", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "Z", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "S", + "E", + "N", + "N", + "W", + "S", + "W", + "S", + "W", + "W" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "3", + "rotation": 270 + }, + "FRONT": { + "patternId": "Z", + "rotation": 0 + }, + "RIGHT": { + "patternId": "2", + "rotation": 90 + }, + "BACK": { + "patternId": "F", + "rotation": 180 + }, + "LEFT": { + "patternId": "4", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "2", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C497\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=F, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=F, rotation=180]\n[LEFT: patternId=4, rotation=270] [TOP: patternId=3, rotation=270] [RIGHT: patternId=2, rotation=90]\n [FRONT: patternId=Z, rotation=0]\n [BOTTOM: patternId=2, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=F, rotation=180\n- LEFT: patternId=4, rotation=270\n- TOP: patternId=3, rotation=270\n- RIGHT: patternId=2, rotation=90\n- FRONT: patternId=Z, rotation=0\n- BOTTOM: patternId=2, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C498.json b/cube2/data/C498.json new file mode 100644 index 0000000000000000000000000000000000000000..8a42093ab6eab4430aa92c935f4b2b0bfbe1a749 --- /dev/null +++ b/cube2/data/C498.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C498", + "name": "Goal Roll C498", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "arrow_left", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "J", + "rotation": 270 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "circle", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "heart", + "rotation": 180 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "triangle", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_up", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "arrow_left", + "rotation": 90 + }, + "FRONT": { + "patternId": "J", + "rotation": 270 + }, + "RIGHT": { + "patternId": "circle", + "rotation": 0 + }, + "BACK": { + "patternId": "heart", + "rotation": 180 + }, + "LEFT": { + "patternId": "triangle", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 8, + "stepNumber": 9, + "patternId": "arrow_left", + "rotation": 180 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C498/initial_net.png", + "targetTopFaceImage": "../images/C498/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 9, + "targetRotationOffset": 180, + "levelId": 498, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-498.json" + }, + "rollSequence": [ + "E", + "S", + "S", + "S", + "W", + "E", + "E", + "S", + "S", + "N" + ], + "observedPathFaces": [ + { + "patternId": "circle", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "J", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "triangle", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "heart", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "circle", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "S", + "S", + "S", + "W", + "E", + "E", + "S", + "S", + "N" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "arrow_left", + "rotation": 90 + }, + "FRONT": { + "patternId": "J", + "rotation": 270 + }, + "RIGHT": { + "patternId": "circle", + "rotation": 0 + }, + "BACK": { + "patternId": "heart", + "rotation": 180 + }, + "LEFT": { + "patternId": "triangle", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C498\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=arrow_left, rotation=180\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=heart, rotation=180]\n[LEFT: patternId=triangle, rotation=90] [TOP: patternId=arrow_left, rotation=90] [RIGHT: patternId=circle, rotation=0]\n [FRONT: patternId=J, rotation=270]\n [BOTTOM: patternId=arrow_up, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=heart, rotation=180\n- LEFT: patternId=triangle, rotation=90\n- TOP: patternId=arrow_left, rotation=90\n- RIGHT: patternId=circle, rotation=0\n- FRONT: patternId=J, rotation=270\n- BOTTOM: patternId=arrow_up, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C499.json b/cube2/data/C499.json new file mode 100644 index 0000000000000000000000000000000000000000..473ef5d8d261c1a093e6b89226d79d0d842abe95 --- /dev/null +++ b/cube2/data/C499.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C499", + "name": "Goal Roll C499", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "S", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "smile", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "2", + "rotation": 90 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "4", + "rotation": 180 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "square", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "S", + "rotation": 90 + }, + "FRONT": { + "patternId": "smile", + "rotation": 0 + }, + "RIGHT": { + "patternId": "2", + "rotation": 90 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "4", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 4, + "stepNumber": 5, + "patternId": "S", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C499/initial_net.png", + "targetTopFaceImage": "../images/C499/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 5, + "targetRotationOffset": 270, + "levelId": 499, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-499.json" + }, + "rollSequence": [ + "E", + "E", + "S", + "W", + "S", + "E", + "N", + "E", + "E", + "S" + ], + "observedPathFaces": [ + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "2", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "4", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "E", + "S", + "W", + "S", + "E", + "N", + "E", + "E", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "S", + "rotation": 90 + }, + "FRONT": { + "patternId": "smile", + "rotation": 0 + }, + "RIGHT": { + "patternId": "2", + "rotation": 90 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "4", + "rotation": 180 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C499\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=S, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=?, rotation=0]\n[LEFT: patternId=4, rotation=180] [TOP: patternId=S, rotation=90] [RIGHT: patternId=2, rotation=90]\n [FRONT: patternId=smile, rotation=0]\n [BOTTOM: patternId=square, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=4, rotation=180\n- TOP: patternId=S, rotation=90\n- RIGHT: patternId=2, rotation=90\n- FRONT: patternId=smile, rotation=0\n- BOTTOM: patternId=square, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C500.json b/cube2/data/C500.json new file mode 100644 index 0000000000000000000000000000000000000000..43965805130b72debd2514569e5d8284b6bd0c5d --- /dev/null +++ b/cube2/data/C500.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C500", + "name": "Goal Roll C500", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "smile", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "1", + "rotation": 0 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "?", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "arrow_up", + "rotation": 0 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "arrow_up", + "rotation": 270 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "smile", + "rotation": 0 + }, + "RIGHT": { + "patternId": "1", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "arrow_up", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 270 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 9, + "stepNumber": 10, + "patternId": "1", + "rotation": 270 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C500/initial_net.png", + "targetTopFaceImage": "../images/C500/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 10, + "targetRotationOffset": 90, + "levelId": 500, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-500.json" + }, + "rollSequence": [ + "E", + "S", + "N", + "S", + "S", + "W", + "N", + "W", + "S", + "S" + ], + "observedPathFaces": [ + { + "patternId": "1", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "smile", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "1", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_up", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "E", + "S", + "N", + "S", + "S", + "W", + "N", + "W", + "S", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "?", + "rotation": 0 + }, + "FRONT": { + "patternId": "smile", + "rotation": 0 + }, + "RIGHT": { + "patternId": "1", + "rotation": 0 + }, + "BACK": { + "patternId": "?", + "rotation": 0 + }, + "LEFT": { + "patternId": "arrow_up", + "rotation": 0 + }, + "BOTTOM": { + "patternId": "arrow_up", + "rotation": 270 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C500\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=1, rotation=270\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=?, rotation=0]\n[LEFT: patternId=arrow_up, rotation=0] [TOP: patternId=?, rotation=0] [RIGHT: patternId=1, rotation=0]\n [FRONT: patternId=smile, rotation=0]\n [BOTTOM: patternId=arrow_up, rotation=270]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=?, rotation=0\n- LEFT: patternId=arrow_up, rotation=0\n- TOP: patternId=?, rotation=0\n- RIGHT: patternId=1, rotation=0\n- FRONT: patternId=smile, rotation=0\n- BOTTOM: patternId=arrow_up, rotation=270\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C501.json b/cube2/data/C501.json new file mode 100644 index 0000000000000000000000000000000000000000..476ba83b3da6b2cfa93797c0200a226e3a2e8b1c --- /dev/null +++ b/cube2/data/C501.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C501", + "name": "Goal Roll C501", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "W", + "rotation": 0 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "arrow_left", + "rotation": 0 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "arrow_right", + "rotation": 180 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "J", + "rotation": 0 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "A", + "rotation": 90 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "square", + "rotation": 0 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "W", + "rotation": 0 + }, + "FRONT": { + "patternId": "arrow_left", + "rotation": 0 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 180 + }, + "BACK": { + "patternId": "J", + "rotation": 0 + }, + "LEFT": { + "patternId": "A", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 0 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 0, + "stepNumber": 1, + "patternId": "arrow_right", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C501/initial_net.png", + "targetTopFaceImage": "../images/C501/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 1, + "targetRotationOffset": 270, + "levelId": 501, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-501.json" + }, + "rollSequence": [ + "W", + "W", + "W", + "S", + "S", + "W", + "W", + "N", + "E", + "E" + ], + "observedPathFaces": [ + { + "patternId": "A", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "W", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 90, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_left", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "square", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "J", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "W", + "W", + "W", + "S", + "S", + "W", + "W", + "N", + "E", + "E" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "W", + "rotation": 0 + }, + "FRONT": { + "patternId": "arrow_left", + "rotation": 0 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 180 + }, + "BACK": { + "patternId": "J", + "rotation": 0 + }, + "LEFT": { + "patternId": "A", + "rotation": 90 + }, + "BOTTOM": { + "patternId": "square", + "rotation": 0 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C501\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=arrow_right, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=J, rotation=0]\n[LEFT: patternId=A, rotation=90] [TOP: patternId=W, rotation=0] [RIGHT: patternId=arrow_right, rotation=180]\n [FRONT: patternId=arrow_left, rotation=0]\n [BOTTOM: patternId=square, rotation=0]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=J, rotation=0\n- LEFT: patternId=A, rotation=90\n- TOP: patternId=W, rotation=0\n- RIGHT: patternId=arrow_right, rotation=180\n- FRONT: patternId=arrow_left, rotation=0\n- BOTTOM: patternId=square, rotation=0\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cube2/data/C502.json b/cube2/data/C502.json new file mode 100644 index 0000000000000000000000000000000000000000..ca342456e22671056d3fc6463b80c7644c35e17b --- /dev/null +++ b/cube2/data/C502.json @@ -0,0 +1,246 @@ +{ + "taskType": "roll_to_target_top_face", + "code": "C502", + "name": "Goal Roll C502", + "description": "Given the initial cross net and the target top-face image, output a roll sequence that moves the cube to the target state.", + "instructions": { + "en": "You are given the initial state of the cube as a cross-shaped net. This net is the unfolded outer surface of the folded cube. Each visible cell is labeled as TOP, BOTTOM, FRONT, BACK, LEFT, or RIGHT. The number under each visible face is the clockwise rotation in degrees from the original upright pattern. Output a roll sequence so that, at the end, the cube's top face seen from above exactly matches the target image.", + "directionVocabulary": { + "N": "Up", + "S": "Down", + "W": "Left", + "E": "Right" + } + }, + "initialCube": { + "net": { + "layout": "reconstruction_cross", + "faceOrder": [ + "TOP", + "FRONT", + "RIGHT", + "BACK", + "LEFT", + "BOTTOM" + ], + "cells": [ + { + "faceKey": "TOP", + "faceLabelZh": "TOP", + "row": 1, + "col": 1, + "patternId": "A", + "rotation": 90 + }, + { + "faceKey": "FRONT", + "faceLabelZh": "FRONT", + "row": 2, + "col": 1, + "patternId": "G", + "rotation": 90 + }, + { + "faceKey": "RIGHT", + "faceLabelZh": "RIGHT", + "row": 1, + "col": 2, + "patternId": "arrow_right", + "rotation": 270 + }, + { + "faceKey": "BACK", + "faceLabelZh": "BACK", + "row": 0, + "col": 1, + "patternId": "F", + "rotation": 270 + }, + { + "faceKey": "LEFT", + "faceLabelZh": "LEFT", + "row": 1, + "col": 0, + "patternId": "S", + "rotation": 270 + }, + { + "faceKey": "BOTTOM", + "faceLabelZh": "BOTTOM", + "row": 3, + "col": 1, + "patternId": "C", + "rotation": 90 + } + ] + }, + "solutionFaces": { + "TOP": { + "patternId": "A", + "rotation": 90 + }, + "FRONT": { + "patternId": "G", + "rotation": 90 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 270 + }, + "BACK": { + "patternId": "F", + "rotation": 270 + }, + "LEFT": { + "patternId": "S", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "C", + "rotation": 90 + } + } + }, + "targetTopFace": { + "sourceObservationIndex": 4, + "stepNumber": 5, + "patternId": "A", + "rotation": 0 + }, + "answers": { + "directions": [], + "moveCount": 0, + "referenceValid": false + }, + "imagePaths": { + "initialNetImage": "../images/C502/initial_net.png", + "targetTopFaceImage": "../images/C502/target_top_face.png" + }, + "metadata": { + "difficulty": 5, + "tier": 5, + "targetStepNumber": 5, + "targetRotationOffset": 180, + "levelId": 502, + "moveCount": 10, + "sourceLevelPath": "levels/reconstruct/generated-502.json" + }, + "rollSequence": [ + "N", + "E", + "N", + "E", + "E", + "W", + "S", + "E", + "E", + "S" + ], + "observedPathFaces": [ + { + "patternId": "F", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "A", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "G", + "rotation": 0, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "arrow_right", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "C", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "S", + "rotation": 270, + "flipHorizontal": false, + "flipVertical": true + }, + { + "patternId": "F", + "rotation": 180, + "flipHorizontal": false, + "flipVertical": true + } + ], + "answer": { + "directions": [ + "N", + "E", + "N", + "E", + "E", + "W", + "S", + "E", + "E", + "S" + ] + }, + "legacy_answer": { + "TOP": { + "patternId": "A", + "rotation": 90 + }, + "FRONT": { + "patternId": "G", + "rotation": 90 + }, + "RIGHT": { + "patternId": "arrow_right", + "rotation": 270 + }, + "BACK": { + "patternId": "F", + "rotation": 270 + }, + "LEFT": { + "patternId": "S", + "rotation": 270 + }, + "BOTTOM": { + "patternId": "C", + "rotation": 90 + } + }, + "prompt": { + "system": "You are a cube-rolling sequence solver. Given a cube whose initial outer-surface configuration is shown as a cross net and a target top-face image, output one valid sequence of N/S/E/W rolls so that the cube's top face after the sequence matches the target.\n\nYou will receive: (a) one initial cross-net image showing the visible faces of the unfolded cube with their patternIds and rotations, (b) one target top-face image showing the desired final top-face pattern and orientation, and (c) a structured text body listing every visible net cell, the target patternId+rotation, the direction vocabulary, and the maximum allowed sequence length.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the directions schema described in section 8 of the user prompt. Multiple sequences may be valid — output any one that solves the puzzle. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident sequence, still output your best-effort FINAL_JSON line with at least one direction token; the only structurally invalid output is no FINAL_JSON line at all. Never refuse, never return prose only.", + "user": "## 1. TASK\nOutput one sequence of rolls so that, at the end of the sequence, the cube's top face seen from above matches the target top face exactly (both patternId and rotation).\nThe puzzle is solved when the engine simulates your sequence on the initial cube and the resulting top-face pattern equals the target.\n\n## 2. WORLD MODEL\n- Cube: a unit cube with one pattern printed on each of its six outer faces. The faces are named TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT in the world frame.\n- Cross net: the unfolded outer surface laid flat. Each cell is one face; its label tells you which face it is and its number under the patternId is the clockwise rotation in degrees from the original upright pattern.\n- Roll: tipping the cube 90° about one of its bottom edges into an adjacent grid cell. After a roll, the face that was on the side becomes the new top, the previous top moves to the opposite side, and so on.\n- Direction tokens: N (roll up / north), S (roll down / south), E (roll right / east), W (roll left / west). The direction is always relative to the world frame, not the cube's current orientation.\n- Target top face: the desired patternId and rotation of whichever face ends up on top after the sequence.\n\n## 3. VISUAL LEGEND\n- Image 1: initial cross-net of the cube. The TOP/BOTTOM/FRONT/BACK/LEFT/RIGHT cells are arranged in a cross. Each visible face shows its patternId and a number indicating the clockwise rotation in degrees from the upright orientation.\n- Image 2: the target top-face image, showing the patternId and rotation the cube's top face must reach.\n- Coordinates: the cube starts at (0, 0). N decrements y (up on screen), S increments y, E increments x (right), W decrements x.\n\n## 4. INPUT FIELDS\n- sample_id: C502\n- task_type: roll_to_target_top_face\n- difficulty: 5\n- target_top_face: patternId=A, rotation=0\n- max_direction_steps: 20\n- initial_net_layout (text view, with the BACK / LEFT-TOP-RIGHT / FRONT / BOTTOM rows of the cross):\n [BACK: patternId=F, rotation=270]\n[LEFT: patternId=S, rotation=270] [TOP: patternId=A, rotation=90] [RIGHT: patternId=arrow_right, rotation=270]\n [FRONT: patternId=G, rotation=90]\n [BOTTOM: patternId=C, rotation=90]\n- initial_net_cells (explicit list of every visible face):\n- BACK: patternId=F, rotation=270\n- LEFT: patternId=S, rotation=270\n- TOP: patternId=A, rotation=90\n- RIGHT: patternId=arrow_right, rotation=270\n- FRONT: patternId=G, rotation=90\n- BOTTOM: patternId=C, rotation=90\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered list of direction tokens:\n- direction: one of {\"N\", \"S\", \"E\", \"W\"}.\n- Sequence length is the number of rolls. The maximum allowed length for this task is `max_direction_steps`.\n- Multiple sequences may produce the same target top face; any one of them counts as correct.\n\n## 6. CONSTRAINTS\n- Each direction token must be exactly one of N, S, E, W (uppercase).\n- The sequence length must be between 1 and `max_direction_steps` inclusive.\n- The sequence must be deterministic: no probabilistic or \"either-or\" entries. One direction per step.\n- The engine evaluates by simulating your sequence on the initial cube; do not output any other JSON keys.\n\n## 7. SOLVING ADVICE\n- Track which face is currently on top after each roll. A roll N moves the FRONT face to the new TOP, S moves BACK to TOP, E moves LEFT to TOP, W moves RIGHT to TOP (with appropriate rotation).\n- Confirm the rotation of the target top face — getting the patternId right but the rotation wrong is still a fail. Each roll N or S adjusts the cube's local-frame rotation by 0/180; each roll E or W adjusts it by ±90.\n- A reference sequence may be inferable from the imprint history if the data includes one, but you do not need to copy it; output any valid sequence.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"directions\":[\"\", ...]}\n- directions: array of direction tokens.\n- Each token: one of `\"N\"`, `\"S\"`, `\"E\"`, `\"W\"`.\n- Length: 1..20.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-070.json b/cutrope/data/rope-070.json new file mode 100644 index 0000000000000000000000000000000000000000..26ef5d8fc3810ac25684b0fce549e043732b1f63 --- /dev/null +++ b/cutrope/data/rope-070.json @@ -0,0 +1,172 @@ +{ + "schema_version": 1, + "level_id": "rope-070", + "level_file": "data/task/rope-070.json", + "video": { + "path": "data/video/rope-070.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "candy": 1, + "grab_or_rope_anchor": 6, + "gravity_button": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 52, + "x": 99, + "y": 414 + }, + { + "name": 100, + "x": 31, + "y": 342, + "length": 60, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 156, + "y": 342, + "length": 60, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 283, + "y": 344, + "length": 100, + "wheel": false, + "radius": 60, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 286, + "y": 181, + "length": 100, + "wheel": false, + "radius": 60, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 159, + "y": 182, + "length": 100, + "wheel": false, + "radius": 60, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 32, + "y": 183, + "length": 100, + "wheel": false, + "radius": 60, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 2, + "x": 41, + "y": 65 + }, + { + "name": 3, + "x": 224, + "y": 110, + "timeout": -1 + }, + { + "name": 3, + "x": 95, + "y": 277, + "timeout": -1 + }, + { + "name": 3, + "x": 224, + "y": 435, + "timeout": -1 + }, + { + "name": 53, + "x": 97, + "y": 345 + } + ], + "mirroredFrom": "08-08.json" + }, + "reference_solution": "toggle_gravity when candy_still for 0.3 and candy_near 810,930,60\ncut_rope 1 when candy_still for 0.3 and candy_near 810,610,60\ncut_rope 0\ncut_rope 5 when candy_still for 0.3 and candy_near 810,210,60\ntoggle_gravity when candy_near 1080,190,60\ncut_rope 3 when candy_still for 0.3 and candy_near 1100,610,60\ncut_rope 4\ntoggle_gravity when candy_y > 960\ncut_rope 2 when candy_y < 520", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T18:05:27.836Z" + }, + "answer": { + "commands": "toggle_gravity when candy_still for 0.3 and candy_near 810,930,60\ncut_rope 1 when candy_still for 0.3 and candy_near 810,610,60\ncut_rope 0\ncut_rope 5 when candy_still for 0.3 and candy_near 810,210,60\ntoggle_gravity when candy_near 1080,190,60\ncut_rope 3 when candy_still for 0.3 and candy_near 1100,610,60\ncut_rope 4\ntoggle_gravity when candy_y > 960\ncut_rope 2 when candy_y < 520", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "toggle_gravity when candy_still for 0.3 and candy_near 810,930,60\ncut_rope 1 when candy_still for 0.3 and candy_near 810,610,60\ncut_rope 0\ncut_rope 5 when candy_still for 0.3 and candy_near 810,210,60\ntoggle_gravity when candy_near 1080,190,60\ncut_rope 3 when candy_still for 0.3 and candy_near 1100,610,60\ncut_rope 4\ntoggle_gravity when candy_y > 960\ncut_rope 2 when candy_y < 520", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-070\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 6\n - gravity switch: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Gravity switch: `toggle_gravity` reverses or rotates gravity. Often triggered after the candy crosses a coordinate threshold.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-071.json b/cutrope/data/rope-071.json new file mode 100644 index 0000000000000000000000000000000000000000..965a7c11a4f3ccd9ba8ecd9b92cde807ea92e303 --- /dev/null +++ b/cutrope/data/rope-071.json @@ -0,0 +1,216 @@ +{ + "schema_version": 1, + "level_id": "rope-071", + "level_file": "data/task/rope-071.json", + "video": { + "path": "data/video/rope-071.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "candy": 1, + "grab_or_rope_anchor": 4, + "object_10": 1, + "object_4": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 52, + "x": 256, + "y": 139 + }, + { + "name": 2, + "x": 157, + "y": 427 + }, + { + "name": 100, + "x": 158, + "y": 68, + "length": 100, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 254, + "y": 68, + "length": 50, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 157, + "y": 163, + "length": 90, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 158, + "y": 259, + "length": 130, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 3, + "x": 70, + "y": 165, + "timeout": -1 + }, + { + "name": 3, + "x": 256, + "y": 276, + "timeout": -1 + }, + { + "name": 3, + "x": 72, + "y": 275, + "timeout": -1 + }, + { + "name": 10, + "x": 71, + "y": 347, + "locale": "en", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 130, + "y": 359, + "locale": "en", + "text": "Keep the candy away from spikes", + "width": 120 + } + ], + "ru": [ + { + "name": 10, + "x": 82, + "y": 370, + "locale": "ru", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 92, + "y": 332, + "locale": "ru", + "text": "Не дайте леденцу разбиться о шипы", + "width": 200 + } + ], + "fr": [ + { + "name": 4, + "x": 210, + "y": 360, + "locale": "fr", + "text": "Garde le bonbon loin des pointes", + "width": 120 + }, + { + "name": 10, + "x": 266, + "y": 346, + "locale": "fr", + "moveSpeed": 100, + "rotateSpeed": 100 + } + ], + "de": [ + { + "name": 10, + "x": 77, + "y": 370, + "locale": "de", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 99, + "y": 327, + "locale": "de", + "text": "Pass auf, dass der Bonbon nicht in die Nähe der Spikes kommt", + "width": 250 + } + ], + "mirroredFrom": "01-16.json" + }, + "reference_solution": "cut_rope 1\ncut_rope 0 when candy_x < 770\ncut_rope 2 when candy_x > 1080", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T13:14:37.146Z" + }, + "answer": { + "commands": "cut_rope 1\ncut_rope 0 when candy_x < 770\ncut_rope 2 when candy_x > 1080", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 1\ncut_rope 0 when candy_x < 770\ncut_rope 2 when candy_x > 1080", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-071\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 4\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-072.json b/cutrope/data/rope-072.json new file mode 100644 index 0000000000000000000000000000000000000000..bd40556149686f0074b2ce5ca86d695507e54aaf --- /dev/null +++ b/cutrope/data/rope-072.json @@ -0,0 +1,241 @@ +{ + "schema_version": 1, + "level_id": "rope-072", + "level_file": "data/task/rope-072.json", + "video": { + "path": "data/video/rope-072.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 2, + "object_counts": { + "bubble": 1, + "candy": 1, + "grab_or_rope_anchor": 5, + "object_4": 1, + "object_8": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "width": 320, + "height": 480, + "gridSize": 32 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 2, + "twoParts": false + } + ], + "objects": [ + { + "name": 3, + "x": 186, + "y": 297, + "timeout": -1 + }, + { + "name": 3, + "x": 266, + "y": 417, + "timeout": -1 + }, + { + "name": 3, + "x": 188, + "y": 410, + "timeout": -1 + }, + { + "name": 2, + "x": 259, + "y": 69 + }, + { + "name": 100, + "x": 186, + "y": 158, + "length": 100, + "wheel": false, + "gun": false, + "radius": 60, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 187, + "y": 351, + "length": 100, + "wheel": false, + "gun": false, + "radius": 60, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 52, + "x": 94, + "y": 135 + }, + { + "name": 100, + "x": 185, + "y": 253, + "length": 100, + "wheel": false, + "gun": false, + "radius": 60, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 41, + "y": 37, + "length": 70, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 148, + "y": 37, + "length": 70, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 4, + "x": 5, + "y": 190, + "locale": "en", + "text": "Automatic ropes appear when candy gets into their area", + "width": 130 + }, + { + "name": 8, + "x": 98, + "y": 181, + "locale": "en", + "angle": 180, + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 54, + "x": 266, + "y": 417 + } + ], + "ru": [ + { + "name": 8, + "x": 100, + "y": 181, + "locale": "ru", + "angle": 180, + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 6, + "y": 190, + "locale": "ru", + "text": "Авто-веревки появляются, когда леденец попадает в их радиус", + "width": 150 + } + ], + "fr": [ + { + "name": 8, + "x": 98, + "y": 180, + "locale": "fr", + "angle": 180, + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 5, + "y": 190, + "locale": "fr", + "text": "Les cordes automatiques apparaissent lorsqu'un bonbon arrive dans leur zone", + "width": 150 + } + ], + "de": [ + { + "name": 8, + "x": 100, + "y": 180, + "locale": "de", + "angle": 180, + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 5, + "y": 189, + "locale": "de", + "text": "Sobald der Bonbon in ihrer Nähe ist, erscheinen automatisch Seile", + "width": 160 + } + ], + "levelId": "00-17", + "levelEditedAt": "2026-05-05T10:22:43.413Z" + }, + "reference_solution": "cut_rope 3 \ncut_rope 4 when candy_x > 900\ncut_rope 0 when candy_y > 570\ncut_rope 2 when candy_y > 780\ncut_rope 1 when candy_near 1180,950,30", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T10:23:45.888Z" + }, + "answer": { + "commands": "cut_rope 3 \ncut_rope 4 when candy_x > 900\ncut_rope 0 when candy_y > 570\ncut_rope 2 when candy_y > 780\ncut_rope 1 when candy_near 1180,950,30", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 3 \ncut_rope 4 when candy_x > 900\ncut_rope 0 when candy_y > 570\ncut_rope 2 when candy_y > 780\ncut_rope 1 when candy_near 1180,950,30", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-072\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 5\n - bubble: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-073.json b/cutrope/data/rope-073.json new file mode 100644 index 0000000000000000000000000000000000000000..5e3ca400959913914eac692b2b82f84480522052 --- /dev/null +++ b/cutrope/data/rope-073.json @@ -0,0 +1,132 @@ +{ + "schema_version": 1, + "level_id": "rope-073", + "level_file": "data/task/rope-073.json", + "video": { + "path": "data/video/rope-073.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 640, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "bubble": 1, + "candy": 1, + "grab_or_rope_anchor": 1, + "gravity_button": 1, + "pump": 3, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 640, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 55, + "x": 40, + "y": 398, + "angle": 0 + }, + { + "name": 55, + "x": 157, + "y": 98, + "angle": 0 + }, + { + "name": 55, + "x": 324, + "y": 398, + "angle": 0 + }, + { + "name": 52, + "x": 158, + "y": 301 + }, + { + "name": 54, + "x": 161, + "y": 391 + }, + { + "name": 100, + "x": 162, + "y": 164, + "length": 100, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 2, + "x": 551, + "y": 64 + }, + { + "name": 3, + "x": 286, + "y": 94, + "timeout": -1 + }, + { + "name": 3, + "x": 551, + "y": 166, + "timeout": 20 + }, + { + "name": 3, + "x": 468, + "y": 399, + "timeout": -1 + }, + { + "name": 53, + "x": 379, + "y": 228 + } + ] + }, + "reference_solution": "cut_rope 0 when candy_still for 0.3 and candy_near 600,670,60\nactivate_pump 0 when candy_y > 880\nactivate_pump 0 when candy_y > 890\ntoggle_gravity when candy_x > 840\ntoggle_gravity when candy_x > 860\nactivate_pump 1 when candy_y < 240\nactivate_pump 1\ntoggle_gravity when candy_y < 50\nactivate_pump 2 when candy_y > 850\nactivate_pump 2 when candy_y > 910\ntoggle_gravity when candy_y > 1000", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T18:02:46.931Z" + }, + "answer": { + "commands": "cut_rope 0 when candy_still for 0.3 and candy_near 600,670,60\nactivate_pump 0 when candy_y > 880\nactivate_pump 0 when candy_y > 890\ntoggle_gravity when candy_x > 840\ntoggle_gravity when candy_x > 860\nactivate_pump 1 when candy_y < 240\nactivate_pump 1\ntoggle_gravity when candy_y < 50\nactivate_pump 2 when candy_y > 850\nactivate_pump 2 when candy_y > 910\ntoggle_gravity when candy_y > 1000", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 0 when candy_still for 0.3 and candy_near 600,670,60\nactivate_pump 0 when candy_y > 880\nactivate_pump 0 when candy_y > 890\ntoggle_gravity when candy_x > 840\ntoggle_gravity when candy_x > 860\nactivate_pump 1 when candy_y < 240\nactivate_pump 1\ntoggle_gravity when candy_y < 50\nactivate_pump 2 when candy_y > 850\nactivate_pump 2 when candy_y > 910\ntoggle_gravity when candy_y > 1000", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-073\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 1\n - bubble: 1\n - pump: 3\n - gravity switch: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n- Pumps: activating a pump pushes nearby objects. `activate_pump N`, optionally with `times`/`every`/`until` modifiers for repeated activation.\n- Gravity switch: `toggle_gravity` reverses or rotates gravity. Often triggered after the candy crosses a coordinate threshold.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-074.json b/cutrope/data/rope-074.json new file mode 100644 index 0000000000000000000000000000000000000000..40ec737f7bdf5caf143330ad63f6ddb7862e52a7 --- /dev/null +++ b/cutrope/data/rope-074.json @@ -0,0 +1,155 @@ +{ + "schema_version": 1, + "level_id": "rope-074", + "level_file": "data/task/rope-074.json", + "video": { + "path": "data/video/rope-074.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 640, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "bubble": 2, + "candy": 1, + "grab_or_rope_anchor": 4, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 640, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 2, + "x": 205, + "y": 40 + }, + { + "name": 54, + "x": 319, + "y": 360 + }, + { + "name": 52, + "x": 321, + "y": 360 + }, + { + "name": 100, + "x": 319, + "y": 442, + "length": 50, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 3, + "x": 312, + "y": 275, + "timeout": -1 + }, + { + "name": 3, + "x": 232, + "y": 148, + "timeout": -1 + }, + { + "name": 3, + "x": 393, + "y": 150, + "timeout": -1 + }, + { + "name": 100, + "x": 389, + "y": 272, + "length": 100, + "wheel": false, + "gun": false, + "radius": 70, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 241, + "y": 271, + "length": 100, + "wheel": false, + "gun": false, + "radius": 70, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 317, + "y": 143, + "length": 100, + "wheel": false, + "gun": false, + "radius": 70, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 54, + "x": 238, + "y": 269 + } + ], + "mirroredFrom": "03-23.json" + }, + "reference_solution": "cut_rope 0 \ncut_rope 2 when candy_y < 400\npop_bubble 0 when candy_still for 0.3 and candy_near 1110,340,60\ncut_rope 1 when candy_x > 1100\ncut_rope 3 when candy_x < 730", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T15:20:55.485Z" + }, + "answer": { + "commands": "cut_rope 0 \ncut_rope 2 when candy_y < 400\npop_bubble 0 when candy_still for 0.3 and candy_near 1110,340,60\ncut_rope 1 when candy_x > 1100\ncut_rope 3 when candy_x < 730", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 0 \ncut_rope 2 when candy_y < 400\npop_bubble 0 when candy_still for 0.3 and candy_near 1110,340,60\ncut_rope 1 when candy_x > 1100\ncut_rope 3 when candy_x < 730", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-074\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 4\n - bubble: 2\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-075.json b/cutrope/data/rope-075.json new file mode 100644 index 0000000000000000000000000000000000000000..1949c26919adde05b551ccf846006a1e14f84320 --- /dev/null +++ b/cutrope/data/rope-075.json @@ -0,0 +1,150 @@ +{ + "schema_version": 1, + "level_id": "rope-075", + "level_file": "data/task/rope-075.json", + "video": { + "path": "data/video/rope-075.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "bubble": 1, + "candy": 1, + "grab_or_rope_anchor": 2, + "pump": 2, + "sock": 2, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 52, + "x": 208, + "y": 352 + }, + { + "name": 100, + "x": 270, + "y": 275, + "length": 70, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 143, + "y": 278, + "length": 70, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 2, + "x": 49, + "y": 90 + }, + { + "name": 56, + "x": 50, + "y": 384, + "group": 0, + "angle": 270 + }, + { + "name": 56, + "x": 271, + "y": 97, + "group": 0, + "angle": 90 + }, + { + "name": 55, + "x": 208, + "y": 418, + "angle": 270 + }, + { + "name": 3, + "x": 205, + "y": 230, + "timeout": -1 + }, + { + "name": 55, + "x": 207, + "y": 305, + "angle": 270 + }, + { + "name": 3, + "x": 272, + "y": 188, + "timeout": -1 + }, + { + "name": 3, + "x": 135, + "y": 359, + "timeout": -1 + }, + { + "name": 54, + "x": 273, + "y": 188 + } + ], + "levelId": "04-06", + "levelEditedAt": "2026-05-05T15:30:05.369Z", + "mirroredFrom": "04-06.json" + }, + "reference_solution": "activate_pump 0 when candy_still for 0.3 and candy_near 1070,810,60\nactivate_pump 1 when candy_y < 660\ncut_rope 2\ncut_rope 0 when candy_y > 800\ncut_rope 1 when candy_x < 810", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T15:30:18.013Z" + }, + "answer": { + "commands": "activate_pump 0 when candy_still for 0.3 and candy_near 1070,810,60\nactivate_pump 1 when candy_y < 660\ncut_rope 2\ncut_rope 0 when candy_y > 800\ncut_rope 1 when candy_x < 810", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "activate_pump 0 when candy_still for 0.3 and candy_near 1070,810,60\nactivate_pump 1 when candy_y < 660\ncut_rope 2\ncut_rope 0 when candy_y > 800\ncut_rope 1 when candy_x < 810", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-075\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 2\n - bubble: 1\n - pump: 2\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n- Pumps: activating a pump pushes nearby objects. `activate_pump N`, optionally with `times`/`every`/`until` modifiers for repeated activation.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-076.json b/cutrope/data/rope-076.json new file mode 100644 index 0000000000000000000000000000000000000000..46f846024c635c6b5a394dbfbc1e50c014ce2f6d --- /dev/null +++ b/cutrope/data/rope-076.json @@ -0,0 +1,172 @@ +{ + "schema_version": 1, + "level_id": "rope-076", + "level_file": "data/task/rope-076.json", + "video": { + "path": "data/video/rope-076.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "bouncer": 2, + "bubble": 2, + "candy": 1, + "grab_or_rope_anchor": 3, + "object_103": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 2, + "x": 163, + "y": 41 + }, + { + "name": 52, + "x": 166, + "y": 174 + }, + { + "name": 100, + "x": 62, + "y": 161, + "length": 100, + "wheel": false, + "gun": false, + "kickable": false, + "radius": -1, + "invisible": false, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 270, + "y": 160, + "length": 100, + "wheel": false, + "gun": false, + "kickable": false, + "radius": -1, + "invisible": false, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 163, + "y": 301, + "length": 100, + "wheel": false, + "gun": false, + "kickable": false, + "radius": -1, + "invisible": false, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 3, + "x": 122, + "y": 397, + "timeout": -1 + }, + { + "name": 3, + "x": 165, + "y": 109, + "timeout": 9 + }, + { + "name": 3, + "x": 210, + "y": 402, + "timeout": -1 + }, + { + "name": 81, + "x": 257, + "y": 407, + "angle": 90, + "size": 1 + }, + { + "name": 81, + "x": 60, + "y": 288, + "angle": 90, + "size": 1 + }, + { + "name": 54, + "x": 214, + "y": 398 + }, + { + "name": 54, + "x": 166, + "y": 173 + }, + { + "name": 103, + "x": 282, + "y": 212, + "angle": 160, + "Pj": 12 + } + ], + "levelId": "06-17", + "levelEditedAt": "2026-05-05T17:31:14.946Z", + "mirroredFrom": "06-17.json" + }, + "reference_solution": "cut_rope 1 \npop_bubble 1 when candy_still for 0.3 and candy_near 960,370,60\ncut_rope 0 when candy_y > 660\ncut_rope 2 when candy_y < 380", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T17:32:03.745Z" + }, + "answer": { + "commands": "cut_rope 1 \npop_bubble 1 when candy_still for 0.3 and candy_near 960,370,60\ncut_rope 0 when candy_y > 660\ncut_rope 2 when candy_y < 380", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 1 \npop_bubble 1 when candy_still for 0.3 and candy_near 960,370,60\ncut_rope 0 when candy_y > 660\ncut_rope 2 when candy_y < 380", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-076\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 3\n - bubble: 2\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-077.json b/cutrope/data/rope-077.json new file mode 100644 index 0000000000000000000000000000000000000000..e4085b4766cf6e48d92b960bbac6bf046b1d8575 --- /dev/null +++ b/cutrope/data/rope-077.json @@ -0,0 +1,171 @@ +{ + "schema_version": 1, + "level_id": "rope-077", + "level_file": "data/task/rope-077.json", + "video": { + "path": "data/video/rope-077.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": null, + "object_counts": { + "bubble": 1, + "candy": 1, + "grab_or_rope_anchor": 6, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 2, + "x": 165, + "y": 210 + }, + { + "name": 100, + "x": 157, + "y": 37, + "length": 50, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 52, + "x": 163, + "y": 129 + }, + { + "name": 54, + "x": 76, + "y": 394 + }, + { + "name": 100, + "x": 161, + "y": 326, + "length": 100, + "wheel": false, + "radius": 60, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 62, + "y": 37, + "length": 100, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 252, + "y": 35, + "length": 100, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 3, + "x": 248, + "y": 167, + "timeout": -1 + }, + { + "name": 3, + "x": 78, + "y": 290, + "timeout": -1 + }, + { + "name": 3, + "x": 160, + "y": 417, + "timeout": -1 + }, + { + "name": 100, + "x": 29, + "y": 257, + "length": 180, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 288, + "y": 255, + "length": 180, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + } + ], + "mirroredFrom": "04-12.json" + }, + "reference_solution": "cut_rope 0 when candy_y < 280\ncut_rope 2\ncut_rope 3 when candy_still for 0.3 and candy_near 1110,380,60\ncut_rope 5 when candy_y > 780", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T15:39:53.262Z" + }, + "answer": { + "commands": "cut_rope 0 when candy_y < 280\ncut_rope 2\ncut_rope 3 when candy_still for 0.3 and candy_near 1110,380,60\ncut_rope 5 when candy_y > 780", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 0 when candy_y < 280\ncut_rope 2\ncut_rope 3 when candy_still for 0.3 and candy_near 1110,380,60\ncut_rope 5 when candy_y > 780", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-077\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 6\n - bubble: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-078.json b/cutrope/data/rope-078.json new file mode 100644 index 0000000000000000000000000000000000000000..005d9e115cb15ae51802936261d31c1cf92df70d --- /dev/null +++ b/cutrope/data/rope-078.json @@ -0,0 +1,119 @@ +{ + "schema_version": 1, + "level_id": "rope-078", + "level_file": "data/task/rope-078.json", + "video": { + "path": "data/video/rope-078.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "candy": 1, + "grab_or_rope_anchor": 2, + "gravity_button": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "uk": false + } + ], + "objects": [ + { + "name": 2, + "x": 167, + "y": 341 + }, + { + "name": 3, + "x": 161, + "y": 152, + "timeout": -1 + }, + { + "name": 3, + "x": 163, + "y": 195, + "timeout": -1 + }, + { + "name": 3, + "x": 161, + "y": 97, + "timeout": -1 + }, + { + "name": 53, + "x": 268, + "y": 413 + }, + { + "name": 100, + "x": 298, + "y": 258, + "length": 75, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false + }, + { + "name": 100, + "x": 34, + "y": 255, + "length": 75, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false + }, + { + "name": 52, + "x": 161, + "y": 256 + } + ], + "levelId": "08-21", + "levelEditedAt": "2026-05-05T18:16:58.220Z" + }, + "reference_solution": "cut_rope 0,1\ntoggle_gravity 0\ntoggle_gravity when candy_y < 300", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T18:17:50.592Z" + }, + "answer": { + "commands": "cut_rope 0,1\ntoggle_gravity 0\ntoggle_gravity when candy_y < 300", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 0,1\ntoggle_gravity 0\ntoggle_gravity when candy_y < 300", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-078\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 2\n - gravity switch: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Gravity switch: `toggle_gravity` reverses or rotates gravity. Often triggered after the candy crosses a coordinate threshold.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-079.json b/cutrope/data/rope-079.json new file mode 100644 index 0000000000000000000000000000000000000000..8a6d619215cae16fa8a029f2ae911739ad76729e --- /dev/null +++ b/cutrope/data/rope-079.json @@ -0,0 +1,128 @@ +{ + "schema_version": 1, + "level_id": "rope-079", + "level_file": "data/task/rope-079.json", + "video": { + "path": "data/video/rope-079.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "bubble": 1, + "candy": 1, + "grab_or_rope_anchor": 3, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "special": 1, + "ropePhysicsSpeed": 1 + } + ], + "objects": [ + { + "name": 52, + "x": 161, + "y": 350 + }, + { + "name": 2, + "x": 163, + "y": 67 + }, + { + "name": 100, + "x": 243, + "y": 290, + "length": 120, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false + }, + { + "name": 100, + "x": 83, + "y": 401, + "length": 90, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false + }, + { + "name": 54, + "x": 165, + "y": 421 + }, + { + "name": 100, + "x": 165, + "y": 123, + "length": 200, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false + }, + { + "name": 3, + "x": 97, + "y": 294, + "timeout": -1 + }, + { + "name": 3, + "x": 166, + "y": 422, + "timeout": -1 + }, + { + "name": 3, + "x": 97, + "y": 228, + "timeout": -1 + } + ] + }, + "reference_solution": "cut_rope 2\ncut_rope 1 when candy_still for 0.3 \ncut_rope 0 when candy_y < 370", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T11:41:55.569Z" + }, + "answer": { + "commands": "cut_rope 2\ncut_rope 1 when candy_still for 0.3 \ncut_rope 0 when candy_y < 370", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 2\ncut_rope 1 when candy_still for 0.3 \ncut_rope 0 when candy_y < 370", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-079\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 3\n - bubble: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-080.json b/cutrope/data/rope-080.json new file mode 100644 index 0000000000000000000000000000000000000000..f156037f839519a847ac4b15919a3dd234194f39 --- /dev/null +++ b/cutrope/data/rope-080.json @@ -0,0 +1,161 @@ +{ + "schema_version": 1, + "level_id": "rope-080", + "level_file": "data/task/rope-080.json", + "video": { + "path": "data/video/rope-080.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 2, + "object_counts": { + "bubble": 6, + "candy": 1, + "grab_or_rope_anchor": 3, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "width": 320, + "height": 480, + "gridSize": 32 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 2, + "twoParts": false + } + ], + "objects": [ + { + "name": 2, + "x": 162, + "y": 276 + }, + { + "name": 54, + "x": 256, + "y": 276 + }, + { + "name": 54, + "x": 232, + "y": 211 + }, + { + "name": 54, + "x": 232, + "y": 339 + }, + { + "name": 54, + "x": 94, + "y": 214 + }, + { + "name": 54, + "x": 68, + "y": 274 + }, + { + "name": 54, + "x": 88, + "y": 341 + }, + { + "name": 100, + "x": 163, + "y": 280, + "length": 80, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 52, + "x": 164, + "y": 123 + }, + { + "name": 100, + "x": 62, + "y": 117, + "length": 60, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 255, + "y": 118, + "length": 60, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 3, + "x": 66, + "y": 277, + "timeout": "-1" + }, + { + "name": 3, + "x": 160, + "y": 370, + "timeout": "-1" + }, + { + "name": 3, + "x": 255, + "y": 274, + "timeout": "-1" + } + ], + "mirroredFrom": "00-18.json" + }, + "reference_solution": "cut_rope 2 \npop_bubble 3 \ncut_rope 1 when candy_still for 0.3 \npop_bubble 4 when candy_y > 570\npop_bubble 5 when candy_y > 750\npop_bubble 1 when candy_still for 0.3", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T10:26:28.025Z" + }, + "answer": { + "commands": "cut_rope 2 \npop_bubble 3 \ncut_rope 1 when candy_still for 0.3 \npop_bubble 4 when candy_y > 570\npop_bubble 5 when candy_y > 750\npop_bubble 1 when candy_still for 0.3", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 2 \npop_bubble 3 \ncut_rope 1 when candy_still for 0.3 \npop_bubble 4 when candy_y > 570\npop_bubble 5 when candy_y > 750\npop_bubble 1 when candy_still for 0.3", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-080\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 3\n - bubble: 6\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-081.json b/cutrope/data/rope-081.json new file mode 100644 index 0000000000000000000000000000000000000000..2ca209099bbd386a35ee02ae9e9b40815883081b --- /dev/null +++ b/cutrope/data/rope-081.json @@ -0,0 +1,152 @@ +{ + "schema_version": 1, + "level_id": "rope-081", + "level_file": "data/task/rope-081.json", + "video": { + "path": "data/video/rope-081.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": true, + "special": 1, + "object_counts": { + "bubble": 1, + "grab_or_rope_anchor": 4, + "left_candy": 1, + "right_candy": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": true + } + ], + "objects": [ + { + "name": 51, + "x": 213, + "y": 178 + }, + { + "name": 50, + "x": 96, + "y": 181 + }, + { + "name": 100, + "x": 194, + "y": 127, + "length": 100, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 2, + "x": 155, + "y": 428 + }, + { + "name": 3, + "x": 16, + "y": 218, + "timeout": -1 + }, + { + "name": 3, + "x": 292, + "y": 213, + "timeout": -1 + }, + { + "name": 3, + "x": 154, + "y": 344, + "timeout": -1 + }, + { + "name": 100, + "x": 43, + "y": 65, + "length": 100, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 266, + "y": 64, + "length": 100, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 113, + "y": 129, + "length": 100, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 54, + "x": 155, + "y": 345 + } + ], + "mirroredFrom": "05-04.json" + }, + "reference_solution": "cut_rope 1 \ncut_rope 2 when left_candy_near 1270,490,40\ncut_rope 0,3 when candy_still for 0.3\npop_bubble 0 when candy_y < 470", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T16:13:11.113Z" + }, + "answer": { + "commands": "cut_rope 1 \ncut_rope 2 when left_candy_near 1270,490,40\ncut_rope 0,3 when candy_still for 0.3\npop_bubble 0 when candy_y < 470", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 1 \ncut_rope 2 when left_candy_near 1270,490,40\ncut_rope 0,3 when candy_still for 0.3\npop_bubble 0 when candy_y < 470", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-081\n- canvas_size: 1920 x 1080\n- two_parts (split candy): True\n- object_counts:\n - target: 1\n - star: 3\n - left split candy: 1\n - right split candy: 1\n - rope/grab: 4\n - bubble: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Split candy: the level starts with left_candy and right_candy halves. Before they merge, use left_candy_* and right_candy_* conditions. After they touch and merge, use candy_* for the complete candy.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-082.json b/cutrope/data/rope-082.json new file mode 100644 index 0000000000000000000000000000000000000000..d642744f5306cf3a83194ccb7c336ce6a268618b --- /dev/null +++ b/cutrope/data/rope-082.json @@ -0,0 +1,207 @@ +{ + "schema_version": 1, + "level_id": "rope-082", + "level_file": "data/task/rope-082.json", + "video": { + "path": "data/video/rope-082.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 2, + "object_counts": { + "candy": 1, + "grab_or_rope_anchor": 2, + "object_4": 1, + "object_8": 1, + "sock": 2, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "width": 320, + "height": 480, + "gridSize": 32 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 2, + "twoParts": false + } + ], + "objects": [ + { + "name": 2, + "x": 103, + "y": 413 + }, + { + "name": 100, + "x": 270, + "y": 56, + "length": 55, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 163, + "y": 58, + "length": 130, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 52, + "x": 273, + "y": 150 + }, + { + "name": 3, + "x": 169, + "y": 384, + "timeout": -1 + }, + { + "name": 3, + "x": 199, + "y": 217, + "timeout": -1 + }, + { + "name": 3, + "x": 269, + "y": 217, + "timeout": -1 + }, + { + "name": 56, + "x": 193, + "y": 388, + "group": 0, + "angle": 180 + }, + { + "name": 56, + "x": 126, + "y": 218, + "group": 0, + "angle": 0 + }, + { + "name": 4, + "x": 269, + "y": 247, + "locale": "en", + "text": "Drop the candy into the sock and it will fall out from the other one", + "width": 220 + }, + { + "name": 8, + "x": 160, + "y": 236, + "locale": "en", + "angle": 0, + "moveSpeed": 100, + "rotateSpeed": 100 + } + ], + "fr": [ + { + "name": 8, + "x": 160, + "y": 237, + "locale": "fr", + "angle": 180, + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 52, + "y": 246, + "locale": "fr", + "text": "Dépose le bonbon dans la chaussette et il sortira de l'autre chaussette", + "width": 160 + } + ], + "de": [ + { + "name": 8, + "x": 161, + "y": 237, + "locale": "de", + "angle": 180, + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 54, + "y": 245, + "locale": "de", + "text": "Wirf die Süßigkeiten in den Strumpf und sie kommt aus dem anderen wieder heraus", + "width": 200 + } + ], + "ru": [ + { + "name": 8, + "x": 160, + "y": 236, + "locale": "ru", + "angle": 180, + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 52, + "y": 242, + "locale": "ru", + "text": "Киньте леденец в один из носков, и он вылетит из другого", + "width": 160 + } + ], + "mirroredFrom": "00-05.json" + }, + "reference_solution": "cut_rope 0", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T05:23:54.654Z" + }, + "answer": { + "commands": "cut_rope 0", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 0", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-082\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 2\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-083.json b/cutrope/data/rope-083.json new file mode 100644 index 0000000000000000000000000000000000000000..01e7b2337c8fddb7bfea9d1283d2d6b97d1de446 --- /dev/null +++ b/cutrope/data/rope-083.json @@ -0,0 +1,141 @@ +{ + "schema_version": 1, + "level_id": "rope-083", + "level_file": "data/task/rope-083.json", + "video": { + "path": "data/video/rope-083.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": true, + "special": 1, + "object_counts": { + "bubble": 1, + "grab_or_rope_anchor": 3, + "left_candy": 1, + "right_candy": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": true + } + ], + "objects": [ + { + "name": 51, + "x": 236, + "y": 326 + }, + { + "name": 50, + "x": 65, + "y": 167 + }, + { + "name": 2, + "x": 156, + "y": 378 + }, + { + "name": 100, + "x": 66, + "y": 86, + "length": 50, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 240, + "y": 240, + "length": 60, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 155, + "y": 169, + "length": 60, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 54, + "x": 242, + "y": 386 + }, + { + "name": 3, + "x": 158, + "y": 86, + "timeout": -1 + }, + { + "name": 3, + "x": 157, + "y": 260, + "timeout": -1 + }, + { + "name": 3, + "x": 216, + "y": 177, + "timeout": -1 + } + ], + "levelId": "05-13", + "levelEditedAt": "2026-05-05T16:37:51.905Z", + "mirroredFrom": "05-13.json" + }, + "reference_solution": "cut_rope 0,1 \npop_bubble 0 when candy_still for 0.3 \ncut_rope 2", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T16:38:05.560Z" + }, + "answer": { + "commands": "cut_rope 0,1 \npop_bubble 0 when candy_still for 0.3 \ncut_rope 2", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 0,1 \npop_bubble 0 when candy_still for 0.3 \ncut_rope 2", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-083\n- canvas_size: 1920 x 1080\n- two_parts (split candy): True\n- object_counts:\n - target: 1\n - star: 3\n - left split candy: 1\n - right split candy: 1\n - rope/grab: 3\n - bubble: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Split candy: the level starts with left_candy and right_candy halves. Before they merge, use left_candy_* and right_candy_* conditions. After they touch and merge, use candy_* for the complete candy.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-084.json b/cutrope/data/rope-084.json new file mode 100644 index 0000000000000000000000000000000000000000..064519a6cd29407213bc8b60f43a2b5a275b23dc --- /dev/null +++ b/cutrope/data/rope-084.json @@ -0,0 +1,183 @@ +{ + "schema_version": 1, + "level_id": "rope-084", + "level_file": "data/task/rope-084.json", + "video": { + "path": "data/video/rope-084.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": true, + "special": 1, + "object_counts": { + "grab_or_rope_anchor": 6, + "left_candy": 1, + "right_candy": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": true + } + ], + "objects": [ + { + "name": 100, + "x": 61, + "y": 64, + "length": 200, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L", + "hidePath": false + }, + { + "name": 100, + "x": 162, + "y": 64, + "length": 30, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R", + "hidePath": false + }, + { + "name": 100, + "x": 263, + "y": 63, + "length": 200, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L", + "hidePath": false + }, + { + "name": 100, + "x": 265, + "y": 384, + "length": 200, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R", + "hidePath": false + }, + { + "name": 100, + "x": 160, + "y": 385, + "length": 30, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L", + "hidePath": false + }, + { + "name": 100, + "x": 59, + "y": 385, + "length": 200, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R", + "hidePath": false + }, + { + "name": 50, + "x": 164, + "y": 302 + }, + { + "name": 51, + "x": 166, + "y": 157 + }, + { + "name": 2, + "x": 159, + "y": 444 + }, + { + "name": 3, + "x": 128, + "y": 335, + "timeout": -1 + }, + { + "name": 3, + "x": 128, + "y": 128, + "timeout": -1 + }, + { + "name": 3, + "x": 157, + "y": 228, + "timeout": -1 + } + ] + }, + "reference_solution": "cut_rope 4 when left_candy_still for 0.3 \ncut_rope 3 when candy_still for 0.3 and candy_near 960,330,60\ncut_rope 1 when candy_still for 0.3 and candy_near 920,310,60\ncut_rope 2 when candy_still for 0.3 and candy_near 970,620,60\ncut_rope 5 when candy_x < 550\ncut_rope 0 when candy_near 800,700,50 times 3", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T18:46:01.088Z" + }, + "answer": { + "commands": "cut_rope 4 when left_candy_still for 0.3 \ncut_rope 3 when candy_still for 0.3 and candy_near 960,330,60\ncut_rope 1 when candy_still for 0.3 and candy_near 920,310,60\ncut_rope 2 when candy_still for 0.3 and candy_near 970,620,60\ncut_rope 5 when candy_x < 550\ncut_rope 0 when candy_near 800,700,50 times 3", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 4 when left_candy_still for 0.3 \ncut_rope 3 when candy_still for 0.3 and candy_near 960,330,60\ncut_rope 1 when candy_still for 0.3 and candy_near 920,310,60\ncut_rope 2 when candy_still for 0.3 and candy_near 970,620,60\ncut_rope 5 when candy_x < 550\ncut_rope 0 when candy_near 800,700,50 times 3", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-084\n- canvas_size: 1920 x 1080\n- two_parts (split candy): True\n- object_counts:\n - target: 1\n - star: 3\n - left split candy: 1\n - right split candy: 1\n - rope/grab: 6\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Split candy: the level starts with left_candy and right_candy halves. Before they merge, use left_candy_* and right_candy_* conditions. After they touch and merge, use candy_* for the complete candy.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-085.json b/cutrope/data/rope-085.json new file mode 100644 index 0000000000000000000000000000000000000000..4d227b99afb4cf864f61ce11fbaccf2edb6ab8c9 --- /dev/null +++ b/cutrope/data/rope-085.json @@ -0,0 +1,156 @@ +{ + "schema_version": 1, + "level_id": "rope-085", + "level_file": "data/task/rope-085.json", + "video": { + "path": "data/video/rope-085.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 2, + "object_counts": { + "bubble": 2, + "candy": 1, + "grab_or_rope_anchor": 2, + "sock": 4, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "width": 320, + "height": 480, + "gridSize": 32 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 2, + "twoParts": false + } + ], + "objects": [ + { + "name": 2, + "x": 51, + "y": 427 + }, + { + "name": 52, + "x": 206, + "y": 174 + }, + { + "name": 56, + "x": 168, + "y": 115, + "group": 0, + "angle": 75 + }, + { + "name": 54, + "x": 213, + "y": 261 + }, + { + "name": 100, + "x": 231, + "y": 65, + "length": 110, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 56, + "x": 267, + "y": 261, + "group": 0, + "angle": 240 + }, + { + "name": 54, + "x": 49, + "y": 322 + }, + { + "name": 56, + "x": 150, + "y": 271, + "group": 1, + "angle": 250 + }, + { + "name": 56, + "x": 217, + "y": 378, + "group": 1, + "angle": 271 + }, + { + "name": 3, + "x": 260, + "y": 219, + "timeout": -1 + }, + { + "name": 3, + "x": 45, + "y": 137, + "timeout": -1 + }, + { + "name": 3, + "x": 218, + "y": 335, + "timeout": -1 + }, + { + "name": 100, + "x": 117, + "y": 112, + "length": 80, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + } + ], + "mirroredFrom": "00-16.json" + }, + "reference_solution": "cut_rope 1 when candy_still for 0.3 and candy_near 1020,460,60\ncut_rope 0 when candy_x > 1120\npop_bubble 0 when candy_y > 650\npop_bubble 1 when candy_y < 340", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T10:15:05.854Z" + }, + "answer": { + "commands": "cut_rope 1 when candy_still for 0.3 and candy_near 1020,460,60\ncut_rope 0 when candy_x > 1120\npop_bubble 0 when candy_y > 650\npop_bubble 1 when candy_y < 340", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 1 when candy_still for 0.3 and candy_near 1020,460,60\ncut_rope 0 when candy_x > 1120\npop_bubble 0 when candy_y > 650\npop_bubble 1 when candy_y < 340", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-085\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 2\n - bubble: 2\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-086.json b/cutrope/data/rope-086.json new file mode 100644 index 0000000000000000000000000000000000000000..526c40ac441de848582e35ee905c09fe5ff9db23 --- /dev/null +++ b/cutrope/data/rope-086.json @@ -0,0 +1,149 @@ +{ + "schema_version": 1, + "level_id": "rope-086", + "level_file": "data/task/rope-086.json", + "video": { + "path": "data/video/rope-086.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 640, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "bubble": 1, + "candy": 1, + "grab_or_rope_anchor": 4, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 640, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 52, + "x": 207, + "y": 110 + }, + { + "name": 2, + "x": 477, + "y": 419 + }, + { + "name": 100, + "x": 304, + "y": 41, + "length": 120, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 465, + "y": 38, + "length": 250, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 208, + "y": 39, + "length": 50, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 54, + "x": 478, + "y": 322 + }, + { + "name": 100, + "x": 478, + "y": 323, + "length": 100, + "wheel": false, + "gun": false, + "radius": 50, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 3, + "x": 339, + "y": 272, + "timeout": -1 + }, + { + "name": 3, + "x": 477, + "y": 145, + "timeout": -1 + }, + { + "name": 3, + "x": 264, + "y": 217, + "timeout": -1 + } + ] + }, + "reference_solution": "cut_rope 2\ncut_rope 0 when candy_x > 800\ncut_rope 3 when candy_still for 0.3 and candy_near 1310,500,60\npop_bubble 0 when candy_y < 300\ncut_rope 1 when candy_y < 440", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T15:22:55.434Z" + }, + "answer": { + "commands": "cut_rope 2\ncut_rope 0 when candy_x > 800\ncut_rope 3 when candy_still for 0.3 and candy_near 1310,500,60\npop_bubble 0 when candy_y < 300\ncut_rope 1 when candy_y < 440", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 2\ncut_rope 0 when candy_x > 800\ncut_rope 3 when candy_still for 0.3 and candy_near 1310,500,60\npop_bubble 0 when candy_y < 300\ncut_rope 1 when candy_y < 440", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-086\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 4\n - bubble: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-087.json b/cutrope/data/rope-087.json new file mode 100644 index 0000000000000000000000000000000000000000..956acb7493f568446ae68262fd81e4839131cc18 --- /dev/null +++ b/cutrope/data/rope-087.json @@ -0,0 +1,151 @@ +{ + "schema_version": 1, + "level_id": "rope-087", + "level_file": "data/task/rope-087.json", + "video": { + "path": "data/video/rope-087.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 640, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "bubble": 1, + "candy": 1, + "grab_or_rope_anchor": 3, + "pump": 2, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 640, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 2, + "x": 379, + "y": 386 + }, + { + "name": 3, + "x": 379, + "y": 321, + "timeout": -1 + }, + { + "name": 3, + "x": 131, + "y": 128, + "timeout": -1 + }, + { + "name": 3, + "x": 225, + "y": 225, + "timeout": -1 + }, + { + "name": 100, + "x": 503, + "y": 28, + "length": 100, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 52, + "x": 425, + "y": 112 + }, + { + "name": 55, + "x": 321, + "y": 243, + "angle": 270 + }, + { + "name": 100, + "x": 333, + "y": 33, + "length": 100, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 199, + "y": 33, + "length": 100, + "wheel": false, + "gun": false, + "radius": 80, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 54, + "x": 226, + "y": 227 + }, + { + "name": 55, + "x": 145, + "y": 236, + "angle": 0 + } + ], + "levelId": "07-14", + "levelEditedAt": "2026-05-05T17:48:27.305Z", + "mirroredFrom": "07-14.json" + }, + "reference_solution": "cut_rope 0\nactivate_pump 0 when candy_x < 1020\ncut_rope 1 when candy_x < 800\ncut_rope 2 when candy_near 630,390,50 times 2\nactivate_pump 1 when candy_y > 500\npop_bubble 0 when candy_x > 1010", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T17:50:14.972Z" + }, + "answer": { + "commands": "cut_rope 0\nactivate_pump 0 when candy_x < 1020\ncut_rope 1 when candy_x < 800\ncut_rope 2 when candy_near 630,390,50 times 2\nactivate_pump 1 when candy_y > 500\npop_bubble 0 when candy_x > 1010", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 0\nactivate_pump 0 when candy_x < 1020\ncut_rope 1 when candy_x < 800\ncut_rope 2 when candy_near 630,390,50 times 2\nactivate_pump 1 when candy_y > 500\npop_bubble 0 when candy_x > 1010", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-087\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 3\n - bubble: 1\n - pump: 2\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n- Pumps: activating a pump pushes nearby objects. `activate_pump N`, optionally with `times`/`every`/`until` modifiers for repeated activation.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-088.json b/cutrope/data/rope-088.json new file mode 100644 index 0000000000000000000000000000000000000000..01f4d92cf9d3294b23a503c28da8f8849d8f0b2f --- /dev/null +++ b/cutrope/data/rope-088.json @@ -0,0 +1,217 @@ +{ + "schema_version": 1, + "level_id": "rope-088", + "level_file": "data/task/rope-088.json", + "video": { + "path": "data/video/rope-088.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "candy": 1, + "grab_or_rope_anchor": 4, + "object_13": 1, + "object_4": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 52, + "x": 77, + "y": 313 + }, + { + "name": 2, + "x": 90, + "y": 436 + }, + { + "name": 3, + "x": 148, + "y": 139, + "timeout": -1 + }, + { + "name": 3, + "x": 257, + "y": 351, + "timeout": -1 + }, + { + "name": 3, + "x": 122, + "y": 346, + "timeout": -1 + }, + { + "name": 100, + "x": 124, + "y": 191, + "length": 70, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 247, + "y": 92, + "length": 150, + "wheel": false, + "gun": false, + "radius": 55, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 188, + "y": 289, + "length": 100, + "wheel": false, + "gun": false, + "radius": 65, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 49, + "y": 381, + "length": 25, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 4, + "x": 20, + "y": 98, + "locale": "en", + "text": "Stretched ropes turn red", + "width": 100 + }, + { + "name": 13, + "x": 67, + "y": 85, + "locale": "en", + "moveSpeed": 100, + "rotateSpeed": 100 + } + ], + "ru": [ + { + "name": 13, + "x": 68, + "y": 64, + "locale": "ru", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 21, + "y": 77, + "locale": "ru", + "text": "Натянутые веревки становятся красными", + "width": 100 + } + ], + "fr": [ + { + "name": 13, + "x": 67, + "y": 61, + "locale": "fr", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 20, + "y": 74, + "locale": "fr", + "text": "Les cordes étirées deviennent rouges", + "width": 100 + } + ], + "de": [ + { + "name": 4, + "x": 57, + "y": 33, + "locale": "de", + "text": "Gespannte Seile werden rot", + "width": 140 + }, + { + "name": 13, + "x": 39, + "y": 68, + "locale": "de", + "moveSpeed": 100, + "rotateSpeed": 100 + } + ], + "levelId": "01-12", + "levelEditedAt": "2026-05-05T13:10:17.063Z" + }, + "reference_solution": "cut_rope 3 \ncut_rope 0,1 when candy_still for 0.3 \ncut_rope 2 when candy_near 850,800,60", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T13:10:29.123Z" + }, + "answer": { + "commands": "cut_rope 3 \ncut_rope 0,1 when candy_still for 0.3 \ncut_rope 2 when candy_near 850,800,60", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 3 \ncut_rope 0,1 when candy_still for 0.3 \ncut_rope 2 when candy_near 850,800,60", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-088\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 4\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-089.json b/cutrope/data/rope-089.json new file mode 100644 index 0000000000000000000000000000000000000000..90d359f6e45c4fb75019c94c3a7d70184830ce09 --- /dev/null +++ b/cutrope/data/rope-089.json @@ -0,0 +1,246 @@ +{ + "schema_version": 1, + "level_id": "rope-089", + "level_file": "data/task/rope-089.json", + "video": { + "path": "data/video/rope-089.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 2, + "object_counts": { + "candy": 1, + "grab_or_rope_anchor": 6, + "object_13": 1, + "object_4": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "width": 320, + "height": 480, + "gridSize": 32 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 2, + "twoParts": false + } + ], + "objects": [ + { + "name": 2, + "x": 67, + "y": 420 + }, + { + "name": 52, + "x": 161, + "y": 153 + }, + { + "name": 3, + "x": 162, + "y": 357, + "timeout": -1 + }, + { + "name": 3, + "x": 238, + "y": 358, + "timeout": -1 + }, + { + "name": 3, + "x": 82, + "y": 360, + "timeout": -1 + }, + { + "name": 100, + "x": 241, + "y": 220, + "length": 75, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 74, + "y": 99, + "length": 75, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 246, + "y": 101, + "length": 75, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 77, + "y": 225, + "length": 75, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 160, + "y": 48, + "length": 75, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 160, + "y": 270, + "length": 75, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 4, + "x": 235, + "y": 274, + "locale": "en", + "text": "Collect as many stars as you can", + "width": 200 + }, + { + "name": 13, + "x": 255, + "y": 307, + "locale": "en", + "moveSpeed": 100, + "rotateSpeed": 100 + } + ], + "ru": [ + { + "name": 13, + "x": 60, + "y": 315, + "locale": "ru", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 73, + "y": 278, + "locale": "ru", + "text": "Старайтесь собирать звезды леденцом", + "width": 210 + } + ], + "fr": [ + { + "name": 4, + "x": 97, + "y": 280, + "locale": "fr", + "text": "Recueillez le plus d'étoiles possible", + "width": 150 + }, + { + "name": 13, + "x": 83, + "y": 316, + "locale": "fr", + "moveSpeed": 100, + "rotateSpeed": 100 + } + ], + "de": [ + { + "name": 13, + "x": 66, + "y": 311, + "locale": "de", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 86, + "y": 275, + "locale": "de", + "text": "Sammle möglichst viele Sternchen", + "width": 170 + } + ], + "levelId": "00-02", + "levelEditedAt": "2026-05-05T04:09:02.662Z", + "mirroredFrom": "00-02.json" + }, + "reference_solution": "cut_rope 1\ncut_rope 2\ncut_rope 4\ncut_rope 3 \ncut_rope 0 when candy_near 1140,780,50\ncut_rope 5 when candy_near 820,800,50", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T04:09:11.578Z" + }, + "answer": { + "commands": "cut_rope 1\ncut_rope 2\ncut_rope 4\ncut_rope 3 \ncut_rope 0 when candy_near 1140,780,50\ncut_rope 5 when candy_near 820,800,50", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 1\ncut_rope 2\ncut_rope 4\ncut_rope 3 \ncut_rope 0 when candy_near 1140,780,50\ncut_rope 5 when candy_near 820,800,50", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-089\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 6\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-090.json b/cutrope/data/rope-090.json new file mode 100644 index 0000000000000000000000000000000000000000..c0690da0923db5bcc86e8269ea4ab7595ffed657 --- /dev/null +++ b/cutrope/data/rope-090.json @@ -0,0 +1,204 @@ +{ + "schema_version": 1, + "level_id": "rope-090", + "level_file": "data/task/rope-090.json", + "video": { + "path": "data/video/rope-090.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "candy": 1, + "grab_or_rope_anchor": 3, + "object_10": 1, + "object_4": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 52, + "x": 292, + "y": 122 + }, + { + "name": 100, + "x": 287, + "y": 51, + "length": 40, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 2, + "x": 8, + "y": 415 + }, + { + "name": 100, + "x": 225, + "y": 220, + "length": 100, + "wheel": false, + "gun": false, + "radius": 70, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 3, + "x": 31, + "y": 303, + "timeout": -1 + }, + { + "name": 100, + "x": 93, + "y": 221, + "length": 100, + "wheel": false, + "gun": false, + "radius": 65, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 3, + "x": 288, + "y": 220, + "timeout": -1 + }, + { + "name": 3, + "x": 160, + "y": 285, + "timeout": -1 + }, + { + "name": 4, + "x": 300, + "y": 366, + "locale": "en", + "text": "Cut the rope before the spider reaches the candy", + "width": 140 + }, + { + "name": 10, + "x": 231, + "y": 350, + "locale": "en", + "moveSpeed": 100, + "rotateSpeed": 100 + } + ], + "ru": [ + { + "name": 10, + "x": 88, + "y": 351, + "locale": "ru", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 19, + "y": 367, + "locale": "ru", + "text": "袠蟹斜械谐邪泄褌械 褝谢械泻褌褉懈褔械褋泻懈褏 懈褋泻褉", + "width": 140 + } + ], + "fr": [ + { + "name": 10, + "x": 89, + "y": 335, + "locale": "fr", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 20, + "y": 351, + "locale": "fr", + "text": "脡vite les 茅tincelles 茅lectriques", + "width": 140 + } + ], + "de": [ + { + "name": 10, + "x": 89, + "y": 359, + "locale": "de", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 3, + "y": 366, + "locale": "de", + "text": "Schneide das Seil durch, bevor die Spinne am Bonbon ist", + "width": 180 + } + ], + "levelId": "03-14", + "levelEditedAt": "2026-05-05T14:44:56.589Z", + "mirroredFrom": "03-14.json" + }, + "reference_solution": "cut_rope 0\ncut_rope 1 when candy_still for 0.3\ncut_rope 2 when candy_x < 720", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T14:45:05.295Z" + }, + "answer": { + "commands": "cut_rope 0\ncut_rope 1 when candy_still for 0.3\ncut_rope 2 when candy_x < 720", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 0\ncut_rope 1 when candy_still for 0.3\ncut_rope 2 when candy_x < 720", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-090\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 3\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-091.json b/cutrope/data/rope-091.json new file mode 100644 index 0000000000000000000000000000000000000000..299b79aba0c24e6df19b84c621ce374e2f811826 --- /dev/null +++ b/cutrope/data/rope-091.json @@ -0,0 +1,215 @@ +{ + "schema_version": 1, + "level_id": "rope-091", + "level_file": "data/task/rope-091.json", + "video": { + "path": "data/video/rope-091.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "candy": 1, + "grab_or_rope_anchor": 4, + "object_10": 1, + "object_4": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 52, + "x": 64, + "y": 139 + }, + { + "name": 2, + "x": 163, + "y": 427 + }, + { + "name": 100, + "x": 162, + "y": 68, + "length": 100, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 66, + "y": 68, + "length": 50, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 163, + "y": 163, + "length": 90, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 162, + "y": 259, + "length": 130, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 3, + "x": 250, + "y": 165, + "timeout": -1 + }, + { + "name": 3, + "x": 64, + "y": 276, + "timeout": -1 + }, + { + "name": 3, + "x": 248, + "y": 275, + "timeout": -1 + }, + { + "name": 10, + "x": 249, + "y": 347, + "locale": "en", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 190, + "y": 359, + "locale": "en", + "text": "Keep the candy away from spikes", + "width": 120 + } + ], + "ru": [ + { + "name": 10, + "x": 82, + "y": 370, + "locale": "ru", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 92, + "y": 332, + "locale": "ru", + "text": "Не дайте леденцу разбиться о шипы", + "width": 200 + } + ], + "fr": [ + { + "name": 4, + "x": 210, + "y": 360, + "locale": "fr", + "text": "Garde le bonbon loin des pointes", + "width": 120 + }, + { + "name": 10, + "x": 266, + "y": 346, + "locale": "fr", + "moveSpeed": 100, + "rotateSpeed": 100 + } + ], + "de": [ + { + "name": 10, + "x": 77, + "y": 370, + "locale": "de", + "moveSpeed": 100, + "rotateSpeed": 100 + }, + { + "name": 4, + "x": 99, + "y": 327, + "locale": "de", + "text": "Pass auf, dass der Bonbon nicht in die Nähe der Spikes kommt", + "width": 250 + } + ] + }, + "reference_solution": "cut_rope 1\ncut_rope 0 when candy_x > 1150\ncut_rope 2 when candy_x < 840", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T13:14:37.146Z" + }, + "answer": { + "commands": "cut_rope 1\ncut_rope 0 when candy_x > 1150\ncut_rope 2 when candy_x < 840", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 1\ncut_rope 0 when candy_x > 1150\ncut_rope 2 when candy_x < 840", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-091\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 4\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-092.json b/cutrope/data/rope-092.json new file mode 100644 index 0000000000000000000000000000000000000000..90f5de30b5708c4a95034b7e343d6b24c4c78b9e --- /dev/null +++ b/cutrope/data/rope-092.json @@ -0,0 +1,152 @@ +{ + "schema_version": 1, + "level_id": "rope-092", + "level_file": "data/task/rope-092.json", + "video": { + "path": "data/video/rope-092.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 640, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "bubble": 1, + "candy": 1, + "grab_or_rope_anchor": 4, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 640, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 2, + "x": 400, + "y": 411 + }, + { + "name": 52, + "x": 459, + "y": 172 + }, + { + "name": 100, + "x": 295, + "y": 136, + "length": 100, + "wheel": false, + "gun": false, + "radius": 65, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 455, + "y": 79, + "length": 60, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 100, + "x": 390, + "y": 248, + "length": 100, + "wheel": false, + "gun": false, + "radius": 65, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 3, + "x": 384, + "y": 127, + "timeout": -1 + }, + { + "name": 3, + "x": 300, + "y": 245, + "timeout": -1 + }, + { + "name": 3, + "x": 383, + "y": 335, + "timeout": -1 + }, + { + "name": 54, + "x": 295, + "y": 307 + }, + { + "name": 100, + "x": 204, + "y": 243, + "length": 100, + "wheel": false, + "gun": false, + "radius": 65, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + } + ], + "levelId": "02-10", + "levelEditedAt": "2026-05-05T13:56:39.211Z", + "mirroredFrom": "02-10.json" + }, + "reference_solution": "cut_rope 1 \ncut_rope 3 when candy_still for 0.3 and candy_near 900,390,60\npop_bubble 0 when candy_still for 0.3 and candy_near 1090,290,60\ncut_rope 2 when candy_y > 310\ncut_rope 0 when candy_near 820,500,50", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T13:56:54.381Z" + }, + "answer": { + "commands": "cut_rope 1 \ncut_rope 3 when candy_still for 0.3 and candy_near 900,390,60\npop_bubble 0 when candy_still for 0.3 and candy_near 1090,290,60\ncut_rope 2 when candy_y > 310\ncut_rope 0 when candy_near 820,500,50", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 1 \ncut_rope 3 when candy_still for 0.3 and candy_near 900,390,60\npop_bubble 0 when candy_still for 0.3 and candy_near 1090,290,60\ncut_rope 2 when candy_y > 310\ncut_rope 0 when candy_near 820,500,50", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-092\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 4\n - bubble: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-093.json b/cutrope/data/rope-093.json new file mode 100644 index 0000000000000000000000000000000000000000..18a074d9ba40aa3df693c7a506671743f9c8d30e --- /dev/null +++ b/cutrope/data/rope-093.json @@ -0,0 +1,163 @@ +{ + "schema_version": 1, + "level_id": "rope-093", + "level_file": "data/task/rope-093.json", + "video": { + "path": "data/video/rope-093.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": true, + "special": null, + "object_counts": { + "bubble": 7, + "grab_or_rope_anchor": 2, + "left_candy": 1, + "pump": 1, + "right_candy": 1, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "twoParts": true + } + ], + "objects": [ + { + "name": 50, + "x": 48, + "y": 135 + }, + { + "name": 51, + "x": 276, + "y": 133 + }, + { + "name": 2, + "x": 247, + "y": 412 + }, + { + "name": 54, + "x": 157, + "y": 322 + }, + { + "name": 54, + "x": 103, + "y": 271 + }, + { + "name": 54, + "x": 216, + "y": 276 + }, + { + "name": 54, + "x": 60, + "y": 216 + }, + { + "name": 54, + "x": 262, + "y": 217 + }, + { + "name": 54, + "x": 100, + "y": 160 + }, + { + "name": 54, + "x": 224, + "y": 161 + }, + { + "name": 3, + "x": 123, + "y": 227, + "timeout": -1 + }, + { + "name": 3, + "x": 199, + "y": 224, + "timeout": -1 + }, + { + "name": 3, + "x": 161, + "y": 264, + "timeout": -1 + }, + { + "name": 100, + "x": 163, + "y": 253, + "length": 140, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 162, + "y": 253, + "length": 140, + "wheel": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R" + }, + { + "name": 55, + "x": 71, + "y": 416, + "angle": 0 + } + ], + "levelId": "05-12", + "levelEditedAt": "2026-05-05T16:31:03.290Z" + }, + "reference_solution": "pop_bubble 3 when left_candy_x >800 \npop_bubble 4 when right_candy_x < 1100\npop_bubble 5 when left_candy_y <300 \npop_bubble 6 when right_candy_y < 300\npop_bubble 0 when candy_still for 0.3\nactivate_pump 0 when candy_still for 0.3", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T16:36:31.795Z" + }, + "answer": { + "commands": "pop_bubble 3 when left_candy_x >800 \npop_bubble 4 when right_candy_x < 1100\npop_bubble 5 when left_candy_y <300 \npop_bubble 6 when right_candy_y < 300\npop_bubble 0 when candy_still for 0.3\nactivate_pump 0 when candy_still for 0.3", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "pop_bubble 3 when left_candy_x >800 \npop_bubble 4 when right_candy_x < 1100\npop_bubble 5 when left_candy_y <300 \npop_bubble 6 when right_candy_y < 300\npop_bubble 0 when candy_still for 0.3\nactivate_pump 0 when candy_still for 0.3", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-093\n- canvas_size: 1920 x 1080\n- two_parts (split candy): True\n- object_counts:\n - target: 1\n - star: 3\n - left split candy: 1\n - right split candy: 1\n - rope/grab: 2\n - bubble: 7\n - pump: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Split candy: the level starts with left_candy and right_candy halves. Before they merge, use left_candy_* and right_candy_* conditions. After they touch and merge, use candy_* for the complete candy.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n- Pumps: activating a pump pushes nearby objects. `activate_pump N`, optionally with `times`/`every`/`until` modifiers for repeated activation.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-094.json b/cutrope/data/rope-094.json new file mode 100644 index 0000000000000000000000000000000000000000..12dfbda9a122a96bb76925cb272783bd21a0db3e --- /dev/null +++ b/cutrope/data/rope-094.json @@ -0,0 +1,171 @@ +{ + "schema_version": 1, + "level_id": "rope-094", + "level_file": "data/task/rope-094.json", + "video": { + "path": "data/video/rope-094.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 320, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "bubble": 1, + "candy": 1, + "grab_or_rope_anchor": 5, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 320, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 100, + "x": 235, + "y": 335, + "length": 44, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R", + "hidePath": false + }, + { + "name": 100, + "x": 234, + "y": 196, + "length": 50, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R", + "hidePath": false + }, + { + "name": 100, + "x": 80, + "y": 195, + "length": 49, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R", + "hidePath": false + }, + { + "name": 100, + "x": 81, + "y": 335, + "length": 50, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R", + "hidePath": false + }, + { + "name": 2, + "x": 320, + "y": 393 + }, + { + "name": 52, + "x": 157, + "y": 270 + }, + { + "name": 3, + "x": 65, + "y": 148, + "timeout": -1 + }, + { + "name": 3, + "x": 62, + "y": 266, + "timeout": -1 + }, + { + "name": 3, + "x": 253, + "y": 265, + "timeout": -1 + }, + { + "name": 100, + "x": 152, + "y": 144, + "length": 100, + "wheel": false, + "gun": false, + "radius": 73, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "R", + "hidePath": false + }, + { + "name": 54, + "x": 74, + "y": 408 + } + ], + "levelId": "02-11", + "levelEditedAt": "2026-05-05T13:58:54.884Z", + "mirroredFrom": "02-11.json" + }, + "reference_solution": "cut_rope 0,1 \ncut_rope 2 when candy_x < 850\ncut_rope 3 when candy_still for 0.3 and candy_near 780,560,60\npop_bubble 0 when candy_y < 370\ncut_rope 4 when candy_x > 1150", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T13:59:06.406Z" + }, + "answer": { + "commands": "cut_rope 0,1 \ncut_rope 2 when candy_x < 850\ncut_rope 3 when candy_still for 0.3 and candy_near 780,560,60\npop_bubble 0 when candy_y < 370\ncut_rope 4 when candy_x > 1150", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 0,1 \ncut_rope 2 when candy_x < 850\ncut_rope 3 when candy_still for 0.3 and candy_near 780,560,60\npop_bubble 0 when candy_y < 370\ncut_rope 4 when candy_x > 1150", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-094\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 5\n - bubble: 1\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-095.json b/cutrope/data/rope-095.json new file mode 100644 index 0000000000000000000000000000000000000000..e050b0ed2fe6d6579e7002a37fdd18c24a0b8362 --- /dev/null +++ b/cutrope/data/rope-095.json @@ -0,0 +1,156 @@ +{ + "schema_version": 1, + "level_id": "rope-095", + "level_file": "data/task/rope-095.json", + "video": { + "path": "data/video/rope-095.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 640, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "bouncer": 3, + "bubble": 3, + "candy": 1, + "grab_or_rope_anchor": 1, + "sock": 2, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 640, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 52, + "x": 566, + "y": 103 + }, + { + "name": 100, + "x": 571, + "y": 195, + "length": 60, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 82, + "x": 346, + "y": 413, + "angle": 0, + "size": 2 + }, + { + "name": 3, + "x": 240, + "y": 297, + "timeout": -1 + }, + { + "name": 3, + "x": 349, + "y": 286, + "timeout": -1 + }, + { + "name": 82, + "x": 587, + "y": 382, + "angle": -37, + "size": 2 + }, + { + "name": 56, + "x": 110, + "y": 292, + "group": 0, + "angle": 0 + }, + { + "name": 56, + "x": 476, + "y": 420, + "group": 0, + "angle": 270 + }, + { + "name": 2, + "x": 350, + "y": 129 + }, + { + "name": 54, + "x": 241, + "y": 286 + }, + { + "name": 3, + "x": 468, + "y": 294, + "timeout": -1 + }, + { + "name": 54, + "x": 567, + "y": 105 + }, + { + "name": 54, + "x": 468, + "y": 285 + }, + { + "name": 82, + "x": 231, + "y": 412, + "angle": 0, + "size": 2 + } + ], + "levelId": "06-20", + "levelEditedAt": "2026-05-05T17:37:15.591Z" + }, + "reference_solution": "cut_rope 0 when candy_still for 0.3 and candy_near 1520,220,60\npop_bubble 1 when candy_near 1520,210,60\npop_bubble 2 when candy_x < 1320", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T17:37:47.859Z" + }, + "answer": { + "commands": "cut_rope 0 when candy_still for 0.3 and candy_near 1520,220,60\npop_bubble 1 when candy_near 1520,210,60\npop_bubble 2 when candy_x < 1320", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "cut_rope 0 when candy_still for 0.3 and candy_near 1520,220,60\npop_bubble 1 when candy_near 1520,210,60\npop_bubble 2 when candy_x < 1320", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-095\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 1\n - bubble: 3\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Bubbles: candy entering a bubble usually floats upward. `pop_bubble N` pops bubble N. In split-candy levels, `pop_bubble_left` / `pop_bubble_right` pop the bubble holding the corresponding half.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +} diff --git a/cutrope/data/rope-096.json b/cutrope/data/rope-096.json new file mode 100644 index 0000000000000000000000000000000000000000..339fff092475e4ab5af4f3c0f6114e6408b2fbfb --- /dev/null +++ b/cutrope/data/rope-096.json @@ -0,0 +1,158 @@ +{ + "schema_version": 1, + "level_id": "rope-096", + "level_file": "data/task/rope-096.json", + "video": { + "path": "data/video/rope-096.mp4", + "mime_type": "video/mp4", + "duration_seconds": 3, + "fps": 30 + }, + "prompt_level": { + "canvas_width": 1920, + "canvas_height": 1080, + "map_width": 640, + "map_height": 480, + "two_parts": false, + "special": 1, + "object_counts": { + "candy": 1, + "grab_or_rope_anchor": 4, + "pump": 2, + "star": 3, + "target": 1 + } + }, + "level_json_without_solution": { + "settings": [ + { + "name": 0, + "gridSize": 32, + "width": 640, + "height": 480 + }, + { + "name": 1, + "ropePhysicsSpeed": 1, + "special": 1, + "twoParts": false + } + ], + "objects": [ + { + "name": 2, + "x": 130, + "y": 421 + }, + { + "name": 52, + "x": 299, + "y": 248 + }, + { + "name": 3, + "x": 300, + "y": 141, + "timeout": -1 + }, + { + "name": 3, + "x": 301, + "y": 70, + "timeout": -1 + }, + { + "name": 3, + "x": 155, + "y": 339, + "timeout": -1 + }, + { + "name": 100, + "x": 234, + "y": 68, + "length": 100, + "wheel": false, + "gun": false, + "radius": 63, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 368, + "y": 68, + "length": 100, + "wheel": false, + "gun": false, + "radius": 63, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 233, + "y": 156, + "length": 85, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 100, + "x": 369, + "y": 155, + "length": 85, + "wheel": false, + "gun": false, + "radius": -1, + "moveLength": -1, + "moveVertical": false, + "moveOffset": 0, + "spider": false, + "part": "L" + }, + { + "name": 55, + "x": 299, + "y": 198, + "angle": 270 + }, + { + "name": 55, + "x": 300, + "y": 318, + "angle": 270 + } + ], + "levelId": "02-23", + "levelEditedAt": "2026-05-05T14:42:27.880Z" + }, + "reference_solution": "activate_pump 1 when candy_still for 0.3 and candy_near 920,570,60\nactivate_pump 0 when candy_y < 370\ncut_rope 1 when candy_still for 0.3 and candy_near 920,360,60\ncut_rope 3\ncut_rope 0 when candy_x < 790\ncut_rope 2 when candy_x < 720", + "reference": { + "won": true, + "stars": 3, + "updated_at": "2026-05-05T14:42:37.343Z" + }, + "answer": { + "commands": "activate_pump 1 when candy_still for 0.3 and candy_near 920,570,60\nactivate_pump 0 when candy_y < 370\ncut_rope 1 when candy_still for 0.3 and candy_near 920,360,60\ncut_rope 3\ncut_rope 0 when candy_x < 790\ncut_rope 2 when candy_x < 720", + "reason": "reference solution", + "confidence": 1.0 + }, + "legacy_answer": "activate_pump 1 when candy_still for 0.3 and candy_near 920,570,60\nactivate_pump 0 when candy_y < 370\ncut_rope 1 when candy_still for 0.3 and candy_near 920,360,60\ncut_rope 3\ncut_rope 0 when candy_x < 790\ncut_rope 2 when candy_x < 720", + "prompt": { + "system": "You are a Cut the Rope replayable-script solver. Given a short gameplay video of one Cut the Rope level (with a coordinate grid overlay) and a structured description of the level objects, you produce a deterministic command script that, replayed from the same initial state, wins the level.\n\nYou will receive: (a) one short gameplay video of the level, (b) a structured text body listing the canvas size, the count of each gameplay object (candy, target, ropes, bubbles, pumps, gravity switches, stars), and the level metadata.\n\nYou may reason step by step before the final answer. Place your final answer on the very last line of your reply, in the form: FINAL_JSON: \n\nThe JSON object must follow the commands schema described in section 8 of the user prompt: keys `commands`, `reason`, `confidence`. Multiple winning scripts may be valid; output any one. Do NOT wrap FINAL_JSON in Markdown code fences. Do NOT write anything after the FINAL_JSON line. Emit exactly one FINAL_JSON line.\n\nIf you cannot reason out a confident solution, still emit a best-effort FINAL_JSON line with at least one command and a confidence value below 1.0. Never refuse, never return prose only.", + "user": "## 1. TASK\nProduce a replayable command script that wins the Cut the Rope level shown in the gameplay video. The script must be deterministic so that replaying it from the same initial state in the simulator produces a win.\nThe level is solved when the candy reaches the target monster's mouth. Three-star completion is preferred but stable winning is the first priority.\n\n## 2. WORLD MODEL\n- Candy: a physics object affected by gravity, ropes, bubbles, pumps, and other active objects. Must be delivered to the target.\n- Target / monster: the level is won when the candy enters the target's mouth.\n- Rope: a constraint between the candy (or a split-candy half) and an anchor. Cutting a rope releases the candy from that constraint. Ropes are zero-indexed.\n- Grab: an anchor for a rope that can be repositioned during play. Zero-indexed.\n- Bubble: when the candy enters a bubble, it usually floats upward. Pop the bubble to release the candy.\n- Pump: a gust source that pushes objects. Each activation produces one impulse.\n- Gravity switch: toggles gravity direction or magnitude.\n- Star: collected by candy passing through its position. Up to 3 stars per level.\n- Split candy: some levels start with two candy halves (`left_candy`, `right_candy`). Use the half-specific conditions before the halves merge; switch to `candy_*` conditions after they merge.\n\n## 3. VISUAL LEGEND\n- The video is a short clip showing the full level layout and a coordinate grid overlay.\n- Coordinates: origin at the top-left corner. x increases to the right; y increases downward.\n- Indices in the video are zero-based for ropes, bubbles, pumps, and grabs. Infer indices from object positions and the order they appear in the clip.\n\n## 4. INPUT FIELDS\n- level_id: rope-096\n- canvas_size: 1920 x 1080\n- two_parts (split candy): False\n- object_counts:\n - target: 1\n - star: 3\n - candy: 1\n - rope/grab: 4\n - pump: 2\n- gameplay objects in this level:\n- Target (monster): the level is won when the candy reaches the monster's mouth. The target is usually fixed in place.\n- Candy: the candy is affected by gravity, ropes, bubbles, pumps, and other active objects. It must be delivered to the target.\n- Ropes / grabs: ropes constrain the candy or split-candy movement. `cut_rope N` cuts rope N; `cut_rope N,M,K` cuts multiple at once. If a grab can move, `move_grab N X` or `move_grab N X Y` repositions it.\n- Stars: candy or split-candy collects a star by passing through it. Prefer paths that collect 3 stars, but stable completion takes priority.\n- Pumps: activating a pump pushes nearby objects. `activate_pump N`, optionally with `times`/`every`/`until` modifiers for repeated activation.\n\n## 5. ACTION VOCABULARY\nA complete answer is one ordered command script (one command per line). Available actions:\n- `cut_rope N` — cut rope N\n- `cut_rope N,M,K` — cut several ropes simultaneously\n- `pop_bubble N` — pop bubble N\n- `pop_bubble_left` — pop the bubble holding the left split-candy half\n- `pop_bubble_right` — pop the bubble holding the right split-candy half\n- `activate_pump N` — fire pump N once\n- `activate_pump N times C` — fire C times back-to-back\n- `activate_pump N times C every S` — fire C times spaced S seconds apart\n- `activate_pump N every S until ` — fire repeatedly until CONDITION holds\n- `move_grab N X` — move grab N to x-coordinate X (y unchanged)\n- `move_grab N X Y` — move grab N to (X, Y)\n- `kick_rope N` — apply a one-shot impulse to rope N\n- `toggle_gravity` — toggle the gravity setting\n\nEach command may be guarded by an optional `when ` clause. Available condition primitives:\n- `candy_x > N`, `candy_x < N`, `candy_y > N`, `candy_y < N`\n- `candy_near X,Y,R` — candy is within radius R of (X,Y); optional `for S` requires the predicate to hold for S seconds\n- `candy_still for S` — candy speed is below threshold for S seconds (useful before cutting after a swing settles)\n- `left_candy_*` and `right_candy_*` mirror the candy_* primitives for the corresponding split half\n- `grab_x I > N`, `grab_y I < N`, `grab_near I,X,Y,R`\n- `rope_cut N` — rope N has been cut\n- `no_rope`, `candy_in_bubble`\n- Conditions can be combined with `and`, `or`, and parentheses.\n\n## 6. CONSTRAINTS\n- One command per line in the `commands` string.\n- Indices must be zero-based and consistent with the level video.\n- `wait_frames` is NOT allowed in this benchmark version. Use condition-based waits.\n- The script must be deterministic; do not output stochastic or \"either-or\" entries.\n- The script must terminate without manual intervention; the simulator runs it from the initial state and decides win/loss.\n\n## 7. SOLVING ADVICE\n- Identify which ropes mainly control the candy first; choose a cut order that releases the candy along the shortest stable path to the target.\n- When waiting for the candy to reach a place, prefer `candy_near` / `candy_y` / `candy_x` over fixed timing.\n- For repeated pumping, use `activate_pump N times C every S` or `activate_pump N every S until CONDITION`.\n- In split-candy levels, do NOT use `candy_still` / `candy_near` for the merged candy before the halves merge; use the `left_candy_*` / `right_candy_*` primitives instead.\n\n## 8. OUTPUT SCHEMA\nFINAL_JSON: {\"commands\":\"\",\"reason\":\"\",\"confidence\":<0..1>}\n- commands: string. One command per line; lines separated by `\\n`.\n- reason: short one-sentence explanation of the intended sequence.\n- confidence: float in `[0, 1]`.\n\n## 9. FINAL INSTRUCTION\nYou may include reasoning above, but the very last line of your reply must start with FINAL_JSON: followed by exactly one valid JSON object.\nDo not wrap FINAL_JSON in code fences and do not write anything after it." + } +}