public void HelixController_IsInstanceOf_HelixController_ReceivingHelixServiceOnCreation_Test()
        {
            // Arrange
            var controller = new HelixController(_helixService.Object);

            // Act | Assert
            IsInstanceOf <HelixController>(controller);
        }
        public void HelixController_GetEventById_EventByIdFromService_EventCouldNotBeFound_ReturnsNotFoundResult_Test()
        {
            // Arrange
            var controller = new HelixController(_helixService.Object);

            // Act
            var actionResult = controller.GetEventById(100);

            actionResult.Wait();

            var result = actionResult.Result.Result;

            // Assert
            IsNotNull(result);
            Assert.IsInstanceOf(typeof(NotFoundResult), result);
        }
        public void HelixController_GetProducts_ListIsEmpty_ReturnsOkResultWithEventListAsContent_Test()
        {
            // Arrange
            _helixService.Setup(m => m.GetAllEvents()).ReturnsAsync(new List <HelixEvent>().ToList());

            var controller = new HelixController(_helixService.Object);

            // Act
            var actionResultTask = controller.GetProducts();

            actionResultTask.Wait();
            var result = actionResultTask.Result.Result as OkObjectResult;

            // Assert
            IsNotNull(result);
        }
예제 #4
0
    private void CreateLevel(LevelData levelData)
    {
        //Random helix number
        int helixNumber = Random.Range(levelData.MinHelixNumber, levelData.MaxHelixNumber);

        //Assign values
        deadPieceMaterial.color   = levelData.DeadPieceColor;
        normalPieceMaterial.color = levelData.NormalPieceColor;
        brokenPieceMaterial.color = levelData.BrokenPieceColor;
        PlayerController.Instance.SetBallColor(levelData.BallColor);
        pillarMaterial.color = levelData.PillarColor;
        TimeToPassLevel      = Random.Range(levelData.MinTimeToPassLevel, levelData.MaxTimeToPassLevel);

        //Create the first helix
        HelixController firstHelixControl = Instantiate(helixPrefab, firstHelixPosition, Quaternion.identity).GetComponent <HelixController>();

        firstHelixControl.HandleHelix(Random.Range(levelData.MinDisablePiecesNumber, levelData.MaxDeadPiecesNumber), 0, levelData.NormalPieceColor, levelData.DeadPieceColor);
        firstHelixControl.transform.SetParent(rotaterTrans);

        //Calculate the height of all helixs, space and distance between the pillar and the first helix
        float oneHelixHeight   = helixPrefab.transform.GetChild(0).GetComponent <Renderer>().bounds.size.y;
        float totalHelixHeight = oneHelixHeight * helixNumber - (helixNumber - 1) * oneHelixHeight + helixSpace;
        float totalSpace       = helixSpace * (helixNumber - 1);
        float distance         = Vector3.Distance(firstHelixPosition + Vector3.up * oneHelixHeight, pillar.transform.position);

        //Calculate and set the pillar's height
        float pillarHeight = totalSpace + totalHelixHeight + Mathf.Round(distance);

        pillar.transform.localScale = new Vector3(1, pillarHeight, 1);

        //Create helixs
        Vector3 nextHelixPos = firstHelixPosition + Vector3.down * helixSpace;

        for (int i = 0; i < helixNumber - 1; i++)
        {
            HelixController helixControl = Instantiate(helixPrefab, nextHelixPos, Quaternion.identity).GetComponent <HelixController>();
            helixControl.HandleHelix(Random.Range(levelData.MinDisablePiecesNumber, levelData.MaxDisablePiecesNumber),
                                     Random.Range(levelData.MinDeadPiecesNumber, levelData.MaxDeadPiecesNumber),
                                     levelData.NormalPieceColor, levelData.DeadPieceColor);
            helixControl.transform.SetParent(rotaterTrans);
            nextHelixPos = helixControl.transform.position + Vector3.down * helixSpace;
        }

        //Move bottomHelix object to the bottom
        bottomPillar.transform.position = nextHelixPos + Vector3.up * oneHelixHeight;;
    }
        public void HelixController_PutProductsToEvent_MissingEventInfo_ReturnsBadRequestResult_Test()
        {
            // Arrange
            var helixEvent = CreateInValidDefaultHelixEventViewModelObject();

            var controller = new HelixController(_helixService.Object);

            controller.ModelState.AddModelError("Id", "Required");

            // Act
            var actionResult = controller.PutProductsToEvent(helixEvent);

            actionResult.Wait();

            // Assert
            IsNotNull(actionResult);
            Assert.IsInstanceOf(typeof(BadRequestResult), actionResult.Result);
        }
        public void HelixController_PutProductsToEvent_HelixEventUpdated_ReturnsOkResultWithContent_Test()
        {
            // Arrange
            var helixEvent = CreateValidDefaultHelixEventViewModelObject();

            _helixService.Setup(m => m.Update(It.IsAny <HelixEventViewModel>())).ReturnsAsync(true);

            var controller = new HelixController(_helixService.Object);

            // Act
            var actionResult = controller.PutProductsToEvent(helixEvent);

            actionResult.Wait();

            // Assert
            IsNotNull(actionResult);
            Assert.IsInstanceOf(typeof(OkResult), actionResult.Result);
        }
        public void HelixController_GetProducts_ReturnsOkResultWithEventListAsContent_Test()
        {
            // Arrange
            List <HelixEvent> eventList = CreateEventList();

            _helixService.Setup(m => m.GetAllEvents()).ReturnsAsync(eventList.ToList());

            var controller = new HelixController(_helixService.Object);

            // Act
            var actionResultTask = controller.GetProducts();

            actionResultTask.Wait();
            var result = actionResultTask.Result.Result as OkObjectResult;

            // Assertdotne
            IsNotNull(result);
            IsNotNull(result.Value);
            ICollection <HelixEvent> list = (ICollection <HelixEvent>)result.Value;

            AreEqual(eventList.Count, list.Count);
        }
        public void HelixController_GetEventById_EventByIdFromService_ReturnsOkWithEventEntityAsContent_Test()
        {
            // Arrange
            var helixEvent = CreateDefaultHelixEventObject();

            _helixService.Setup(m => m.GetEventById(It.IsAny <long>())).ReturnsAsync(helixEvent);


            var controller = new HelixController(_helixService.Object);

            // Act
            var actionResultTask = controller.GetEventById(helixEventId);

            actionResultTask.Wait();
            var result = actionResultTask.Result.Result as OkObjectResult;

            // Assert
            IsNotNull(result);
            var responseItem = (HelixEvent)result.Value;

            IsNotNull(responseItem);
            AreEqual(helixEventId, responseItem.HelixEventId);
        }
예제 #9
0
    /// <summary>
    /// Creates the level using the data from levelData
    /// </summary>
    /// <param name="levelData"></param>
    private void CreateLevel(GameLevelData levelData)
    {
        #region Documentation
        //Calculate dificulty % , with 0 as minimun and 1 maximum
        //For example if level is between 6 and 10, difficutly would be 0,0.25,0.50,0.5 and 1 respectively, making the difficulty increasing for every level.
        //This value will be used for giving a integer value between 2 vars affecting difficulty.
        //In short , this function calculates an increasing difficulty for a level.
        #endregion

        float difficulty = (1.0f / (levelData.MaxLevel - levelData.MinLevel)) * (CurrentLevel - levelData.MinLevel);

        //Define how many helixes would this level have, according the difficult settings.
        //More advanced levels will have more helixes.
        //Example MinHelixNumber=25 and MaxHelixNumber=35 -> the result would be something like 25,25,30,33 and 35

        int helixNumber = Mathf.RoundToInt(Mathf.Lerp(levelData.MinHelixNumber, levelData.MaxHelixNumber, difficulty));  //Random.Range(levelData.MinHelixNumber, levelData.MaxHelixNumber);

        //Assign colors to different pieces
        deadPieceMaterial.color   = levelData.DeadPieceColor;
        normalPieceMaterial.color = levelData.NormalPieceColor;
        brokenPieceMaterial.color = levelData.BrokenPieceColor;
        PlayerController.Instance.SetBallColor(levelData.BallColor);
        pillarMaterial.color = levelData.PillarColor;

        //Calculate time needed for this leve, increasing according the level.
        TimeToPassLevel = Mathf.RoundToInt(Mathf.Lerp(levelData.MinTimeToPassLevel, levelData.MaxTimeToPassLevel, difficulty)); //.Range(levelData.MinTimeToPassLevel, levelData.MaxTimeToPassLevel);

        //Create the first helix . Every disc is a 12-pieces helix
        HelixController firstHelixControl = Instantiate(helixPrefab, GPC.firstHelixPosition, Quaternion.identity).GetComponent <HelixController>();

        //Pass how many pieces will be disabled , how many would be a kill piece and the colors for each one
        firstHelixControl.HandleHelix(Random.Range(levelData.MinDisablePiecesNumber, levelData.MaxDeadPiecesNumber), 0, levelData.NormalPieceColor, levelData.DeadPieceColor);
        firstHelixControl.transform.SetParent(rotaterTrans);

        //Calculate the height of all helixs, space and distance between the pillar and the first helix
        float oneHelixHeight   = helixPrefab.transform.GetChild(0).GetComponent <Renderer>().bounds.size.y;
        float totalHelixHeight = oneHelixHeight * helixNumber - (helixNumber - 1) * oneHelixHeight + GPC.helixSpace;
        float totalSpace       = GPC.helixSpace * (helixNumber - 1);
        float distance         = Vector3.Distance(GPC.firstHelixPosition + Vector3.up * oneHelixHeight, pillar.transform.position);

        //Calculate and set the pillar's height
        float pillarHeight = totalSpace + totalHelixHeight + Mathf.Round(distance);
        pillar.transform.localScale = new Vector3(1, pillarHeight, 1);

        //Create helixes
        Vector3 nextHelixPos = GPC.firstHelixPosition + Vector3.down * GPC.helixSpace;
        for (int i = 0; i < helixNumber - 1; i++)
        {
            HelixController helixControl = Instantiate(helixPrefab, nextHelixPos, Quaternion.identity).GetComponent <HelixController>();

            if (levelData.MovPieces)
            {
                helixControl.SetMovPiece(levelData.RandomValues, levelData.OneDirection, levelData.LerpMov, levelData.angleMov, levelData.velMov, levelData.velLerp, levelData.dstMeta, levelData.percentMov);
            }

            helixControl.HandleHelix(Random.Range(levelData.MinDisablePiecesNumber, levelData.MaxDisablePiecesNumber),
                                     Mathf.RoundToInt(Mathf.Lerp(levelData.MinDeadPiecesNumber, levelData.MaxDeadPiecesNumber, difficulty)),
                                     levelData.NormalPieceColor, levelData.DeadPieceColor);
            helixControl.transform.SetParent(rotaterTrans);
            nextHelixPos = helixControl.transform.position + Vector3.down * GPC.helixSpace;
        }

        //Move bottomHelix object to the bottom
        bottomPillar.transform.position = nextHelixPos + Vector3.up * oneHelixHeight;;
    }