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--;
}
