// Fetch instruction
protected virtual void DemoUpdate()
{
if (newDemoImplemented)
{
InstructionBase instruction = null;
// Step by step activated by pausing, and step requested
if (userPausedTask && demoManager.PlayerMove)
{
demoManager.PlayerMove = false;
instruction = demoManager.GetStep();
bool increment = demoManager.PlayerIncremented;
PerformInstruction(instruction, increment);
}
else if (!userPausedTask && demoManager.HasInstructions()) // Demo mode
{
// First check if user test setup is complete
if (!WaitingForSupportToFinish())//waitForSupportToComplete == 0)
{
instruction = demoManager.GetInstruction();
//Debug.Log("Current: " + demoManager.CurrentInstructionNr + ", Actual: " + instruction.InstructionNr);
PerformInstruction(instruction, true);
demoManager.IncrementToNextInstruction();
}
}
// Debugging
if (instruction != null && prevInstruction != instruction.Instruction)
{
prevInstruction = instruction.DebugInfo();
Debug.Log(instruction.DebugInfo());
if (useDebugText && debugText != null)
{
if (deleteWhenReached <= 0)
{
debugText.text = instruction.DebugInfo();
deleteWhenReached = debugLineNumbers;
}
else
{
debugText.text += "\n" + instruction.DebugInfo();
}
deleteWhenReached--;
}
}
}
}
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 int PrepareNextInstruction(InstructionBase instruction)
{
Debug.Log(instruction.DebugInfo());
bool gotSortingElement = !bubbleSort.SkipDict[UtilSort.SKIP_NO_ELEMENT].Contains(instruction.Instruction);
bool noDestination = bubbleSort.SkipDict[UtilSort.SKIP_NO_DESTINATION].Contains(instruction.Instruction);
if (gotSortingElement)
{
// Get the next two instructions
BubbleSortInstruction bubbleInstruction = (BubbleSortInstruction)instruction;
// Find the sorting elements for this instruction
BubbleSortElement s1 = sortMain.ElementManager.GetSortingElement(bubbleInstruction.SortingElementID1).GetComponent <BubbleSortElement>();
BubbleSortElement s2 = sortMain.ElementManager.GetSortingElement(bubbleInstruction.SortingElementID2).GetComponent <BubbleSortElement>();
// Hand the instructions out
s1.Instruction = bubbleInstruction;
s2.Instruction = bubbleInstruction;
// Give this sorting element permission to give feedback to progress to next intstruction
if (instruction.Instruction == UtilSort.COMPARE_START_INST || instruction.Instruction == UtilSort.SWITCH_INST)
{
s1.NextMove = true;
s2.NextMove = true;
}
}
if (sortMain.SortSettings.Difficulty <= Util.BEGINNER)
{
sortMain.WaitForSupportToComplete++;
StartCoroutine(sortMain.GetTeachingAlgorithm().UserTestHighlightPseudoCode(instruction, gotSortingElement));
}
if (gotSortingElement && !noDestination)
{
return(0);
}
return(2);
}
public override int PrepareNextInstruction(InstructionBase instruction)
{
Debug.Log(instruction.DebugInfo());
bool gotSortingElement = !bucketSort.SkipDict[Util.SKIP_NO_ELEMENT].Contains(instruction.Instruction);
bool noDestination = bucketSort.SkipDict[Util.SKIP_NO_DESTINATION].Contains(instruction.Instruction);
switch (instruction.Instruction)
{
case UtilSort.PHASING_INST:
// Phase into Insertion Sort?
bucketManager.AutoSortBuckets();
break;
case UtilSort.DISPLAY_ELEMENT:
Debug.Log("Display elements");
// Display elements on top of bucket
sortMain.WaitForSupportToComplete++;
StartCoroutine(bucketManager.PutElementsForDisplay(((BucketSortInstruction)instruction).BucketID));
return(1); // Nothing to do for the player, nor any pseudocode
}
if (instruction is BucketSortInstruction)
{
// Get the next instruction
BucketSortInstruction bucketSortInstruction = (BucketSortInstruction)instruction;
// Get the Sorting element
BucketSortElement sortingElement = sortMain.ElementManager.GetSortingElement(bucketSortInstruction.SortingElementID).GetComponent <BucketSortElement>();
// Hands out the next instruction
sortingElement.Instruction = bucketSortInstruction;
Bucket bucket = bucketManager.GetBucket(bucketSortInstruction.BucketID);
bucket.BucketSortInstruction = bucketSortInstruction;
// Give this sorting element permission to give feedback to progress to next intstruction
if (instruction.Instruction == UtilSort.MOVE_TO_BUCKET_INST || instruction.Instruction == UtilSort.MOVE_BACK_INST)
{
sortingElement.NextMove = true;
}
}
// Display help on blackboard
if (sortMain.SortSettings.Difficulty <= Util.BEGINNER)
{
sortMain.WaitForSupportToComplete++;
StartCoroutine(sortMain.GetTeachingAlgorithm().UserTestHighlightPseudoCode(instruction, gotSortingElement));
}
Debug.Log("Element: " + gotSortingElement + ", no destination: " + noDestination);
if (gotSortingElement && !noDestination)
{
return(0);
}
Debug.Log(">>>>>>>>>>>>>>>>>>>>>>>>>>>> Nothing for player to do, continuing to next instruction");
return(1);
}
// User test
public int PrepareNextInstruction(InstructionBase instruction)
{
string inst = instruction.Instruction;
Debug.Log(">>> " + instruction.DebugInfo());
// First check whether the instruction contains a node and/or destination
bool gotNode = !graphAlgorithm.SkipDict[Util.SKIP_NO_ELEMENT].Contains(inst);
bool noDestination = graphAlgorithm.SkipDict[Util.SKIP_NO_DESTINATION].Contains(inst);
// List visual Update
if (instruction is ListVisualInstruction)
{
// Only provide list visual support until <lvl>
if (graphSettings.Difficulty > UtilGraph.LIST_VISUAL_MAX_DIFFICULTY)
{
return(1);
}
ListVisualInstruction listVisualInst = (ListVisualInstruction)instruction;
listVisual.ExecuteInstruction(listVisualInst, true);
//Debug.Log("List visual instruction: " + listVisualInst.DebugInfo());
}
else
{
Node node = null;
if (gotNode)
{
if (instruction is TraverseInstruction)
{
TraverseInstruction traverseInstruction = (TraverseInstruction)instruction;
//Debug.Log("Traverse instruction: " + traverseInstruction.DebugInfo());
// Get the Sorting element
node = traverseInstruction.Node;
// Hands out the next instruction
node.Instruction = traverseInstruction;
// Set goal
posManager.CurrentGoal = node;
// Reset if pointer must be used on the same node twice
if (traverseInstruction.VisitInst && pointer.prevNodeShot == node)
{
pointer.prevNodeShot = null;
}
// Reset position manager if the user already stands on top of the node
if (traverseInstruction.TraverseInst && posManager.ReportedNode == node)
{
posManager.ReportedNode = null;
}
// Give this sorting element permission to give feedback to progress to next intstruction
node.NextMove = NextIsUserMove(inst);
// Traverse instruction extra
switch (inst)
{
// Highlight the node we are currently going to work at
case UtilGraph.DEQUEUE_NODE_INST:
case UtilGraph.POP_INST:
case UtilGraph.PRIORITY_REMOVE_NODE:
// Hide all edge cost to make it easier to see node distances
if (graphSettings.GraphTask == UtilGraph.SHORTEST_PATH)
{
graphManager.MakeEdgeCostVisible(false);
}
break;
case UtilGraph.FOR_ALL_NEIGHBORS_INST:
// Make edge cost visible again
if (graphSettings.GraphTask == UtilGraph.SHORTEST_PATH)
{
graphManager.MakeEdgeCostVisible(true);
}
break;
}
// Perform list visual instruction in next step (when current instruction has been correctly performed)
if (traverseInstruction.ListVisualInstruction != null)
{
updateListVisualInstruction = traverseInstruction.ListVisualInstruction;
}
}
else if (instruction is ShortestPathInstruction)
{
ShortestPathInstruction spInst = (ShortestPathInstruction)instruction;
//Debug.Log("Shortest path instruction: " + spInst.DebugInfo());
// Get the Sorting element
if (spInst.CurrentNode != null)
{
node = spInst.CurrentNode;
}
else
{
node = spInst.ConnectedNode;
}
// Hands out the next instruction
node.Instruction = spInst;
// Set goal
posManager.CurrentGoal = node;
// Give this sorting element permission to give feedback to progress to next intstruction
node.NextMove = NextIsUserMove(inst);
// Shortest path extra
switch (inst)
{
case UtilGraph.IF_DIST_PLUS_EDGE_COST_LESS_THAN:
// Turn off highlight effect of previous line
pseudoCodeViewer.ChangeColorOfText(8, Util.BLACKBOARD_TEXT_COLOR);
// Since we highlighted the color and/or text position of the node/edge we are working on (highlighting purpose) in the previous instruction, now we reset them
// Changed color of node
spInst.ConnectedNode.CurrentColor = UtilGraph.VISITED_COLOR;
// Reset text color/position of the edge cost
spInst.CurrentEdge.CurrentColor = UtilGraph.VISITED_COLOR;
// Perform sub task: calculate dist (current node) + edge cost to the connected node
if (!autoCalculation)
{
usingCalculator = true;
pointer.AllowShooting = false;
calculator.InitCalculation(Calculator.GRAPH_TASK);
calculator.SpawnDeviceInfrontOfPlayer();
}
break;
}
// Perform list visual instruction in next step (when current instruction has been correctly performed)
if (spInst.ListVisualInstruction != null)
{
updateListVisualInstruction = spInst.ListVisualInstruction;
}
}
}
}
// Display help on blackboard
if (graphSettings.Difficulty <= Util.PSEUDO_CODE_HIGHTLIGHT_MAX_DIFFICULTY)
{
WaitForSupportToComplete++;
StartCoroutine(graphAlgorithm.UserTestHighlightPseudoCode(instruction, gotNode));// && !noDestination));
}
// InstructionBase extra
switch (inst)
{
case UtilGraph.SET_ALL_NODES_TO_INFINITY:
graphManager.SetAllNodesDist(UtilGraph.INF);
break;
case UtilGraph.SET_START_NODE_DIST_TO_ZERO:
// Find start node and set distance to 0
Node startNode = graphManager.StartNode;
startNode.Dist = 0;
// If list visual: update value
if (Settings.Difficulty <= UtilGraph.LIST_VISUAL_MAX_DIFFICULTY)
{
listVisual.FindNodeRepresentation(startNode).UpdateSurfaceText(UtilGraph.DIST_UPDATE_COLOR);
}
break;
case UtilGraph.MARK_END_NODE:
Node endNode = graphManager.EndNode;
endNode.CurrentColor = UtilGraph.SHORTEST_PATH_COLOR;
endNode.PrevEdge.CurrentColor = UtilGraph.SHORTEST_PATH_COLOR;
break;
case UtilGraph.END_FOR_LOOP_INST:
if (graphSettings.Difficulty <= UtilGraph.LIST_VISUAL_MAX_DIFFICULTY)
{
listVisual.DestroyCurrentNode();
}
break;
case UtilGraph.NO_PATH_FOUND:
case Util.FINAL_INSTRUCTION:
// No path found
WaitForSupportToComplete++;
StartCoroutine(FinishUserTest());
break;
}
//Debug.Log("Got node: " + gotNode + ", no destination: " + noDestination);
if (gotNode && !noDestination)
{
return(0);
}
//Debug.Log("Nothing to do for player, get another instruction");
return(1);
}