public override int PrepareNextInstruction(InstructionBase instruction) { if (instruction is MergeSortInstruction) { MergeSortInstruction mergeSortInstruction = (MergeSortInstruction)instruction; } else if (instruction is MergeSortHolderInstruction) { } else { } // Display help on blackboard if (false) // help enabled { } else { //if (instruction.NextHolderID == Util.NO_INSTRUCTION) // skipping until next move // TODO: FIX Debug.Log("PrepareNextInstruction not implemented!"); return(1); } return(0); }
private MergeSortInstruction[] MergeInstructions(MergeSortInstruction[] left, MergeSortInstruction[] right) { Debug.Log("Merge: left length = " + left.Length + ", right length = " + right.Length); MergeSortInstruction[] result = new MergeSortInstruction[left.Length + right.Length]; int l = 0, r = 0; instructions.Add(instNr++, new InstructionBase(MERGE_START, instNr)); while (l < left.Length && r < right.Length) { instructions.Add(instNr++, new MergeSortInstruction(UtilSort.COMPARE_START_INST, instNr, l + r, Util.NO_VALUE, Util.NO_VALUE, left[l].SortingElementID, left[l].HolderID, UtilSort.NO_DESTINATION, left[l].Value, true, false)); instructions.Add(instNr++, new MergeSortInstruction(UtilSort.COMPARE_START_INST, instNr, l + r, Util.NO_VALUE, Util.NO_VALUE, right[r].SortingElementID, right[r].HolderID, UtilSort.NO_DESTINATION, right[r].Value, true, false)); if (left[l].Value <= right[r].Value) { result[l + r] = left[l]; l += 1; } else { result[l + r] = right[r]; r += 1; } // Add merged element int q = l + r - 1; bool isSorted = left.Length + right.Length == sortMain.SortSettings.NumberOfElements; instructions.Add(instNr++, new MergeSortInstruction(MERGE_ELEMENT, instNr, l + r, Util.NO_VALUE, Util.NO_VALUE, result[q].SortingElementID, result[q].HolderID, l + r, result[q].Value, false, isSorted)); } while (l < left.Length) { result[l + r] = left[l]; l += 1; // Add remaining merging element int q = l - 1; bool isSorted = left.Length + right.Length == sortMain.SortSettings.NumberOfElements; instructions.Add(instNr++, new MergeSortInstruction(MERGE_REMAINING_ELEMENT, instNr, l, 0, Util.NO_VALUE, result[q].SortingElementID, result[q].HolderID, l, result[q].Value, false, isSorted)); } while (r < right.Length) { result[l + r] = right[r]; r += 1; // Add remaining merging element int q = r - 1; bool isSorted = left.Length + right.Length == sortMain.SortSettings.NumberOfElements; instructions.Add(instNr++, new MergeSortInstruction(MERGE_REMAINING_ELEMENT, instNr, r, 1, Util.NO_VALUE, result[q].SortingElementID, result[q].HolderID, r, result[q].Value, true, isSorted)); } return(result); }
private MergeSortInstruction[] MergeSortInstructions(MergeSortInstruction[] list) { Debug.Log("Test: Length " + list.Length); if (list.Length <= 1) { return(list); } int leftLength = list.Length / 2; int rightLength = list.Length - leftLength; MergeSortInstruction[] left = new MergeSortInstruction[leftLength]; MergeSortInstruction[] right = new MergeSortInstruction[rightLength]; int leftHolderID = -1, rightHolderID = -1; if (firstSplit) { // Create new holders leftHolderID = 0; rightHolderID = numbElements / 2; instructions.Add(instNr++, new MergeSortHolderInstruction(CREATE_HOLDER, instNr, leftHolderID)); instructions.Add(instNr++, new MergeSortHolderInstruction(CREATE_HOLDER, instNr, rightHolderID)); firstSplit = false; } else { // When the number of extra holders are equal to the number of elements, place half at the same holder they are standing on, the rest the next holder to the right leftHolderID = list[0].HolderID; rightHolderID = leftHolderID + 1; instructions.Add(instNr++, new MergeSortHolderInstruction(CREATE_HOLDER, instNr, rightHolderID)); } for (int x = 0; x < list.Length; x++) { if (x < leftLength) { left[x] = list[x]; instructions.Add(instNr++, new MergeSortInstruction(MOVE_ELEMENT_TO_MERGE_HOLDER, instNr, x, Util.NO_VALUE, Util.NO_VALUE, list[x].SortingElementID, list[x].HolderID, leftHolderID, list[x].Value, false, false)); } else { right[x - rightLength] = list[x]; instructions.Add(instNr++, new MergeSortInstruction(MOVE_ELEMENT_TO_MERGE_HOLDER, instNr, x, Util.NO_VALUE, Util.NO_VALUE, list[x].SortingElementID, list[x].HolderID, rightHolderID, list[x].Value, false, false)); } } left = MergeSortInstructions(left); right = MergeSortInstructions(right); return(MergeInstructions(left, right)); }
public override Dictionary <int, InstructionBase> UserTestInstructions(InstructionBase[] list) { instructions = new Dictionary <int, InstructionBase>(); instNr = 0; nextMergeSortHolderID = list.Length; MergeSortInstruction[] mergeSortInitInst = new MergeSortInstruction[list.Length]; for (int i = 0; i < list.Length; i++) { mergeSortInitInst[i] = (MergeSortInstruction)list[i]; } MergeSortInstructions(mergeSortInitInst); return(instructions); }
public override InstructionBase[] CopyFirstState(GameObject[] sortingElements) { MergeSortInstruction[] elementStates = new MergeSortInstruction[sortingElements.Length]; for (int i = 0; i < sortingElements.Length; i++) { MergeSortElement element = sortingElements[i].GetComponent <MergeSortElement>(); int sortingElementID = element.SortingElementID; int holderID = element.CurrentStandingOn.HolderID; int value = element.Value; bool isCompare = element.IsCompare; bool isSorted = element.IsSorted; elementStates[i] = new MergeSortInstruction(Util.INIT_INSTRUCTION, 0, Util.NO_VALUE, Util.NO_VALUE, Util.NO_VALUE, sortingElementID, holderID, UtilSort.NO_DESTINATION, value, isCompare, isSorted); } return(elementStates); }
public override IEnumerator ExecuteDemoInstruction(InstructionBase instruction, bool increment) { // Gather information from instruction MergeSortInstruction mergeSortInstruction = null; MergeSortHolderInstruction mergeSortHolderInstruction = null; MergeSortElement sortingElement = null; MergeSortHolder holder = null; if (instruction is MergeSortInstruction) { mergeSortInstruction = (MergeSortInstruction)instruction; sortingElement = sortMain.ElementManager.GetSortingElement(mergeSortInstruction.SortingElementID).GetComponent <MergeSortElement>(); holder = sortMain.HolderManager.GetHolder(mergeSortInstruction.HolderID).GetComponent <MergeSortHolder>(); } else if (instruction is MergeSortHolderInstruction) { mergeSortHolderInstruction = (MergeSortHolderInstruction)instruction; } else 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 = 0; switch (instruction.Instruction) { case Util.FIRST_INSTRUCTION: lineOfCode = 0; if (increment) { lengthOfList = sortMain.SortSettings.NumberOfElements.ToString(); } else { lengthOfList = "N"; } break; case CREATE_HOLDER: lineOfCode = 0; if (increment) { CreateSplitHolder(mergeSortHolderInstruction.MergeHolderID); } else { Destroy(splitHolders[splitHolders.Count - 1].gameObject); } break; case MOVE_ELEMENT_TO_MERGE_HOLDER: lineOfCode = 0; if (increment) { sortingElement.transform.position = mergeSortManager.GetCorrectHolder(mergeSortInstruction.NextHolderID).transform.position + UtilSort.ABOVE_HOLDER_VR; } else { sortingElement.transform.position = sortMain.HolderManager.GetHolder(mergeSortInstruction.HolderID).transform.position + UtilSort.ABOVE_HOLDER_VR; } break; case MERGE_START: lineOfCode = 0; if (increment) { } else { } break; case UtilSort.COMPARE_START_INST: lineOfCode = 0; if (increment) { sortingElement.IsCompare = mergeSortInstruction.IsCompare; sortingElement.IsSorted = mergeSortInstruction.IsSorted; } else { sortingElement.IsCompare = !mergeSortInstruction.IsCompare; if (mergeSortInstruction.HolderID == sortingElement.SortingElementID) // works for worst case, none might be buggy { sortingElement.IsSorted = mergeSortInstruction.IsSorted; } else { sortingElement.IsSorted = !mergeSortInstruction.IsSorted; } } //PreparePseudocodeValue(sortingElement.Value, 2); UtilSort.IndicateElement(sortingElement.gameObject); break; case MERGE_ELEMENT: lineOfCode = 0; if (increment) { sortingElement.transform.position = sortMain.HolderManager.GetHolder(mergeSortInstruction.NextHolderID).transform.position + UtilSort.ABOVE_HOLDER_VR; } else { sortingElement.transform.position = sortMain.HolderManager.GetHolder(mergeSortInstruction.HolderID).transform.position + UtilSort.ABOVE_HOLDER_VR; } break; case MERGE_REMAINING_ELEMENT: lineOfCode = 0; if (increment) { sortingElement.transform.position = sortMain.HolderManager.GetHolder(mergeSortInstruction.NextHolderID).transform.position + UtilSort.ABOVE_HOLDER_VR; } else { sortingElement.transform.position = sortMain.HolderManager.GetHolder(mergeSortInstruction.HolderID).transform.position + UtilSort.ABOVE_HOLDER_VR; } break; case UtilSort.FINAL_INSTRUCTION: lineOfCode = 0; break; } prevHighlightedLineOfCode = lineOfCode; // Highlight part of code in pseudocode pseudoCodeViewer.SetCodeLine(CollectLine(lineOfCode), Util.HIGHLIGHT_STANDARD_COLOR); yield return(demoStepDuration); sortMain.WaitForSupportToComplete--; }