private void OnCollisionExit(Collision collision) { InsertionSortElement wasHolding = collision.collider.GetComponent <InsertionSortElement>(); if (wasHolding != null && isPivotHolder) { wasHolding.RigidBody.constraints = RigidbodyConstraints.None; // Unfreeze } }
public override InstructionBase[] CopyFirstState(GameObject[] sortingElements) { InsertionSortInstruction[] elementStates = new InsertionSortInstruction[sortingElements.Length]; for (int i = 0; i < sortingElements.Length; i++) { InsertionSortElement element = sortingElements[i].GetComponent <InsertionSortElement>(); int sortingElementID = element.SortingElementID; int holderID = element.CurrentStandingOn.HolderID; int value = element.Value; bool isPivot = element.IsPivot; bool isCompare = element.IsCompare; bool isSorted = element.IsSorted; elementStates[i] = new InsertionSortInstruction(UtilSort.INIT_INSTRUCTION, 0, UtilSort.NO_VALUE, UtilSort.NO_VALUE, UtilSort.NO_VALUE, sortingElementID, value, isCompare, isSorted, isPivot, holderID, UtilSort.NO_DESTINATION); // new InsertionSortInstruction(sortingElementID, holderID, Util.NO_DESTINATION, Util.NO_VALUE, Util.NO_VALUE, Util.INIT_INSTRUCTION, 0, value, isPivot, isCompare, isSorted); } return(elementStates); }
public override int PrepareNextInstruction(InstructionBase instruction) { Debug.Log(instruction.DebugInfo()); bool gotSortingElement = !insertionSort.SkipDict[UtilSort.SKIP_NO_ELEMENT].Contains(instruction.Instruction); bool noDestination = insertionSort.SkipDict[UtilSort.SKIP_NO_DESTINATION].Contains(instruction.Instruction); if (gotSortingElement) { InsertionSortInstruction insertionSortInstruction = (InsertionSortInstruction)instruction; // Get the Sorting element InsertionSortElement sortingElement = sortMain.ElementManager.GetSortingElement(insertionSortInstruction.SortingElementID).GetComponent <InsertionSortElement>(); // Hands out the next instruction sortingElement.Instruction = insertionSortInstruction; // Give this sorting element permission to give feedback to progress to next intstruction switch (instruction.Instruction) { case UtilSort.PIVOT_START_INST: case UtilSort.COMPARE_START_INST: case UtilSort.PIVOT_END_INST: case UtilSort.SWITCH_INST: sortingElement.NextMove = true; break; } //if (instruction.Instruction == UtilSort.PIVOT_START_INST || instruction.Instruction == UtilSort.PIVOT_END_INST || instruction.Instruction == UtilSort.SWITCH_INST) // sortingElement.NextMove = true; } // Display help on blackboard if (sortMain.SortSettings.Difficulty <= UtilSort.BEGINNER) { sortMain.WaitForSupportToComplete++; StartCoroutine(sortMain.GetTeachingAlgorithm().UserTestHighlightPseudoCode(instruction, gotSortingElement)); } if (gotSortingElement && !noDestination) { return(0); } return(1); }
public override IEnumerator UserTestHighlightPseudoCode(InstructionBase instruction, bool gotSortingElement) { // Gather information from instruction InsertionSortElement sortingElement = null; if (gotSortingElement) { sortingElement = sortMain.ElementManager.GetSortingElement(((InsertionSortInstruction)instruction).SortingElementID).GetComponent <InsertionSortElement>(); } if (instruction is InstructionLoop) { i = ((InstructionLoop)instruction).I; j = ((InstructionLoop)instruction).J; // k = ((InstructionLoop)instruction).K; } // Remove highlight from previous instruction pseudoCodeViewer.ChangeColorOfText(prevHighlightedLineOfCode, Util.BLACKBOARD_TEXT_COLOR); // Gather part of code to highlight int lineOfCode = Util.NO_VALUE; useHighlightColor = Util.HIGHLIGHT_STANDARD_COLOR; switch (instruction.Instruction) { case UtilSort.SET_SORTED_INST: UtilSort.IndicateElement(sortingElement.gameObject); break; case Util.FIRST_INSTRUCTION: lineOfCode = FirstInstructionCodeLine(); break; case UtilSort.FIRST_LOOP: lineOfCode = 2; i_str = i.ToString(); SetLengthOfList(); useHighlightColor = UseConditionColor(i < lengthOfListInteger); break; case Util.SET_VAR_J: lineOfCode = 3; iMinus1 = (i - 1).ToString(); break; case UtilSort.PIVOT_START_INST: lineOfCode = 4; useHighlightColor = Util.HIGHLIGHT_USER_ACTION; PreparePseudocodeValue(sortingElement.Value, 1); UtilSort.IndicateElement(sortingElement.gameObject); break; case UtilSort.COMPARE_START_INST: lineOfCode = 5; j_str = j.ToString(); useHighlightColor = Util.HIGHLIGHT_USER_ACTION; PreparePseudocodeValue(sortingElement.Value, 2); UtilSort.IndicateElement(sortingElement.gameObject); break; case UtilSort.UPDATE_LOOP_INST: // Update 2nd while loop when j < 0 lineOfCode = 5; useHighlightColor = Util.HIGHLIGHT_CONDITION_NOT_FULFILLED; j_str = j.ToString(); element2Value = "X"; break; case UtilSort.SWITCH_INST: lineOfCode = 6; jPlus1 = (j + 1).ToString(); useHighlightColor = Util.HIGHLIGHT_USER_ACTION; break; case Util.UPDATE_VAR_J: lineOfCode = 7; jMinus1 = (j - 1).ToString(); break; case UtilSort.COMPARE_END_INST: lineOfCode = 8; break; case UtilSort.PIVOT_END_INST: lineOfCode = 9; jPlus1 = (j + 1).ToString(); useHighlightColor = Util.HIGHLIGHT_USER_ACTION; break; case Util.INCREMENT_VAR_I: lineOfCode = 10; iPlus1 = (i + 1).ToString(); break; case Util.FINAL_INSTRUCTION: lineOfCode = FinalInstructionCodeLine(); break; } // Highlight part of code in pseudocode yield return(HighlightPseudoCode(CollectLine(lineOfCode), useHighlightColor)); // Mark prev for next round prevHighlightedLineOfCode = lineOfCode; sortMain.WaitForSupportToComplete--; }
public override IEnumerator ExecuteDemoInstruction(InstructionBase instruction, bool increment) { // Gather information from instruction InsertionSortInstruction insertionInstruction = null; InsertionSortElement sortingElement = null; if (instruction is InsertionSortInstruction) { insertionInstruction = (InsertionSortInstruction)instruction; // Change internal state of sorting element sortingElement = sortMain.ElementManager.GetSortingElement(insertionInstruction.SortingElementID).GetComponent <InsertionSortElement>(); } if (instruction is InstructionLoop) { i = ((InstructionLoop)instruction).I; j = ((InstructionLoop)instruction).J; //k = ((InstructionLoop)instruction).K; } // Remove highlight from previous instruction pseudoCodeViewer.ChangeColorOfText(prevHighlightedLineOfCode, Util.BLACKBOARD_TEXT_COLOR); // Gather part of code to highlight int lineOfCode = Util.NO_VALUE; useHighlightColor = Util.HIGHLIGHT_STANDARD_COLOR; switch (instruction.Instruction) { case UtilSort.SET_SORTED_INST: if (increment) { sortingElement.IsSorted = insertionInstruction.IsSorted; UtilSort.IndicateElement(sortingElement.gameObject); } else { sortingElement.IsSorted = !insertionInstruction.IsSorted; UtilSort.IndicateElement(sortingElement.gameObject); } break; case Util.FIRST_INSTRUCTION: lineOfCode = FirstInstructionCodeLine(); break; case UtilSort.FIRST_LOOP: lineOfCode = 2; if (increment) { i_str = i.ToString(); SetLengthOfList(); useHighlightColor = UseConditionColor(i < lengthOfListInteger); } else { if (i > 1) { i_str = (i - 1).ToString(); } else { i_str = "i"; lengthOfList = "len(list)"; } } break; case Util.SET_VAR_J: lineOfCode = 3; if (increment) { iMinus1 = (i - 1).ToString(); } else { if (i > 1) { iMinus1 = (i - 2).ToString(); } else { iMinus1 = "i - 1"; } } break; case UtilSort.PIVOT_START_INST: lineOfCode = 4; if (increment) { PreparePseudocodeValue(sortingElement.Value, 1); sortingElement.IsPivot = insertionInstruction.IsPivot; } else { element1Value = "list[i]"; sortingElement.IsPivot = !insertionInstruction.IsPivot; } UtilSort.IndicateElement(sortingElement.gameObject); break; case UtilSort.COMPARE_START_INST: lineOfCode = 5; if (increment) { PreparePseudocodeValue(sortingElement.Value, 2); sortingElement.IsCompare = insertionInstruction.IsCompare; sortingElement.IsSorted = insertionInstruction.IsSorted; j_str = j.ToString(); useHighlightColor = UseConditionColor(j >= 0 && sortingElement.Value > value1); } else { element2Value = "list[j]"; sortingElement.IsCompare = !insertionInstruction.IsCompare; sortingElement.IsSorted = !insertionInstruction.IsSorted; if (j > 0) { j_str = j.ToString(); } else { j_str = "j"; } } UtilSort.IndicateElement(sortingElement.gameObject); break; case UtilSort.UPDATE_LOOP_INST: // Update 2nd while loop when j < 0 lineOfCode = 5; if (increment) { j_str = j.ToString(); element2Value = "X"; useHighlightColor = Util.HIGHLIGHT_CONDITION_NOT_FULFILLED; } else { j_str = "j"; element2Value = "list[j]"; } break; case UtilSort.SWITCH_INST: lineOfCode = 6; if (increment) { //PreparePseudocodeValue(sortingElement.Value, 2); // testing sortingElement.IsCompare = insertionInstruction.IsCompare; sortingElement.IsSorted = insertionInstruction.IsSorted; jPlus1 = (j + 1).ToString(); } else { element2Value = "list[j]"; jPlus1 = "j + 1"; sortingElement.IsCompare = !insertionInstruction.IsCompare; } break; case Util.UPDATE_VAR_J: lineOfCode = 7; if (increment) { jMinus1 = (j - 1).ToString(); } else { if (i > 1) { jMinus1 = j.ToString(); } else { jMinus1 = "j - 1"; } } break; case UtilSort.COMPARE_END_INST: if (increment) { sortingElement.IsCompare = insertionInstruction.IsCompare; sortingElement.IsSorted = insertionInstruction.IsSorted; } else { sortingElement.IsCompare = !insertionInstruction.IsCompare; sortingElement.IsSorted = !insertionInstruction.IsSorted; } UtilSort.IndicateElement(sortingElement.gameObject); lineOfCode = 8; break; case UtilSort.PIVOT_END_INST: lineOfCode = 9; if (increment) { sortingElement.IsPivot = insertionInstruction.IsPivot; sortingElement.IsSorted = insertionInstruction.IsSorted; jPlus1 = (j + 1).ToString(); } else { PreparePseudocodeValue(sortingElement.Value, 1); sortingElement.IsPivot = !insertionInstruction.IsPivot; sortingElement.IsSorted = !insertionInstruction.IsSorted; jPlus1 = "j + 1"; } UtilSort.IndicateElement(sortingElement.gameObject); break; case Util.INCREMENT_VAR_I: lineOfCode = 10; if (increment) { iPlus1 = (i + 1).ToString(); } else { if (i > 1) { iPlus1 = i.ToString(); } else { iPlus1 = "i + 1"; } } break; case Util.FINAL_INSTRUCTION: lineOfCode = FinalInstructionCodeLine(); IsTaskCompleted = increment; break; } // Highlight part of code in pseudocode yield return(HighlightPseudoCode(CollectLine(lineOfCode), useHighlightColor)); // Mark prev for next round prevHighlightedLineOfCode = lineOfCode; // Move sorting element if (instruction is InsertionSortInstruction) { switch (insertionInstruction.Instruction) { case UtilSort.COMPARE_START_INST: // testing if (increment) { // Positioning the pivot holder behind/slightly above comparing element pivotHolder.transform.position = new Vector3(insertionSortManager.GetCorrectHolder(sortingElement.CurrentStandingOn.HolderID).transform.position.x, pivotHolder.transform.position.y, pivotHolder.transform.position.z); // Postitioning the pivot element on top of the pivot holder SortingElementBase pivotElement = pivotHolder.CurrentHolding; pivotElement.transform.position = pivotHolder.transform.position + UtilSort.ABOVE_HOLDER_VR; pivotElement.transform.rotation = Quaternion.identity; } else { //sortingElement.transform.position = insertionSortManager.GetCorrectHolder(insertionInstruction.HolderID).transform.position + Util.ABOVE_HOLDER_VR; } break; case UtilSort.PIVOT_START_INST: // tesing (was combined with switch/pivot_end if (increment) { pivotHolder.transform.position = new Vector3(insertionSortManager.GetCorrectHolder(sortingElement.CurrentStandingOn.HolderID).transform.position.x, pivotHolder.transform.position.y, pivotHolder.transform.position.z); sortingElement.transform.position = pivotHolder.transform.position + UtilSort.ABOVE_HOLDER_VR; sortingElement.transform.rotation = Quaternion.identity; } else { // sortingElement.transform.position = insertionSortManager.GetCorrectHolder(insertionInstruction.HolderID).transform.position + UtilSort.ABOVE_HOLDER_VR; sortingElement.transform.rotation = Quaternion.identity; } break; //case Util.PIVOT_START_INST: // original working setup (non moving pivot holder) case UtilSort.SWITCH_INST: case UtilSort.PIVOT_END_INST: if (increment) { sortingElement.transform.position = insertionSortManager.GetCorrectHolder(insertionInstruction.NextHolderID).transform.position + UtilSort.ABOVE_HOLDER_VR; sortingElement.transform.rotation = Quaternion.identity; } else { sortingElement.transform.position = insertionSortManager.GetCorrectHolder(insertionInstruction.HolderID).transform.position + UtilSort.ABOVE_HOLDER_VR; sortingElement.transform.rotation = Quaternion.identity; } break; } } sortMain.WaitForSupportToComplete--; }
public override IEnumerator Demo(GameObject[] list) { Vector3 temp = new Vector3(); // Set first element as sorted list[0].GetComponent <SortingElementBase>().IsSorted = true; UtilSort.IndicateElement(list[0]); yield return(demoStepDuration); int listLength = list.Length; lengthOfList = listLength.ToString(); // Pseudocode i = 1; // Display pseudocode (set i) yield return(HighlightPseudoCode(CollectLine(1), Util.HIGHLIGHT_STANDARD_COLOR)); while (i < listLength) { // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } // Display pseudocode (1st while) yield return(HighlightPseudoCode(CollectLine(2), Util.HIGHLIGHT_STANDARD_COLOR)); // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } // Get index of first element to the left of the pivot and compare j = i - 1; // Display pseudocode (set j) yield return(HighlightPseudoCode(CollectLine(3), Util.HIGHLIGHT_STANDARD_COLOR)); // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } // Get pivot GameObject pivotObj = list[i]; InsertionSortElement pivot = list[i].GetComponent <InsertionSortElement>(); pivot.IsPivot = true; // Get pivot's initial position temp = pivot.transform.position; // Place pivot holder above the pivot element pivotHolder.transform.position = temp + pivotHolderPos; // Place the pivot on top of the pivot holder pivot.transform.position = temp + tutorialPivotElementHeight; // Set first values here to display on blackboard PreparePseudocodeValue(pivot.Value, 1); PreparePseudocodeValue(list[j].GetComponent <InsertionSortElement>().Value, 2); // Display pseudocode (set pivot) yield return(HighlightPseudoCode(CollectLine(4), Util.HIGHLIGHT_STANDARD_COLOR)); // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } // Start comparing until find the correct position is found // Prepare the element to compare with GameObject compareObj = list[j]; InsertionSortElement compare = compareObj.GetComponent <InsertionSortElement>(); compare.IsCompare = true; UtilSort.IndicateElement(compare.gameObject); // Display pseudocode (2nd while) yield return(HighlightPseudoCode(CollectLine(5), Util.HIGHLIGHT_STANDARD_COLOR)); // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } compare.IsCompare = false; compare.IsSorted = true; while (value1 < value2) { // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } // Pivot is smaller, start moving compare element // Compare element's position Vector3 temp2 = compare.transform.position; // Moving other element one index to the right compare.transform.position = temp; // Updating list list[j + 1] = compareObj; // Display pseudocode (move compare element) yield return(HighlightPseudoCode(CollectLine(6), Util.HIGHLIGHT_STANDARD_COLOR)); // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } // Preparing for next step temp = temp2; // Display pseudocode (update j) yield return(HighlightPseudoCode(CollectLine(7), Util.HIGHLIGHT_STANDARD_COLOR)); j -= 1; // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } // Move pivot out and place it ontop of pivot holder (above holder it check whether it's put the element) pivotHolder.transform.position = temp + pivotHolderPos; pivot.transform.position = temp + tutorialPivotElementHeight; // Wait to show the pivot being moved yield return(demoStepDuration); // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } // Check if there are more elements to compare the pivot with if (j >= 0) { // Start comparing until find the correct position is found // Prepare the element to compare with compareObj = list[j]; compare = compareObj.GetComponent <InsertionSortElement>(); compare.IsCompare = true; PreparePseudocodeValue(compare.Value, 2); UtilSort.IndicateElement(compare.gameObject); // Display pseudocode (2nd while new compare value) yield return(HighlightPseudoCode(CollectLine(5), Util.HIGHLIGHT_STANDARD_COLOR)); // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } compare.IsCompare = false; compare.IsSorted = true; if (value1 >= value2) { UtilSort.IndicateElement(compare.gameObject); // Display pseudocode (end 2nd while) yield return(HighlightPseudoCode(CollectLine(8), Util.HIGHLIGHT_STANDARD_COLOR)); // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } } } else { // Display pseudocode (end 2nd while) yield return(HighlightPseudoCode(CollectLine(8), Util.HIGHLIGHT_STANDARD_COLOR)); break; } } // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } if (i == 1 && value1 >= value2) { compare.CurrentStandingOn.CurrentColor = UtilSort.SORTED_COLOR; } // Finish off the pivots work pivot.IsSorted = true; pivot.IsPivot = false; pivot.transform.position = temp; // Put pivot object back into the list list[j + 1] = pivotObj; yield return(HighlightPseudoCode(CollectLine(9), Util.HIGHLIGHT_STANDARD_COLOR)); // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } // Display pseudocode (increment i) yield return(HighlightPseudoCode(CollectLine(10), Util.HIGHLIGHT_STANDARD_COLOR)); i += 1; // Check if user wants to stop the demo if (sortMain.UserStoppedTask) { break; } } // Display pseudocode (end 1st while) yield return(HighlightPseudoCode(CollectLine(11), Util.HIGHLIGHT_STANDARD_COLOR)); // Mark the last element sorted InsertionSortElement lastElement = null; if (list[list.Length - 1] != null) { lastElement = list[list.Length - 1].GetComponent <InsertionSortElement>(); } if (lastElement != null) { lastElement.IsSorted = true; } // Finished off; remove pivot holder PivotHolderVisible(false); if (sortMain.UserStoppedTask) { sortMain.UpdateCheckList(Util.DEMO, true); } else { isTaskCompleted = true; } }