Example #1
0
    protected internal override Steering getSteering(PersonajeBase personaje)
    {
        _finishedLinear = _finishedAngular = false;
        Vector3 newOffset = SimulationManager.DirectionToVector(_target.orientacion + SimulationManager.VectorToDirection(offsetPosition)) * offsetPosition.magnitude;
        Vector2 destino   = SimManagerFinal.positionToGrid(_target.posicion + newOffset);

        if (destino != lastDestiny)
        {
            Vector2        origen    = SimManagerFinal.positionToGrid(personaje.posicion);
            List <Vector3> recorrido = SimManagerFinal.aStarPathV3(origen, destino, personaje.tipo, personaje is PersonajePlayer);
            lastDestiny = destino;
            followPath  = new PathFollowEndSD(recorrido);
        }
        if (followPath.finishedLinear)
        {
            personaje.fakeAlign.orientacion = _target.orientacion + offsetOrientation;
            if (personaje.fakeAlign.orientacion < -System.Math.PI)
            {
                personaje.fakeAlign.orientacion += 2 * (float)System.Math.PI;
            }
            else if (personaje.fakeAlign.orientacion > System.Math.PI)
            {
                personaje.fakeAlign.orientacion -= 2 * (float)System.Math.PI;
            }
            personaje.fakeAlign.transform.eulerAngles = new Vector3(0, (_target.orientacion + offsetOrientation) * Bodi.RadianesAGrados, 0);
            faceSD.target = personaje.fakeAlign;
            parada.getSteering(personaje);
            return(faceSD.getSteering(personaje));
        }
        else
        {
            return(followPath.getSteering(personaje));
        }
    }
Example #2
0
    protected internal override Steering getSteering(PersonajeBase personaje)
    {
        _finishedLinear = _finishedAngular = false;
        Vector3 newOffset = SimulationManager.DirectionToVector(_target.orientacion + SimulationManager.VectorToDirection(offsetPosition)) * offsetPosition.magnitude;

        opSD.target = _target;
        opSD.offset = newOffset;
        Steering st = opSD.getSteering(personaje);

        if (opSD.finishedLinear)
        {
            personaje.fakeAlign.orientacion = _target.orientacion + offsetOrientation;
            if (personaje.fakeAlign.orientacion < -System.Math.PI)
            {
                personaje.fakeAlign.orientacion += 2 * (float)System.Math.PI;
            }
            else if (personaje.fakeAlign.orientacion > System.Math.PI)
            {
                personaje.fakeAlign.orientacion -= 2 * (float)System.Math.PI;
            }
            personaje.fakeAlign.transform.eulerAngles = new Vector3(0, (_target.orientacion + offsetOrientation) * Bodi.RadianesAGrados, 0);
            faceSD.target = personaje.fakeAlign;
            st.angular    = faceSD.getSteering(personaje).angular;
        }
        //_finishedLinear = opSD.finishedLinear;
        //_finishedAngular = faceSD.finishedAngular;
        return(st);
    }
Example #3
0
    protected internal override Steering getSteering(PersonajeBase personaje)
    {
        Steering st = new Steering();
        float    angularVariation = (float)randomizer.NextDouble() * rotationLimit - rotationLimit / 2; //rotacion random entre orientacion - limite/2 y orientacion+limite/2
        float    nuevoAngulo      = personaje.orientacion + angularVariation;

        st.angular = SimulationManager.TurnAmountInDirection(personaje.orientacion, SimulationManager.VectorToDirection(personaje.velocidad)); //rotacion random entre orientacion - limite/2 y orientacion+limite/2
        st.linear  = SimulationManager.DirectionToVector(nuevoAngulo) * offset;
        return(st);
    }
Example #4
0
    internal void OnDrawGizmos()
    {
        Vector3 origin = posicion + Vector3.up;

        //Drawing gizmos
        //Whiskers
        Gizmos.color = Color.green;

        /*if (velocidad != Vector3.zero)
         * {
         *  Gizmos.DrawLine(origin, origin + velocidad.normalized * maxMovementSpeed);
         *  Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(SimulationManager.VectorToDirection(velocidad) + outterAngleVision).normalized * maxMovementSpeed / 2);
         *  Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(SimulationManager.VectorToDirection(velocidad) - outterAngleVision).normalized * maxMovementSpeed / 2);
         * }
         * else
         * {*/
        //Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(orientacion) * velocidad.magnitude*2.5f);
        Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(orientacion) * maxMovementSpeed * 2f);
        float leftOri = orientacion - outterAngleVision;

        if (leftOri > System.Math.PI)
        {
            leftOri -= 2 * (float)System.Math.PI;
        }
        else if (leftOri < -System.Math.PI)
        {
            leftOri += 2 * (float)System.Math.PI;
        }
        //Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(leftOri) * velocidad.magnitude * 1.5f);
        Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(leftOri) * maxMovementSpeed * 1.5f);
        float rightOri = orientacion + outterAngleVision;

        if (rightOri > System.Math.PI)
        {
            rightOri -= 2 * (float)System.Math.PI;
        }
        else if (rightOri < -System.Math.PI)
        {
            rightOri += 2 * (float)System.Math.PI;
        }
        //Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(rightOri) * velocidad.magnitude * 1.5f);
        Gizmos.DrawLine(origin, origin + SimulationManager.DirectionToVector(rightOri) * maxMovementSpeed * 1.5f);

        //}
        //Area detectors
        Gizmos.color = Color.grey;
        //Gizmos.DrawSphere(posicion, innerDetector);
        Gizmos.color = Color.black;
        //Gizmos.DrawSphere(posicion, outterDetector);
        //Bodi vars
        Gizmos.color = Color.blue;
        Gizmos.DrawLine(origin + Vector3.up / 2, origin + Vector3.up / 2 + velocidad);
        Gizmos.color = Color.yellow;
        Gizmos.DrawLine(origin + Vector3.up / 2, origin + Vector3.up / 2 + aceleracion);
    }
Example #5
0
    protected internal override Steering getSteering(PersonajeBase personaje)
    {
        if (pursueSD.finishedLinear || setup)
        {
            setup = false;
            float angularVariation = (float)randomizer.NextDouble() * rotationLimit * 2 - rotationLimit; //rotacion random entre orientacion - limite/2 y orientacion+limite/2
            float nuevoAngulo      = personaje.orientacion + angularVariation;

            Vector3 wanderCenter           = personaje.posicion + SimulationManager.DirectionToVector(personaje.orientacion) * offset;
            float   secondAngularVariation = (float)randomizer.NextDouble() * wanderLimit * 2 - wanderLimit;

            Vector3 wanderTarget = wanderCenter + SimulationManager.DirectionToVector(nuevoAngulo + secondAngularVariation) * wanderRadius;
            //personaje.fakeMovement.posicion = personaje.posicion + SimulationManager.DirectionToVector(nuevoAngulo) * offset;
            personaje.fakeMovement.posicion = wanderTarget;
            personaje.fakeMovement.moveTo(wanderTarget);
        }
        pursueSD.target = personaje.fakeMovement;
        return(pursueSD.getSteering(personaje));
    }
    protected internal override Steering getSteering(PersonajeBase personaje)
    {
        terciaryWhiskersAngle  = personaje.outterAngleVision;
        secondaryWhiskersAngle = personaje.outterAngleVision / 2;
        //secondaryWhiskersLength = personaje.velocidad.magnitude*1.5f;
        //primaryWhiskerLenght = personaje.velocidad.magnitude*2.5f;
        terciaryWhiskersLength  = personaje.maxMovSpeed * multiplier * 0.5f;
        secondaryWhiskersLength = personaje.maxMovSpeed * 0.75f * multiplier;
        primaryWhiskerLenght    = personaje.maxMovSpeed * 1.5f * multiplier;
        wallOffset = personaje.innerDetector * 1.5f;

        RaycastHit leftSWHit, leftTWHit, rightSWHit, rightTWHit, midWHit;

        float leftSecondaryOri = personaje.orientacion - secondaryWhiskersAngle;

        if (leftSecondaryOri > System.Math.PI)
        {
            leftSecondaryOri -= 2 * (float)System.Math.PI;
        }
        else if (leftSecondaryOri < -System.Math.PI)
        {
            leftSecondaryOri += 2 * (float)System.Math.PI;
        }

        float leftTerciaryOri = personaje.orientacion - terciaryWhiskersAngle;

        if (leftTerciaryOri > System.Math.PI)
        {
            leftTerciaryOri -= 2 * (float)System.Math.PI;
        }
        else if (leftTerciaryOri < -System.Math.PI)
        {
            leftTerciaryOri += 2 * (float)System.Math.PI;
        }


        float rightSecondaryOri = personaje.orientacion + secondaryWhiskersAngle;

        if (rightSecondaryOri > System.Math.PI)
        {
            rightSecondaryOri -= 2 * (float)System.Math.PI;
        }
        else if (rightSecondaryOri < -System.Math.PI)
        {
            rightSecondaryOri += 2 * (float)System.Math.PI;
        }

        float rightTerciaryOri = personaje.orientacion + terciaryWhiskersAngle;

        if (rightTerciaryOri > System.Math.PI)
        {
            rightTerciaryOri -= 2 * (float)System.Math.PI;
        }
        else if (rightTerciaryOri < -System.Math.PI)
        {
            rightTerciaryOri += 2 * (float)System.Math.PI;
        }


        bool midWhisker    = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(personaje.orientacion), out midWHit, primaryWhiskerLenght, 1 << 9 | 1 << 8 | 1 << 13);
        bool leftSWhisker  = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(leftSecondaryOri), out leftSWHit, secondaryWhiskersLength, 1 << 9 | 1 << 8 | 1 << 13);
        bool rightSWhisker = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(rightSecondaryOri), out rightSWHit, secondaryWhiskersLength, 1 << 9 | 1 << 8 | 1 << 13);
        bool leftTWhisker  = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(leftTerciaryOri), out leftTWHit, terciaryWhiskersLength, 1 << 9 | 1 << 8 | 1 << 13);
        bool righTWhisker  = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(rightTerciaryOri), out rightTWHit, terciaryWhiskersLength, 1 << 9 | 1 << 8 | 1 << 13);


        if (midWhisker)
        {
            _finishedLinear = _finishedAngular = false;

            Vector3 newPos = midWHit.point + midWHit.normal.normalized * wallOffset;

            newPos = new Vector3(newPos.x, 0, newPos.z);
            Vector2 newPos2d = SimManagerFinal.positionToGrid(newPos);
            if (SimManagerFinal.terrenos[(int)newPos2d.x][(int)newPos2d.y] == StatsInfo.TIPO_TERRENO.INFRANQUEABLE)
            {
                newPos2d = getVecinoFranqueable(newPos2d);
            }
            newPos = SimManagerFinal.gridToPosition(newPos2d);
            personaje.fakeAvoid.posicion      = newPos;
            personaje.fakeAvoid.innerDetector = personaje.innerDetector;
            personaje.fakeAvoid.moveTo(newPos);
            pursueSD.target = personaje.fakeAvoid;
        }
        else if ((leftSWhisker || leftTWhisker) && !rightSWhisker && !righTWhisker)
        {
            _finishedLinear = _finishedAngular = false;

            float hipotenusa           = 0;
            float transversalDistance  = 0;
            float longitudinalDistance = 0;
            if (leftSWhisker)
            {
                hipotenusa           = leftSWHit.distance;
                transversalDistance  = hipotenusa * (float)System.Math.Sin(secondaryWhiskersAngle);
                longitudinalDistance = hipotenusa * (float)System.Math.Cos(secondaryWhiskersAngle);
            }
            else if (leftTWhisker)
            {
                hipotenusa           = leftTWHit.distance;
                transversalDistance  = hipotenusa * (float)System.Math.Sin(terciaryWhiskersAngle);
                longitudinalDistance = hipotenusa * (float)System.Math.Cos(terciaryWhiskersAngle);
            }
            else
            {
                hipotenusa           = (leftSWHit.distance + leftTWHit.distance) / 2;
                transversalDistance  = hipotenusa * (float)System.Math.Sin((secondaryWhiskersAngle + terciaryWhiskersAngle) / 2);
                longitudinalDistance = hipotenusa * (float)System.Math.Cos((secondaryWhiskersAngle + terciaryWhiskersAngle) / 2);
            }

            float transversalOri = personaje.orientacion + 90 * Bodi.GradosARadianes;
            if (transversalOri > (float)System.Math.PI)
            {
                transversalOri -= 2 * (float)System.Math.PI;
            }
            else if (transversalOri < (float)System.Math.PI)
            {
                transversalOri += 2 * (float)System.Math.PI;
            }
            //CUSTOM FOR INNER CORNERS
            Vector3 newPos = personaje.posicion + personaje.velocidad.normalized * longitudinalDistance
                             + SimulationManager.DirectionToVector(transversalOri) * (wallOffset - transversalDistance);

            newPos = new Vector3(newPos.x, 0, newPos.z);
            Vector2 newPos2d = SimManagerFinal.positionToGrid(newPos);
            if (SimManagerFinal.terrenos[(int)newPos2d.x][(int)newPos2d.y] == StatsInfo.TIPO_TERRENO.INFRANQUEABLE)
            {
                newPos2d = getVecinoFranqueable(newPos2d);
            }
            newPos = SimManagerFinal.gridToPosition(newPos2d);
            personaje.fakeAvoid.posicion      = newPos;
            personaje.fakeAvoid.innerDetector = personaje.innerDetector;
            personaje.fakeAvoid.moveTo(newPos);
            pursueSD.target = personaje.fakeAvoid;
        }
        else if ((rightSWhisker || righTWhisker) && !leftSWhisker && !leftTWhisker)
        {
            _finishedLinear = _finishedAngular = false;

            float hipotenusa           = 0;
            float transversalDistance  = 0;
            float longitudinalDistance = 0;
            if (rightSWhisker)
            {
                hipotenusa           = leftSWHit.distance;
                transversalDistance  = hipotenusa * (float)System.Math.Sin(secondaryWhiskersAngle);
                longitudinalDistance = hipotenusa * (float)System.Math.Cos(secondaryWhiskersAngle);
            }
            else if (righTWhisker)
            {
                hipotenusa           = leftTWHit.distance;
                transversalDistance  = hipotenusa * (float)System.Math.Sin(terciaryWhiskersAngle);
                longitudinalDistance = hipotenusa * (float)System.Math.Cos(terciaryWhiskersAngle);
            }
            else
            {
                hipotenusa           = (leftSWHit.distance + leftTWHit.distance) / 2;
                transversalDistance  = hipotenusa * (float)System.Math.Sin((secondaryWhiskersAngle + terciaryWhiskersAngle) / 2);
                longitudinalDistance = hipotenusa * (float)System.Math.Cos((secondaryWhiskersAngle + terciaryWhiskersAngle) / 2);
            }


            float transversalOri = personaje.orientacion - 90 * Bodi.GradosARadianes;
            if (transversalOri > (float)System.Math.PI)
            {
                transversalOri -= 2 * (float)System.Math.PI;
            }
            else if (transversalOri < (float)System.Math.PI)
            {
                transversalOri += 2 * (float)System.Math.PI;
            }

            //CUSTOM FOR INNER CORNERS
            Vector3 newPos = personaje.posicion + personaje.velocidad.normalized * longitudinalDistance
                             + SimulationManager.DirectionToVector(transversalOri) * (wallOffset - transversalDistance);

            newPos = new Vector3(newPos.x, 0, newPos.z);
            Vector2 newPos2d = SimManagerFinal.positionToGrid(newPos);
            if (SimManagerFinal.terrenos[(int)newPos2d.x][(int)newPos2d.y] == StatsInfo.TIPO_TERRENO.INFRANQUEABLE)
            {
                newPos2d = getVecinoFranqueable(newPos2d);
            }
            newPos = SimManagerFinal.gridToPosition(newPos2d);
            personaje.fakeAvoid.posicion      = newPos;
            personaje.fakeAvoid.innerDetector = personaje.innerDetector;
            personaje.fakeAvoid.moveTo(newPos);
            pursueSD.target = personaje.fakeAvoid;
        }
        else if (_finishedLinear || (!_finishedLinear && pursueSD.finishedLinear))
        {
            _finishedLinear = _finishedAngular = true;
            return(new Steering());
        }
        return(pursueSD.getSteering(personaje));
    }
    protected internal override Steering getSteering(PersonajeBase personaje)
    {
        secondaryWhiskersAngle = personaje.outterAngleVision;
        //secondaryWhiskersLength = personaje.velocidad.magnitude*1.5f;
        //primaryWhiskerLenght = personaje.velocidad.magnitude*2.5f;
        secondaryWhiskersLength = personaje.maxMovSpeed * 1.5f * multiplier;
        primaryWhiskerLenght    = personaje.maxMovSpeed * 2f * multiplier;
        wallOffset = personaje.innerDetector * 1.1f * multiplier;

        RaycastHit leftWHit, rightWHit, midWHit;
        float      leftOri = personaje.orientacion - secondaryWhiskersAngle;

        if (leftOri > System.Math.PI)
        {
            leftOri -= 2 * (float)System.Math.PI;
        }
        else if (leftOri < -System.Math.PI)
        {
            leftOri += 2 * (float)System.Math.PI;
        }
        float rightOri = personaje.orientacion + secondaryWhiskersAngle;

        if (rightOri > System.Math.PI)
        {
            rightOri -= 2 * (float)System.Math.PI;
        }
        else if (rightOri < -System.Math.PI)
        {
            rightOri += 2 * (float)System.Math.PI;
        }
        bool midWhisker   = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(personaje.orientacion), out midWHit, primaryWhiskerLenght, 1 << 9 | 1 << 8 | 1 << 13);
        bool leftWhisker  = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(leftOri), out leftWHit, secondaryWhiskersLength, 1 << 9 | 1 << 8 | 1 << 13);
        bool rightWhisker = Physics.Raycast(personaje.posicion, SimulationManager.DirectionToVector(rightOri), out rightWHit, secondaryWhiskersLength, 1 << 9 | 1 << 8 | 1 << 13);


        if (midWhisker)
        {
            _finishedLinear = _finishedAngular = false;

            Vector3 newPos = midWHit.point + midWHit.normal.normalized * wallOffset;

            newPos = new Vector3(newPos.x, 0, newPos.z);
            personaje.fakeAvoid.posicion      = newPos;
            personaje.fakeAvoid.innerDetector = personaje.innerDetector;
            personaje.fakeAvoid.moveTo(newPos);
        }
        else if (leftWhisker && !rightWhisker)
        {
            _finishedLinear = _finishedAngular = false;

            float hipotenusa           = leftWHit.distance;
            float transversalDistance  = hipotenusa * (float)System.Math.Sin(secondaryWhiskersAngle);
            float longitudinalDistance = hipotenusa * (float)System.Math.Cos(secondaryWhiskersAngle);

            float transversalOri = personaje.orientacion + 90 * Bodi.GradosARadianes;
            if (transversalOri > (float)System.Math.PI)
            {
                transversalOri -= 2 * (float)System.Math.PI;
            }
            else if (transversalOri < (float)System.Math.PI)
            {
                transversalOri += 2 * (float)System.Math.PI;
            }
            //CUSTOM FOR INNER CORNERS
            Vector3 newPos = personaje.posicion + personaje.velocidad.normalized * longitudinalDistance
                             + SimulationManager.DirectionToVector(transversalOri) * (wallOffset - transversalDistance);

            newPos = new Vector3(newPos.x, 0, newPos.z);
            personaje.fakeAvoid.posicion      = newPos;
            personaje.fakeAvoid.innerDetector = personaje.innerDetector;
            personaje.fakeAvoid.moveTo(newPos);
        }
        else if (rightWhisker && !leftWhisker)
        {
            _finishedLinear = _finishedAngular = false;

            float hipotenusa           = rightWHit.distance;
            float transversalDistance  = hipotenusa * (float)System.Math.Sin(secondaryWhiskersAngle);
            float longitudinalDistance = hipotenusa * (float)System.Math.Cos(secondaryWhiskersAngle);


            float transversalOri = personaje.orientacion - 90 * Bodi.GradosARadianes;
            if (transversalOri > (float)System.Math.PI)
            {
                transversalOri -= 2 * (float)System.Math.PI;
            }
            else if (transversalOri < (float)System.Math.PI)
            {
                transversalOri += 2 * (float)System.Math.PI;
            }

            //CUSTOM FOR INNER CORNERS
            Vector3 newPos = personaje.posicion + personaje.velocidad.normalized * longitudinalDistance
                             + SimulationManager.DirectionToVector(transversalOri) * (wallOffset - transversalDistance);

            newPos = new Vector3(newPos.x, 0, newPos.z);
            personaje.fakeAvoid.posicion      = newPos;
            personaje.fakeAvoid.innerDetector = personaje.innerDetector;
            personaje.fakeAvoid.moveTo(newPos);
        }
        else if (_finishedLinear || (!_finishedLinear && pursueSD.finishedLinear))
        {
            _finishedLinear = _finishedAngular = true;
            return(new Steering());
        }
        pursueSD.target = personaje.fakeAvoid;
        return(pursueSD.getSteering(personaje));
    }