private void OnTriggerEnter(Collider other) { if (other.tag == UtilSort.SORTING_ELEMENT_TAG) { BucketSortElement sortingElement = other.GetComponent <BucketSortElement>(); // Check for bug(same sorting element got added twice) //if (prevSortingElementID == sortingElement.SortingElementID) // return; if (enterTrigger.enabled) { if (parent.SortSettings.IsDemo()) { if (ValidateSortingElement(sortingElement)) // !displayElements && { // Do animation (color -> green -> color) AddSortingElementToBucket(sortingElement); prevSortingElementID = sortingElement.SortingElementID; } else { // Can't be put into this bucket StartCoroutine(Animation(ERROR, 2)); } } else // User test { if (sortingElement.Instruction is BucketSortInstruction) { BucketSortInstruction inst = (BucketSortInstruction)sortingElement.Instruction; if (instruction == sortingElement.Instruction && instruction.Instruction == UtilSort.MOVE_TO_BUCKET_INST) // inst.Instruction == UtilSort.MOVE_TO_BUCKET_INST && inst.BucketID == bucketID { AddSortingElementToBucket(sortingElement); prevSortingElementID = sortingElement.SortingElementID; // Score parent.GetComponent <UserTestManager>().IncrementTotalCorrect(); // Progress user test parent.GetComponent <UserTestManager>().ReadyForNext += 1; } else if (ValidateSortingElement(sortingElement)) { } else { // Can't be put into this bucket StartCoroutine(Animation(ERROR, 2)); parent.GetComponent <UserTestManager>().Mistake(); } } } } else if (onTopOfBucketTrigger.enabled) { } } }
// public IEnumerator PutElementsForDisplay(int bucketID) { //sortMain.UpdateCheckList(UtilSort.ALGORITHM_MANAGER, false); Bucket bucket = GetBucket(bucketID); bucket.SetEnterTrigger(false); yield return(emptyBucketDuration); int numberOfElements = bucket.CurrenHolding.Count; if (numberOfElements > 0) { for (int y = 0; y < numberOfElements; y++) { BucketSortElement element = (BucketSortElement)bucket.GetElementForDisplay(y); bucket.PutElementForDisplay(element); StartCoroutine(bucket.Animation(Bucket.HIGHLIGHT, 1)); yield return(emptyBucketDuration); } bucket.Empty(); } //sortMain.UpdateCheckList(UtilSort.ALGORITHM_MANAGER, true); superElement.WaitForSupportToComplete--; }
private void OnTriggerExit(Collider other) { if (other.tag == UtilSort.SORTING_ELEMENT_TAG) { BucketSortElement sortingElement = other.GetComponent <BucketSortElement>(); if (onTopOfBucketTrigger.enabled) { sortingElement.CurrentInside = null; RemoveSortingElement(sortingElement); sortingElement.RigidBody.constraints = RigidbodyConstraints.None; prevSortingElementID = -1; } } }
public override InstructionBase[] CopyFirstState(GameObject[] sortingElements) { BucketSortInstruction[] elementStates = new BucketSortInstruction[sortingElements.Length]; for (int i = 0; i < sortingElements.Length; i++) { BucketSortElement element = sortingElements[i].GetComponent <BucketSortElement>(); 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 BucketSortInstruction(Util.INIT_INSTRUCTION, 0, Util.NO_VALUE, Util.NO_VALUE, Util.NO_VALUE, sortingElementID, value, isCompare, isSorted, holderID, UtilSort.NO_DESTINATION, Util.NO_VALUE); } return(elementStates); }
public void PutElementForDisplay(BucketSortElement sortingElement) { Debug.Log("Putting element " + sortingElement.SortingElementID + " for display"); // Make sure it's still considered inside the bucket sortingElement.CurrentInside = this; // Fix position and rotation sortingElement.transform.position = dropElementForDisplayPos.position; sortingElement.transform.rotation = Quaternion.identity; // Enable Y-axis movement sortingElement.RigidBody.constraints = ~RigidbodyConstraints.FreezePositionY; sortingElement.GetComponent <ElementInteraction>().PutBack(); // Disable all constraints after some seconds //StartCoroutine(RemoveConstraintsDelay(sortingElement)); }
protected override void OnCollisionEnter(Collision collision) { base.OnCollisionEnter(collision); if (collision.collider.tag == UtilSort.SORTING_ELEMENT_TAG) { // Current holding the sorting element that collided BucketSortElement element = collision.collider.GetComponent <BucketSortElement>(); CurrentHolding = element; // Demo if (parent.SortSettings.IsDemo()) { if (currentHolding.IsCompare) { CurrentColor = UtilSort.COMPARE_COLOR; } if (currentHolding.IsSorted) { CurrentColor = UtilSort.SORTED_COLOR; } } } }
public void AddSortingElementToBucket(SortingElementBase sortingElement) { if (currentHolding.Contains(sortingElement)) { return; } Debug.Log("Adding element: " + sortingElement.SortingElementID); currentHolding.Add(sortingElement); // Change transform parent to this bucket sortingElement.transform.parent = transform; if (sortingElement is BucketSortElement) { BucketSortElement bucketSortElement = (BucketSortElement)sortingElement; bucketSortElement.CurrentInside = this; StartCoroutine(Animation(ENTER, 3)); // Make invisible bucketSortElement.transform.position = transform.position; bucketSortElement.RigidBody.constraints = RigidbodyConstraints.FreezeAll; } }
public override IEnumerator UserTestHighlightPseudoCode(InstructionBase instruction, bool gotSortingElement) { // Gather information from instruction BucketSortInstruction bucketInstruction = null; BucketSortElement sortingElement = null; if (gotSortingElement) { bucketInstruction = (BucketSortInstruction)instruction; // Change internal state of sorting element sortingElement = sortMain.ElementManager.GetSortingElement(bucketInstruction.SortingElementID).GetComponent <BucketSortElement>(); } if (instruction is InstructionLoop) { InstructionLoop loopInst = (InstructionLoop)instruction; i = loopInst.I; j = loopInst.J; k = loopInst.K; loopType = loopInst.LoopType; } // 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 Util.FIRST_INSTRUCTION: lineOfCode = FirstInstructionCodeLine(); SetLengthOfList(); numberOfBuckets = bucketSortManager.NumberOfBuckets.ToString(); break; case UtilSort.CREATE_BUCKETS_INST: lineOfCode = 1; break; case UtilSort.FIRST_LOOP: lineOfCode = 2; useHighlightColor = UseConditionColor(i != lengthOfListInteger); break; case UtilSort.BUCKET_INDEX_INST: lineOfCode = 3; PreparePseudocodeValue(sortingElement.Value, 1); bucketIndex = bucketInstruction.BucketID; bucketIndexStr = bucketIndex.ToString(); //sortingElement.IsCompare = bucketInstruction.IsCompare; UtilSort.IndicateElement(sortingElement.gameObject); break; case UtilSort.MOVE_TO_BUCKET_INST: lineOfCode = 4; useHighlightColor = Util.HIGHLIGHT_USER_ACTION; PreparePseudocodeValue(sortingElement.Value, 1); UtilSort.IndicateElement(sortingElement.gameObject); //sortingElement.IsCompare = bucketInstruction.IsCompare; break; case UtilSort.END_LOOP_INST: switch (loopType) { case UtilSort.OUTER_LOOP: lineOfCode = 5; break; case UtilSort.INNER_LOOP: lineOfCode = 12; break; default: Debug.LogError(UtilSort.END_LOOP_INST + ": '" + loopType + "' loop not found"); break; } break; case UtilSort.PHASING_INST: lineOfCode = 6; break; case Util.SET_VAR_K: lineOfCode = 7; break; case UtilSort.UPDATE_LOOP_INST: if (loopType == UtilSort.OUTER_LOOP) // 2nd loop (outher) { //j = 0; lineOfCode = 8; useHighlightColor = UseConditionColor(i != j); } else // 2nd loop (inner) { lineOfCode = 9; bucketSize = k.ToString(); useHighlightColor = UseConditionColor(j != k); } break; case UtilSort.MOVE_BACK_INST: lineOfCode = 10; useHighlightColor = Util.HIGHLIGHT_USER_ACTION; PreparePseudocodeValue(sortingElement.Value, 2); break; case Util.UPDATE_VAR_K: lineOfCode = 11; kPlus1 = (k + 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 BucketSortInstruction bucketInstruction = null; BucketSortElement sortingElement = null; if (instruction is BucketSortInstruction) { bucketInstruction = (BucketSortInstruction)instruction; // Change internal state of sorting element sortingElement = sortMain.ElementManager.GetSortingElement(bucketInstruction.SortingElementID).GetComponent <BucketSortElement>(); bucketIndex = bucketInstruction.BucketID; } if (instruction is InstructionLoop) { InstructionLoop loopInst = (InstructionLoop)instruction; i = loopInst.I; j = loopInst.J; k = loopInst.K; loopType = loopInst.LoopType; } // 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 Util.FIRST_INSTRUCTION: lineOfCode = FirstInstructionCodeLine(); SetBuckets(increment); break; case UtilSort.CREATE_BUCKETS_INST: lineOfCode = 1; SetBuckets(increment); break; case UtilSort.FIRST_LOOP: lineOfCode = 2; if (increment) { SetLengthOfList(); useHighlightColor = UseConditionColor(i != lengthOfListInteger); } else { if (i == 0) { lengthOfList = "len(list)"; } else { i -= 1; } } break; case UtilSort.BUCKET_INDEX_INST: lineOfCode = 3; PreparePseudocodeValue(sortingElement.Value, 1); bucketIndex = bucketInstruction.BucketID; if (increment) { sortingElement.IsCompare = bucketInstruction.IsCompare; bucketIndexStr = bucketIndex.ToString(); } else { sortingElement.IsCompare = !bucketInstruction.IsCompare; bucketIndexStr = "list[i] * N / MAX_VALUE"; } UtilSort.IndicateElement(sortingElement.gameObject); break; case UtilSort.MOVE_TO_BUCKET_INST: lineOfCode = 4; if (increment) { PreparePseudocodeValue(sortingElement.Value, 1); bucketIndex = bucketInstruction.BucketID; sortingElement.IsCompare = bucketInstruction.IsCompare; } else { element1Value = "list[i]"; //bucketIndex = ""; // TODO ? sortingElement.IsCompare = !bucketInstruction.IsCompare; } UtilSort.IndicateElement(sortingElement.gameObject); break; case UtilSort.END_LOOP_INST: switch (loopType) { case UtilSort.OUTER_LOOP: lineOfCode = 5; break; case UtilSort.INNER_LOOP: lineOfCode = 12; break; default: Debug.LogError(UtilSort.END_LOOP_INST + ": '" + loopType + "' loop not found"); break; } break; case UtilSort.PHASING_INST: lineOfCode = 6; i = 0; // ???? j = (bucketSortManager.NumberOfBuckets - 1); bucketIndex = j; // Sort buckets bucketManager.AutoSortBuckets(); break; case UtilSort.DISPLAY_ELEMENT: // TODO: Fix //sortMain.WaitForSupportToComplete++; // add to list? StartCoroutine(bucketManager.PutElementsForDisplay(bucketInstruction.BucketID)); if (!increment) { bucketManager.GetBucket(bucketIndex).SetEnterTrigger(true); } break; case Util.SET_VAR_K: lineOfCode = 7; break; case UtilSort.UPDATE_LOOP_INST: if (loopType == UtilSort.OUTER_LOOP) // 2nd loop (outher) { //j = 0; lineOfCode = 8; if (increment) { numberOfBuckets = bucketSortManager.NumberOfBuckets.ToString(); useHighlightColor = UseConditionColor(i != j); } else { if (i > 0) { i -= 1; } else { numberOfBuckets = "N"; } } } else // 2nd loop (inner) { lineOfCode = 9; if (increment) { bucketSize = k.ToString(); useHighlightColor = UseConditionColor(j != k); } else { if (j > 0) { j--; } else { bucketSize = k.ToString(); } } } break; case UtilSort.MOVE_BACK_INST: lineOfCode = 10; k = bucketInstruction.NextHolderID; // ??? if (increment) { PreparePseudocodeValue(sortingElement.Value, 2); sortingElement.IsSorted = bucketInstruction.IsSorted; } else { element2Value = "buckets[" + i + "][" + j + "]"; sortingElement.IsSorted = !bucketInstruction.IsSorted; } break; case Util.UPDATE_VAR_K: lineOfCode = 11; if (increment) { kPlus1 = (k + 1).ToString(); } else { //if (k > 0) // kPlus1 = (k - 1).ToString(); //else kPlus1 = "k + 1"; } break; case Util.FINAL_INSTRUCTION: lineOfCode = FinalInstructionCodeLine(); IsTaskCompleted = increment; break; } // Highlight part of code in pseudocode if (instruction.Instruction == UtilSort.DISPLAY_ELEMENT) { yield return(null); } else { yield return(HighlightPseudoCode(CollectLine(lineOfCode), useHighlightColor)); prevHighlightedLineOfCode = lineOfCode; } // Move sorting element if (instruction is BucketSortInstruction) { switch (bucketInstruction.Instruction) { case UtilSort.MOVE_TO_BUCKET_INST: if (increment) { sortingElement.transform.position = bucketManager.GetBucket(bucketInstruction.BucketID).transform.position + UtilSort.ABOVE_BUCKET_VR; } else { sortingElement.transform.position = bucketSortManager.GetCorrectHolder(bucketInstruction.HolderID).transform.position + UtilSort.ABOVE_HOLDER_VR; sortingElement.gameObject.SetActive(true); bucketManager.GetBucket(bucketIndex).RemoveSortingElement(sortingElement); sortingElement.RigidBody.constraints = RigidbodyConstraints.None; } break; case UtilSort.DISPLAY_ELEMENT: if (increment) { sortingElement.transform.position = bucketManager.GetBucket(bucketInstruction.BucketID).transform.position + UtilSort.ABOVE_BUCKET_VR; sortingElement.gameObject.SetActive(true); } else { sortingElement.gameObject.SetActive(false); } break; case UtilSort.MOVE_BACK_INST: if (increment) { sortingElement.transform.position = bucketSortManager.GetCorrectHolder(bucketInstruction.NextHolderID).transform.position + UtilSort.ABOVE_HOLDER_VR; } else { sortingElement.transform.position = bucketManager.GetBucket(bucketInstruction.BucketID).transform.position + UtilSort.ABOVE_BUCKET_VR; } break; } } // Display element reports itself when it's done if (instruction.Instruction != UtilSort.DISPLAY_ELEMENT) { sortMain.WaitForSupportToComplete--; } }
private IEnumerator RemoveConstraintsDelay(BucketSortElement element) { yield return(colorChangeDuration); element.RigidBody.constraints = RigidbodyConstraints.None; }
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); }