예제 #1
0
    private IEnumerator RunSlide()
    {
        m_states.m_movementControllState = MovementControllState.MovementDisabled;
        m_isSliding = true;


        Vector3 slideDir = transform.forward;

        m_slideTimer = 0;

        bool hasBeenOnSlope = false;

        while (m_slideTimer < m_slideTime)
        {
            m_slideTimer += Time.fixedDeltaTime;

            float progress = m_slideCurve.Evaluate(m_slideTimer / m_slideTime);

            float currentSlideSpeed = Mathf.Lerp(m_slideSpeed, m_baseMovementProperties.m_crouchMovementSpeed, progress);

            SlopeInfo slopeInfo = OnSlope();

            if (slopeInfo.m_onSlope)
            {
                hasBeenOnSlope = true;

                m_slideTimer = 0;

                float normalX = slopeInfo.m_slopeNormal.x > 0 ? slopeInfo.m_slopeNormal.x : slopeInfo.m_slopeNormal.x * -1;
                float normalZ = slopeInfo.m_slopeNormal.z > 0 ? slopeInfo.m_slopeNormal.z : slopeInfo.m_slopeNormal.z * -1;

                float slopeX = Mathf.Lerp(m_slideAngleBoostMin, m_slideAngleBoostMax, normalX / m_slopeTolerence) * Mathf.Sign(slopeInfo.m_slopeNormal.x);
                float slopeZ = Mathf.Lerp(m_slideAngleBoostMin, m_slideAngleBoostMax, normalZ / m_slopeTolerence) * Mathf.Sign(slopeInfo.m_slopeNormal.z);

                slideDir = new Vector3(slopeX, 0, slopeZ);
                Vector3 horizontalMovement = Vector3.SmoothDamp(m_velocity, slideDir, ref m_velocitySmoothing, m_slopeSlideAccelerationTime);

                m_slopeTransform.rotation = Quaternion.LookRotation(slideDir);

                Vector3 targetX   = m_slopeTransform.right * m_movementInput.x * m_slideSideShiftMaxSpeed;
                Vector3 shiftVelX = Vector3.SmoothDamp(m_slideSideShiftVelocity, targetX, ref m_slideSideShiftVelocitySmoothing, m_slideSideShiftAcceleration);

                m_velocity = new Vector3(horizontalMovement.x, m_velocity.y, horizontalMovement.z);

                m_velocity += shiftVelX;
            }
            else if (!hasBeenOnSlope)
            {
                Vector3 slideVelocity = slideDir * currentSlideSpeed;
                m_velocity = new Vector3(slideVelocity.x, m_velocity.y, slideVelocity.z);
            }

            yield return(new WaitForFixedUpdate());
        }

        m_isSliding = false;

        m_states.m_movementControllState = MovementControllState.MovementEnabled;
    }
        public double?GetPERatioFitness(SlopeInfo slopeInfo)
        {
            double?peRatioFitness = 0;
            var    peValues       = slopeInfo.NominalValues;

            if (peValues == null)
            {
                return(peRatioFitness);
            }

            if (peValues.Any(x => x.Value == null))
            {
                return(peRatioFitness);
            }
            if (peValues.Any(x => x.Value < 0))
            {
                return(peRatioFitness);
            }
            double?count = 0;

            foreach (var item in peValues)
            {
                if (item.Value <= 0.15)
                {
                    peRatioFitness = 3;
                }
                if (item.Value > 0.15 && item.Value <= 0.3)
                {
                    peRatioFitness = 1.5;
                }
                if (item.Value > 0.3 && item.Value <= 0.6)
                {
                    peRatioFitness = 0.7;
                }
                else if (item.Value >= 0.6)
                {
                    peRatioFitness = 0;
                }
                count += peRatioFitness;
            }
            peRatioFitness = count / (peValues.Count * 3);

            return(peRatioFitness);
        }
예제 #3
0
    private SlopeInfo OnSlope()
    {
        SlopeInfo slopeInfo = new SlopeInfo {
        };

        RaycastHit hit;

        Vector3 bottom = m_characterController.transform.position - new Vector3(0, m_characterController.height / 2, 0);

        if (Physics.Raycast(bottom, Vector3.down, out hit, 0.5f))
        {
            if (hit.normal != Vector3.up)
            {
                slopeInfo.m_onSlope     = true;
                slopeInfo.m_slopeAngle  = Vector3.Angle(Vector3.up, hit.normal);
                slopeInfo.m_slopeNormal = hit.normal;

                return(slopeInfo);
            }
        }

        return(slopeInfo);
    }
예제 #4
0
    public void GenerateFlowMap()
    {
        flowMap      = new Texture2D(textureSize, textureSize);
        flowMap.name = "Generated Flow Map";
        Color[] flowMapColors = new Color[textureSize * textureSize];

        var forestController = ForestController.Instance;

        if (!forestController)
        {
            forestController = GameObject.FindObjectOfType <ForestController>();
        }
        mapSize          = forestController.mapSize;
        terrainLayerMask = forestController.terrainLayerMask;

        float sampleRadius = (mapSize.x + mapSize.z) / 2f / (float)textureSize;
//		Debug.Log("Sample Radius: " + sampleRadius);

        Vector3 centerOffset = new Vector3(-mapSize.x / 2f, 0f, -mapSize.z / 2f);

        int        totalSamples = 0;
        Vector3    samplePoint;
        RaycastHit hit;

        hitGrid = new SlopeInfo[textureSize, textureSize];
        for (int x = 0; x < textureSize; x++)
        {
            for (int y = 0; y < textureSize; y++)
            {
                samplePoint = new Vector3((float)x / (float)(textureSize - 1) * mapSize.x, mapSize.y, (float)y / (float)(textureSize - 1) * mapSize.z) + centerOffset;
                for (int i = 0; i <= samplesPerPixel; i++)
                {
                    Color debugRayColor = Color.blue;
                    hitGrid[x, y] = new SlopeInfo();
                    Vector3 offset = Vector3.zero;
                    if (i > 0)
                    {
                        float theta = (float)i / (float)samplesPerPixel * Mathf.PI * 2f;
                        offset        = new Vector3(Mathf.Cos(theta), 0f, Mathf.Sin(theta)) * sampleRadius;
                        debugRayColor = Color.red;
                    }
                    if (Physics.Raycast(samplePoint + offset, Vector3.down, out hit, mapSize.y * 1.5f, terrainLayerMask))
                    {
                        if (x % 64 == 0 && y % 64 == 0)
                        {
                            Debug.DrawLine(samplePoint + offset, hit.point, debugRayColor, 10f);
                        }

                        hitGrid[x, y].AddData(hit.point, hit.normal);
                        totalSamples++;
                    }
                }
                hitGrid[x, y].GetStats(x % 64 == 0 && y % 64 == 0);
            }
        }

        Debug.Log("Total Samples: " + totalSamples);

        if (smoothTexturePass.filterRadius > 0)
        {
            Color[,] smoothableGrid = new Color[textureSize, textureSize];
            for (int x = 0; x < textureSize; x++)
            {
                for (int y = 0; y < textureSize; y++)
                {
                    smoothableGrid[x, y] = GetFlowColorAtPoint(x, y);
                }
            }

            smoothableGrid = smoothTexturePass.SmoothColorGrid(smoothableGrid);

            for (int x = 0; x < textureSize; x++)
            {
                for (int y = 0; y < textureSize; y++)
                {
                    int pixelIndex = y * textureSize + x;
                    flowMapColors[pixelIndex] = smoothableGrid[x, y];
                }
            }
        }
        else
        {
            for (int x = 0; x < textureSize; x++)
            {
                for (int y = 0; y < textureSize; y++)
                {
                    int pixelIndex = y * textureSize + x;
                    flowMapColors[pixelIndex] = GetFlowColorAtPoint(x, y);
                }
            }
        }
        flowMap.SetPixels(flowMapColors);
        flowMap.Apply();
    }
예제 #5
0
    private void SlopePhysics()
    {
        SlopeInfo slopeInfo = OnSlope();

        if (slopeInfo.m_onSlope == true)
        {
            if (m_velocity.y > 0)
            {
                return;
            }

            if (m_hasJumped)
            {
                return;
            }

            RaycastHit hit;

            Vector3 bottom = m_characterController.transform.position - new Vector3(0, m_characterController.height / 2, 0);

            if (Physics.Raycast(bottom, Vector3.down, out hit))
            {
                if (slopeInfo.m_slopeAngle > m_characterController.slopeLimit)
                {
                    m_velocity.x += (1f - hit.normal.y) * hit.normal.x * (m_baseMovementProperties.m_slopeFriction);
                    m_velocity.z += (1f - hit.normal.y) * hit.normal.z * (m_baseMovementProperties.m_slopeFriction);
                }

                #region not suing

                /*
                 * if (m_isSliding)
                 * {
                 *      m_slideTimer = 0;
                 *
                 *      float anglePercent = slopeAngle / m_characterController.slopeLimit;
                 *
                 *      float normalX = hit.normal.x > 0 ? hit.normal.x : hit.normal.x * -1;
                 *      float normalZ = hit.normal.z > 0 ? hit.normal.z : hit.normal.z * -1;
                 *
                 *      float slopeX = Mathf.Lerp(m_slideAngleBoostMin, m_slideAngleBoostMax, normalX / m_slopeTolerence) * Mathf.Sign(hit.normal.x);
                 *      float slopeZ = Mathf.Lerp(m_slideAngleBoostMin, m_slideAngleBoostMax, normalZ / m_slopeTolerence) * Mathf.Sign(hit.normal.z);
                 *
                 *      Vector3 targetMovement = new Vector3(slopeX, 0, slopeZ);
                 *      Vector3 horizontalMovement = Vector3.SmoothDamp(m_velocity, targetMovement, ref m_velocitySmoothing, m_slopeSlideAccelerationTime);
                 *
                 *      m_slopeTransform.rotation = Quaternion.LookRotation(targetMovement);
                 *
                 *      Vector3 targetX = m_slopeTransform.right * m_movementInput.x * m_slideSideShiftMaxSpeed;
                 *      Vector3 shiftVelX = Vector3.SmoothDamp(m_slideSideShiftVelocity, targetX, ref m_slideSideShiftVelocitySmoothing, m_slideSideShiftAcceleration);
                 *
                 *      m_velocity = new Vector3(horizontalMovement.x, m_velocity.y, horizontalMovement.z);
                 *
                 *      m_velocity += shiftVelX;
                 * }
                 */
                #endregion

                m_characterController.Move(new Vector3(0, -(hit.distance), 0));
            }
        }
    }
        public double?GetRoicFitness(SlopeInfo slopeInfo)
        {
            if (slopeInfo.NominalValues == null)
            {
                return(0);
            }
            if (slopeInfo.GrowthTrendline == null)
            {
                return(null);
            }
            var slope = slopeInfo.GrowthTrendline.Slope;

            if (slope == null)
            {
                return(null);
            }
            var    deviation              = slopeInfo.GrowthDeviation;
            double?fitnessValueDeviation  = 0;
            double?fitnessSlopeValue      = 0;
            double?fitnessSlopeThreeYears = 0;

            #region All values bigger than 10%
            double?fitnessNominalValue = 0;
            double?count  = 0;
            var    values = slopeInfo.NominalValues;
            foreach (var item in values)
            {
                if (item.Value >= 0.1)
                {
                    fitnessNominalValue = 3;
                }

                if (item.Value >= 0 && item.Value < 0.1)
                {
                    fitnessNominalValue = 1.5;
                }

                else if (item.Value < 0)
                {
                    fitnessNominalValue = 0;
                }

                count += fitnessNominalValue;
            }

            fitnessNominalValue = count / values.Count;
            #endregion

            #region Small deviation
            if (deviation <= 15)
            {
                fitnessValueDeviation = 3;
            }
            if (deviation > 15 && deviation < 30)
            {
                fitnessValueDeviation = 1.5;
            }
            else if (deviation >= 30)
            {
                fitnessValueDeviation = 0;
            }
            #endregion

            #region Slope
            if (slope >= 0.1)
            {
                fitnessSlopeValue = 3;
            }
            if (slope >= 0 && slope < 0.1)
            {
                fitnessSlopeValue = 1.5;
            }
            else if (slope < 0)
            {
                fitnessSlopeValue = 0;
            }
            #endregion

            #region Slope last 3 years
            var lastThreeYearsGrowthSlope = slopeInfo.LastThreeYearsTrendLine.Slope;
            if (lastThreeYearsGrowthSlope >= 0.1)
            {
                fitnessSlopeThreeYears = 3;
            }
            if (lastThreeYearsGrowthSlope >= 0 && lastThreeYearsGrowthSlope < 0.1)
            {
                fitnessSlopeThreeYears = 1.5;
            }
            else if (lastThreeYearsGrowthSlope < 0)
            {
                fitnessSlopeThreeYears = 0;
            }
            #endregion

            var fitness = (fitnessSlopeThreeYears + fitnessSlopeValue + fitnessValueDeviation + fitnessNominalValue) / 12;
            return(fitness);
        }
        public double?GetGrowthFitness(SlopeInfo slopeInfo)
        {
            if (slopeInfo.Growth == null)
            {
                return(0);
            }
            var    slope                  = slopeInfo.GrowthTrendline.Slope;
            double?fitnessSlopeValue      = 0;
            double?fitnessSlopeThreeYears = 0;

            #region All values bigger than 10%
            double?fitnessBiggerThanTen = 0;
            double?count        = 0;
            var    growthValues = slopeInfo.Growth;
            foreach (var item in growthValues)
            {
                if (item.Value >= 0.1)
                {
                    fitnessBiggerThanTen = 3;
                }

                if (item.Value >= 0 && item.Value < 0.1)
                {
                    fitnessBiggerThanTen = 1.5;
                }

                else if (item.Value < 0)
                {
                    fitnessBiggerThanTen = 0;
                }

                count += fitnessBiggerThanTen;
            }

            fitnessBiggerThanTen = count / growthValues.Count;
            #endregion

            #region Slope
            if (slope >= 0.1)
            {
                fitnessSlopeValue = 3;
            }
            if (slope >= 0 && slope < 0.1)
            {
                fitnessSlopeValue = 1.5;
            }
            else if (slope < 0)
            {
                fitnessSlopeValue = 0;
            }
            #endregion

            #region Slope last 3 years
            var lastThreeYearsGrowthSlope = slopeInfo.LastThreeYearsTrendLine.Slope;
            if (lastThreeYearsGrowthSlope >= 0.1)
            {
                fitnessSlopeThreeYears = 3;
            }
            if (lastThreeYearsGrowthSlope >= 0 && lastThreeYearsGrowthSlope < 0.1)
            {
                fitnessSlopeThreeYears = 1.5;
            }
            else if (lastThreeYearsGrowthSlope < 0)
            {
                fitnessSlopeThreeYears = 0;
            }
            #endregion

            var fitness = (fitnessSlopeThreeYears + fitnessSlopeValue + fitnessBiggerThanTen) / 9;
            return(fitness);
        }
	public void GenerateFlowMap ()
	{
		flowMap = new Texture2D (textureSize, textureSize);
		flowMap.name = "Generated Flow Map";
		Color[] flowMapColors = new Color[textureSize * textureSize];

		var forestController = ForestController.Instance;
		if (!forestController)
		{
			forestController = GameObject.FindObjectOfType<ForestController>();
		}
		mapSize = forestController.mapSize;
		terrainLayerMask = forestController.terrainLayerMask;

		float sampleRadius = (mapSize.x + mapSize.z) / 2f / (float)textureSize;
//		Debug.Log("Sample Radius: " + sampleRadius);

		Vector3 centerOffset = new Vector3 (-mapSize.x / 2f, 0f, -mapSize.z / 2f);

		int totalSamples = 0;
		Vector3 samplePoint;
		RaycastHit hit;
		hitGrid = new SlopeInfo[textureSize,textureSize];
		for (int x = 0; x < textureSize; x++)
		{
			for (int y = 0; y < textureSize; y++)
			{
				samplePoint = new Vector3 ((float)x / (float)(textureSize - 1) * mapSize.x, mapSize.y, (float)y / (float)(textureSize - 1) * mapSize.z) + centerOffset;
				for (int i = 0; i <= samplesPerPixel; i++)
				{
					Color debugRayColor = Color.blue;
					hitGrid[x, y] = new SlopeInfo ();
					Vector3 offset = Vector3.zero;
					if (i > 0)
					{
						float theta = (float)i / (float)samplesPerPixel * Mathf.PI * 2f;
						offset = new Vector3 (Mathf.Cos(theta), 0f, Mathf.Sin(theta)) * sampleRadius;
						debugRayColor = Color.red;
					}
					if (Physics.Raycast(samplePoint + offset, Vector3.down, out hit, mapSize.y * 1.5f, terrainLayerMask))
					{
						if (x % 64 == 0 && y % 64 == 0)
						{
							Debug.DrawLine(samplePoint + offset, hit.point, debugRayColor, 10f);
						}

						hitGrid[x, y].AddData(hit.point, hit.normal);
						totalSamples++;
					}
				}
				hitGrid[x, y].GetStats(x % 64 == 0 && y % 64 == 0);
			}
		}

		Debug.Log("Total Samples: " + totalSamples);

		if (smoothTexturePass.filterRadius > 0)
		{
			Color[,] smoothableGrid = new Color[textureSize, textureSize];
			for (int x = 0; x < textureSize; x++)
			{
				for (int y = 0; y < textureSize; y++)
				{
					smoothableGrid[x, y] = GetFlowColorAtPoint(x, y);
				}
			}

			smoothableGrid = smoothTexturePass.SmoothColorGrid(smoothableGrid);

			for (int x = 0; x < textureSize; x++)
			{
				for (int y = 0; y < textureSize; y++)
				{
					int pixelIndex = y * textureSize + x;
					flowMapColors[pixelIndex] = smoothableGrid[x, y];
				}
			}
		}
		else
		{
			for (int x = 0; x < textureSize; x++)
			{
				for (int y = 0; y < textureSize; y++)
				{
					int pixelIndex = y * textureSize + x;
					flowMapColors[pixelIndex] = GetFlowColorAtPoint(x, y);
				}
			}
		}
		flowMap.SetPixels(flowMapColors);
		flowMap.Apply();
	}