public override BallRound GenerateDataForRound(float targetRingRadius) { float initialFastBallRadius = GenerateInitialBallRadius(targetRingRadius); float initialPlayerBallRadius = initialFastBallRadius * RamGenerator.GenerateARamNum(MIN_PLAYER_BALL_RADIUS_AS_PERCENTAGE_OF_FAST_BALL_RADIUS, MAX_PLAYER_BALL_RADIUS_AS_PERCENTAGE_OF_FAST_BALL_RADIUS); float initialSlowBallRadius = initialPlayerBallRadius * RamGenerator.GenerateARamNum(MIN_SLOW_BALL_RADIUS_AS_PERCENTAGE_OF_FAST_BALL_RADIUS, MAX_SLOW_BALL_RADIUS_AS_PERCENTAGE_OF_FAST_BALL_RADIUS); float fastBallActualTimeToContact = GenerateActualTimeToContact(); float playerBallActualTimeToContact = fastBallActualTimeToContact + RamGenerator.GenerateARamNum(MIN_ADDITIONAL_SECONDS_IN_TIME_TO_CONTACT, MAX_ADDITIONAL_SECONDS_IN_TIME_TO_CONTACT); float slowBallActualTimeToContact = playerBallActualTimeToContact + RamGenerator.GenerateARamNum(MIN_ADDITIONAL_SECONDS_IN_TIME_TO_CONTACT, MAX_ADDITIONAL_SECONDS_IN_TIME_TO_CONTACT); BallRound ballRound = new BallRound { InitialSlowBallRadius = initialSlowBallRadius, InitialPlayerBallRadius = initialPlayerBallRadius, InitialFastBallRadius = initialFastBallRadius, SlowBallActualTimeToContact = slowBallActualTimeToContact, PlayerBallActualTimeToContact = playerBallActualTimeToContact, FastBallActualTimeToContact = fastBallActualTimeToContact }; // The ball disappearance time is calculated by taking the // fastest time-to-contact ball time, and then // subtracting a random value from this. ballRound.TimeBeforeDisappearence = Math.Min(ballRound.SlowBallActualTimeToContact, ballRound.FastBallActualTimeToContact) - RamGenerator.GenerateARamNum(MIN_SECONDS_BEFORE_BALL_DISAPPEARANCE, MAX_SECONDS_BEFORE_BALL_DISAPPEARANCE); return(ballRound); }
/// <summary> /// Generates an initial ball radius from the target ring radius. /// </summary> /// <param name="targetRingRadius">The radius of the target ring.</param> /// <returns>The initial ball radius.</returns> public float GenerateInitialBallRadius(float targetRingRadius) { // The initial ball radius is currently between 1% and 30% of that of // the target ring's. return(targetRingRadius * RamGenerator.GenerateARamNum(MIN_BALL_RADIUS_AS_PERCENTAGE_OF_TARGET_RING_RADIUS, MAX_BALL_RADIUS_AS_PERCENTAGE_OF_TARGET_RING_RADIUS)); }
/// <summary> /// Calculates the number of thieves and people images that will appear in the round. The imageOrder /// list will be updated accordingly. /// </summary> private void FillImageList() { // Randomly determine whether thief or person images should appear // And make sure at least one of thief and person appears thiefAppearInRound = RamGenerator.GenerateARandomBool(); if (thiefAppearInRound) { // personAppearInRound could be either true or false personAppearInRound = RamGenerator.GenerateARandomBool(); // Add thief image type to the list of images that will appear imageOrder.Add(Images.THIEF); } else { // personAppearInRound should be true personAppearInRound = true; } if (personAppearInRound) { // Determine the number of people that will appear this round numberOfPeople = RamGenerator.GenerateARamInt(MIN_PEOPLE, MAX_PEOPLE); // Add one person image type to the list for each person that will appear this round for (int count = 0; count < numberOfPeople; count += 1) { imageOrder.Add(Images.PERSON); } } // For all the remaining square game objects, they will be left blank while (imageOrder.Count < 9) { imageOrder.Add(Images.BLANK); } }
public void WHEN_PickNRandomElems_THEN_ValuesGeneratedEqually() { testIntList = new List <int>() { 0, 1, 2, 3, 4 }; resultIntList = new List <int>() { 0, 0, 0, 0, 0 }; // Run the random boolean generator 1000 times for (int i = 0; i < 1000; i++) { List <int> ramGeneratorList = RamGenerator.PickNRandomElems(testIntList, 2); // Record the values generated in the list resultIntList[ramGeneratorList[0]] += 1; resultIntList[ramGeneratorList[1]] += 1; } // Ensure that all numbers were generated at least 15% of the time out of 1000 calls to the generator for (int index = 0; index < 4; index++) { Assert.IsTrue(resultIntList[index] > 150, "GenerateARamInt: Out of 1000 calls, " + index + " was generated " + resultIntList[index] + " times."); } }
/// <summary> /// PrepareDestinationBalloons is called when the player is going to click on the balloon /// that would appears on a random position. /// It will set up the game state for the current round. /// </summary> private void PrepareDestinationBalloon() { // Save the previous balloon info before it's been updated previousBalloonPos = balloon.transform.localPosition; previousBalloonSize = balloon.image.rectTransform.sizeDelta; // Generate random x and y values for the random balloon position (local position) // Make sure the random position is different from center point (0,0) float localX = RamGenerator.GenerateARamNum(MINX, MAXX); float localY = RamGenerator.GenerateARamNum(MINY, MAXY); while (localX == 0 && localY == 0) { localX = RamGenerator.GenerateARamNum(MINX, MAXX); localY = RamGenerator.GenerateARamNum(MINY, MAXY); } // Display balloon at the random position (local position) balloon.transform.localPosition = new Vector3(localX, localY, 0); // Reset destinationClickTime when the balloon appears in ramdom position destinationClickTime = 0; // Reset the click time timer for the time between clicks initClickTime = 0; // Toggle the isBalloonInCenter value because The next balloon should appear at the center isBalloonInCenter = true; // Set the local state variables: balloonSize = balloon.image.rectTransform.sizeDelta.x; destinationPoint = new Position2D(localX, localY); }
public void WHEN_Pick0RandomElemsFromEmptyList_THEN_EmptyListReturned() { // Predetermined test list testIntList = new List <int>() { }; // Random items picked out by the PickNRandomElems function List <int> ramGeneratorList = RamGenerator.PickNRandomElems(testIntList, 0); Assert.AreEqual(0, ramGeneratorList.Count()); }
public void WHEN_Pick3RandomElemsFromListWith2Elems_THEN_ListWith2ElemsReturned() { // Predetermined test list testIntList = new List <int>() { 1, 2 }; // Random items picked out by the PickNRandomElems function List <int> ramGeneratorList = RamGenerator.PickNRandomElems(testIntList, 3); Assert.AreEqual(2, ramGeneratorList.Count()); }
public void WHEN_GenerateARandomBool_THEN_TrueAndFalseAppearEqually() { int trueCountTotal = 0; // Run the random boolean generator 1000 times for (int i = 0; i < 1000; i++) { testBoolValue = RamGenerator.GenerateARandomBool(); if (testBoolValue) { trueCountTotal += 1; } } Assert.IsTrue(trueCountTotal < 600, "GenerateARandomBool: Out of 1000 calls, number of times true appeared " + trueCountTotal); }
public IEnumerator WHEN_ClickCatchTheThief_THEN_CatchTheThiefImageCheck() { Grid = GameObject.Find("SquareGridArea"); yield return(null); // Boolean to determine if the thief appears in this round bool thiefAppearInRound; // Boolean to determine if the person appears in this round bool personAppearInRound; List <Images> imageOrder = new List <Images>(); int numberOfPeople; // Randomly determine whether thief or person images should appear // And make sure at least one of thief and person appears thiefAppearInRound = RamGenerator.GenerateARandomBool(); if (thiefAppearInRound) { // personAppearInRound could be either true or false personAppearInRound = RamGenerator.GenerateARandomBool(); // Add thief image type to the list of images that will appear imageOrder.Add(Images.THIEF); } else { // personAppearInRound should be true personAppearInRound = true; } if (personAppearInRound) { // Determine the number of people that will appear this round numberOfPeople = RamGenerator.GenerateARamInt(1, 3); // Add one person image type to the list for each person that will appear this round for (int count = 0; count < numberOfPeople; count += 1) { imageOrder.Add(Images.PERSON); } } // For all the remaining square game objects, they will be left blank while (imageOrder.Count < 9) { imageOrder.Add(Images.BLANK); } Assert.IsTrue(imageOrder.Count == 9, " message: no Error TestFCS1"); }
/// <summary> /// To start the Image hit game /// The game should be started at once after calling this method /// </summary> public void StartGame() { UnityEngine.Random.InitState(DateTime.Now.Second); //To get a random theme used for this round of game currentThemeId = GetRandTheme(""); if (currentThemeId != -1) { themes[currentThemeId].specifiedTheme = themes[currentThemeId].specifiedTheme.Trim(); specifiedTheme = themes[currentThemeId].specifiedTheme; // To get images of current themes of the number MIN_NumOfImagesOfTheme to MAX_NumOfImagesOfTheme int randThemeCount = RamGenerator.GenerateARamInt(MIN_NumOfImagesOfTheme, MAX_NumOfImagesOfTheme); currentRoundTestImages = themes[currentThemeId].getrandimages(randThemeCount); randThemeCount = 10 - randThemeCount; List <TImage> tmp = GetRandImage(randThemeCount); currentRoundTestImages.AddRange(tmp); } images = new List <string>(); foreach (var item in currentRoundTestImages) { images.Add(item.sprite.name); } // Before the game start, the imagelist must have 10 images // All variables should be initialized serialNumber = 0; if (currentRoundTestImages.Count == 10) { currentRoundTestData.Clear(); initialTestImages = currentRoundTestImages; gameInfo.text = ""; prepareTime = 1; imageDisplayedTime = 0; canShowNextImage = true; gameState = 0; RandSortImages(initialTestImages); imageDisplay.gameObject.SetActive(true); mRoundStart(0); } }
public void WHEN_PickNRandomElems_THEN_NoDuplicatedElements() { // Predetermined test list testIntList = new List <int>() { 1, 2, 3, 4, 5 }; // Random items picked out by the PickNRandomElems function List <int> ramGeneratorList = RamGenerator.PickNRandomElems(testIntList, 3); // Check for duplicates IEnumerable <int> duplicatesList = ramGeneratorList.GroupBy(x => x) .Where(g => g.Count() > 1) .Select(x => x.Key); Assert.AreEqual(0, duplicatesList.Count()); }
public void WHEN_GenerateARamNum_THEN_ValuesGeneratedAreWithinRange() { int actualOutOfRangeCount = 0; int expectedOutOfRangeCount = 0; // Run the random boolean generator 1000 times for (int i = 0; i < 1000; i++) { // Generate a random number between 0 and 0 testFloatValue = RamGenerator.GenerateARamNum(1.0f, 100.0f); // Keep track of the occurrences of the number one if (testFloatValue < 1.0 || testFloatValue > 100.0) { actualOutOfRangeCount += 1; } } Assert.IsTrue(actualOutOfRangeCount == expectedOutOfRangeCount, "Invalid number generated from GenerateARamNum"); }
public void WHEN_GenerateARamNumLowerEqualUpperBound_THEN_Only1NumGenerated() { int actualOnesCount = 0; int expectedOnesCount = 1000; // Run the random boolean generator 1000 times for (int i = 0; i < 1000; i++) { // Generate a random number between 0 and 0 testFloatValue = RamGenerator.GenerateARamNum(1.0f, 1.0f); // Keep track of the occurrences of the number one if (testFloatValue == 1.0) { actualOnesCount += 1; } } Assert.IsTrue(actualOnesCount == expectedOnesCount, "Invalid number generated from GenerateARamNum"); }
/// <summary> /// Function for displaying the highlight sequence /// </summary> private IEnumerator HighlightSequenceStage() { roundNumber += 1; // Initialize round gameplay data variables round = new SquaresRound(); round.HighlightedSquares = new List <IndexAndPosition>(); round.RecalledSquares = new List <IndexAndPosition>(); round.SquareHighlightInterval = squareHighlightInterval; // float value round.SquareHighlightDuration = squareHighlightDuration; // float value // Randomly select a new square highlight sequence for the new round, // by using the existing list of square game objects squaresToHighlight = RamGenerator.PickNRandomElems(displayedSquares, numberOfHighlightedSquares); // Display the square highlight sequence yield return(StartCoroutine(HighlightSquareSequence(squaresToHighlight, squareHighlightInterval))); // Clear the list of squares recalled by the player recalledSquares = new List <IndexAndPosition>(); }
public void WHEN_GenerateARamInt_THEN_ValuesGeneratedEqually() { resultIntList = new List <int>() { 0, 0, 0, 0, 0 }; // Run the random boolean generator 1000 times for (int i = 0; i < 1000; i++) { // Generate a random number between 0 and 10 testIntValue = RamGenerator.GenerateARamInt(0, 4); // Keep track of the occurrences of each number resultIntList[testIntValue] += 1; } // Ensure that all numbers were generated at least 15% of the time out of 1000 calls to the generator for (int index = 0; index < 4; index++) { Assert.IsTrue(resultIntList[index] > 150, "GenerateARamInt: Out of 1000 calls, " + index + " was generated " + resultIntList[index] + " times."); } }
/// <summary> /// Reset or Calculate the level variables for the next round. /// </summary> private IEnumerator PrepareRound() { // Initialize round gameplay data variables roundNumber += 1; identifiedKeyPressTime = 0; isRoundOver = false; isIdentifiedKeyPressed = false; // In each round there is a new image order imageOrder = new List <Images>(); // Decrease round duration as the number of rounds increase, until it reaches the minimum // round duration time if (roundDuration > MIN_ROUND_TIME) { roundDuration -= ROUND_TIME_DECREMENT; } // Calculate whether thief or person images will appear in this round FillImageList(); // Set the round variables in the game storage round = new CatchTheThiefRound(); round.UnidentifiedKeysPressed = new List <TimeAndKey>(); round.ThiefAppearInRound = thiefAppearInRound; round.PersonAppearInRound = personAppearInRound; // Randomize the list of images that will appear in this round imageOrder = RamGenerator.PickNRandomElems(imageOrder, numberOfSquaresInGrid); // If the thief has been randomized to appear on the same square as in the last round while (imageOrder[indexThiefAppearedLastRound] == Images.THIEF) { // Randomize the list of images again imageOrder = RamGenerator.PickNRandomElems(imageOrder, numberOfSquaresInGrid); } yield return(null); }
public void WHEN_GenerateARamNum_THEN_ValuesGeneratedEqually() { resultIntList = new List <int>() { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // Run the random boolean generator 1000 times for (int i = 0; i < 1000; i++) { // Generate a random number between 0 and 10 testFloatValue = RamGenerator.GenerateARamNum(1, 11); // Keep track of the occurrences of each number if (testFloatValue < 2) { resultIntList[0] += 1; } else if (testFloatValue < 3) { resultIntList[1] += 1; } else if (testFloatValue < 4) { resultIntList[2] += 1; } else if (testFloatValue < 5) { resultIntList[3] += 1; } else if (testFloatValue < 6) { resultIntList[4] += 1; } else if (testFloatValue < 7) { resultIntList[5] += 1; } else if (testFloatValue < 8) { resultIntList[6] += 1; } else if (testFloatValue < 9) { resultIntList[7] += 1; } else if (testFloatValue < 10) { resultIntList[8] += 1; } else if (testFloatValue <= 11) { resultIntList[9] += 1; } } // Ensure that all numbers were generated at least 80% of the time out of 1000 calls to the generator for (int index = 0; index < 9; index++) { Assert.IsTrue(resultIntList[index] > 70, "GenerateARamInt: Out of 1000 calls, " + index + " was generated " + resultIntList[index] + " times."); } }
/// <summary> /// Generates an actual time to contact. /// </summary> /// <returns>The generated actual time to contact.</returns> public float GenerateActualTimeToContact() { return(RamGenerator.GenerateARamNum(MIN_TIME_TO_CONTACT_IN_SECONDS, MAX_TIME_TO_CONTACT_IN_SECONDS)); }