示例#1
0
        Vector3 Seek(Vector3 targetPos)
        {
            Vector3 desiredVelocity;

            desiredVelocity = targetPos - transform.position;
            desiredVelocity.Normalize();
            desiredVelocity *= maxSpeed;
            if (Params.drawDebugLines)
            {
                LineDrawer.DrawTarget(targetPos, Color.red);
            }
            return(desiredVelocity - velocity);
        }
示例#2
0
文件: Lazer.cs 项目: skooter500/Fish
        public void Update()
        {
            float speed  = 5.0f;
            float width  = 500;
            float height = 500;

            if ((transform.position.x < -(width / 2)) || (transform.position.x > width / 2) || (transform.position.z < -(height / 2)) || (transform.position.z > height / 2) || (transform.position.y < 0) || (transform.position.y > 100))
            {
                Destroy(gameObject);
            }
            transform.position += transform.forward * speed;
            LineDrawer.DrawLine(transform.position, transform.position + transform.forward * 10.0f, Color.red);
        }
 public void Draw()
 {
     if (draw)
     {
         for (int i = 1; i < waypoints.Count(); i++)
         {
             LineDrawer.DrawLine(waypoints[i - 1], waypoints[i], Color.clear);
         }
         if (looped && (waypoints.Count() > 0))
         {
             LineDrawer.DrawLine(waypoints[0], waypoints[waypoints.Count() - 1], Color.clear);
         }
     }
 }
示例#4
0
        public void Update()
        {
            if (drawGizmos)
            {
                LineDrawer.DrawSphere(transform.position, radius, 20, Color.yellow);
            }

            if (GetComponent <Boid>() != null)
            {
                foreach (GameObject o in boids)
                {
                    o.GetComponent <Boid>().sphereCentre = transform.position;
                }
            }
        }
示例#5
0
        Vector3 Pursue()
        {
            Vector3 toTarget = target.transform.position - transform.position;
            float   dist     = toTarget.magnitude;
            float   time     = dist / maxSpeed;

            Vector3 targetPos = target.transform.position + (time * target.GetComponent <SteeringBehaviours>().velocity);

            if (Params.drawDebugLines)
            {
                LineDrawer.DrawLine(transform.position, targetPos, debugLineColour);
            }

            return(Seek(targetPos));
        }
示例#6
0
        Vector3 Pursue()
        {
            Vector3 toTarget = pursuitTarget.transform.position - transform.position;
            float   dist     = toTarget.magnitude;
            float   time     = dist / maxSpeed;

            Vector3 targetPos = pursuitTarget.transform.position + (time * pursuitTarget.GetComponent <Boid>().velocity);

            if (drawGizmos)
            {
                LineDrawer.DrawTarget(targetPos, Color.red);
                LineDrawer.DrawLine(transform.position, targetPos, Color.cyan);
            }

            return(Seek(targetPos));
        }
示例#7
0
        Vector3 Flee(Vector3 targetPos)
        {
            Vector3 desiredVelocity;

            desiredVelocity = transform.position - targetPos;
            if (desiredVelocity.magnitude > fleeRange)
            {
                return(Vector3.zero);
            }
            if (drawGizmos)
            {
                LineDrawer.DrawSphere(transform.position, fleeRange, 20, Color.yellow);
            }
            desiredVelocity.Normalize();
            desiredVelocity *= maxSpeed;
            return(desiredVelocity - velocity);
        }
示例#8
0
        Vector3 Wander()
        {
            float jitterTimeSlice = Params.GetFloat("wander_jitter") * timeDelta;

            Vector3 toAdd = UnityEngine.Random.insideUnitSphere * jitterTimeSlice;

            wanderTargetPos += toAdd;
            wanderTargetPos.Normalize();
            wanderTargetPos *= Params.GetFloat("wander_radius");

            Vector3 localTarget = wanderTargetPos + Vector3.forward * Params.GetFloat("wander_distance");
            Vector3 worldTarget = transform.TransformPoint(localTarget);

            if (Params.drawDebugLines)
            {
                LineDrawer.DrawTarget(worldTarget, Color.blue);
            }
            return(worldTarget - transform.position);
        }
示例#9
0
        Vector3 Wander()
        {
            float jitterTimeSlice = wanderJitter * timeDelta;

            Vector3 toAdd = UnityEngine.Random.insideUnitSphere * jitterTimeSlice;

            wanderTargetPos += toAdd;
            wanderTargetPos.Normalize();
            wanderTargetPos *= wanderRadius;

            Vector3 localTarget = wanderTargetPos + Vector3.forward * wanderDistance;
            Vector3 worldTarget = transform.TransformPoint(localTarget);

            if (drawGizmos)
            {
                LineDrawer.DrawTarget(worldTarget, Color.blue);
            }
            return(worldTarget - transform.position);
        }
示例#10
0
        private int TagNeighboursSimple(float inRange)
        {
            tagged.Clear();

            GameObject[] allBoids = GameObject.FindGameObjectsWithTag("boid");

            foreach (GameObject boid in allBoids)
            {
                if (boid != gameObject)
                {
                    if (drawNeighbours && Params.drawDebugLines)
                    {
                        LineDrawer.DrawLine(transform.position, boid.transform.position, Color.yellow);
                    }
                    if ((transform.position - boid.transform.position).magnitude < inRange)
                    {
                        tagged.Add(boid);
                    }
                }
            }
            DrawNeighbours(Color.white);
            return(tagged.Count);
        }
 // Use this for initialization
 void Start()
 {
     instance = this;
 }
示例#12
0
        Vector3 ObstacleAvoidance()
        {
            Vector3 force = Vector3.zero;

            makeFeelers();
            List <GameObject> tagged       = new List <GameObject>();
            float             minBoxLength = 50.0f;
            float             boxLength    = minBoxLength + ((velocity.magnitude / maxSpeed) * minBoxLength * 2.0f);

            if (float.IsNaN(boxLength))
            {
                System.Console.WriteLine("NAN");
            }

            GameObject[] obstacles = GameObject.FindGameObjectsWithTag("obstacle");
            // Matt Bucklands Obstacle avoidance
            // First tag obstacles in range
            if (obstacles.Length == 0)
            {
                return(Vector3.zero);
            }
            foreach (GameObject obstacle in obstacles)
            {
                if (obstacle == null)
                {
                    Debug.Log("Null object");
                    continue;
                }

                Vector3 toCentre = transform.position - obstacle.transform.position;
                float   dist     = toCentre.magnitude;
                if (dist < boxLength)
                {
                    tagged.Add(obstacle);
                }
            }

            float      distToClosestIP             = float.MaxValue;
            GameObject closestIntersectingObstacle = null;
            Vector3    localPosOfClosestObstacle   = Vector3.zero;
            Vector3    intersection = Vector3.zero;

            foreach (GameObject o in tagged)
            {
                Vector3 localPos = transform.InverseTransformPoint(o.transform.position);

                // If the local position has a positive Z value then it must lay
                // behind the agent. (in which case it can be ignored)
                if (localPos.z >= 0)
                {
                    // If the distance from the x axis to the object's position is less
                    // than its radius + half the width of the detection box then there
                    // is a potential intersection.

                    float obstacleRadius = o.transform.localScale.x / 2;
                    float expandedRadius = GetRadius() + obstacleRadius;
                    if ((Math.Abs(localPos.y) < expandedRadius) && (Math.Abs(localPos.x) < expandedRadius))
                    {
                        // Now to do a ray/sphere intersection test. The center of the
                        // Create a temp Entity to hold the sphere in local space
                        Sphere tempSphere = new Sphere(expandedRadius, localPos);

                        // Create a ray
                        BGE.Geom.Ray ray = new BGE.Geom.Ray();
                        ray.pos  = new Vector3(0, 0, 0);
                        ray.look = Vector3.forward;

                        // Find the point of intersection
                        if (tempSphere.closestRayIntersects(ray, Vector3.zero, ref intersection) == false)
                        {
                            continue;
                        }

                        // Now see if its the closest, there may be other intersecting spheres
                        float dist = intersection.magnitude;
                        if (dist < distToClosestIP)
                        {
                            dist = distToClosestIP;
                            closestIntersectingObstacle = o;
                            localPosOfClosestObstacle   = localPos;
                        }
                    }
                }
            }

            if (closestIntersectingObstacle != null)
            {
                // Now calculate the force
                float multiplier = 1.0f + (boxLength - localPosOfClosestObstacle.z) / boxLength;

                //calculate the lateral force
                float obstacleRadius = closestIntersectingObstacle.transform.localScale.x / 2; // closestIntersectingObstacle.GetComponent<Renderer>().bounds.extents.magnitude;
                float expandedRadius = GetRadius() + obstacleRadius;
                force.x = (expandedRadius - Math.Abs(localPosOfClosestObstacle.x)) * multiplier;
                force.y = (expandedRadius - Math.Abs(localPosOfClosestObstacle.y)) * multiplier;

                // Generate positive or negative direction so we steer around!
                // Not always in the same direction as in Matt Bucklands book
                if (localPosOfClosestObstacle.x > 0)
                {
                    force.x = -force.x;
                }

                // If the obstacle is above, steer down
                if (localPosOfClosestObstacle.y > 0)
                {
                    force.y = -force.y;
                }

                if (Params.drawDebugLines)
                {
                    LineDrawer.DrawLine(transform.position, transform.position + transform.forward * boxLength, Color.grey);
                }
                //apply a braking force proportional to the obstacle's distance from
                //the vehicle.
                const float brakingWeight = 0.01f;
                force.z = (expandedRadius -
                           localPosOfClosestObstacle.z) *
                          brakingWeight;

                //finally, convert the steering vector from local to world space
                // Dont include position!
                force = transform.TransformDirection(force);
            }


            return(force);
        }
示例#13
0
        void Update()
        {
            float smoothRate;

            force = Calculate();
            if (Params.drawForces)
            {
                Quaternion q = Quaternion.FromToRotation(Vector3.forward, force);
                LineDrawer.DrawArrowLine(transform.position, transform.position + force * 5.0f, Color.blue, q);
            }
            Utilities.checkNaN(force);
            Vector3 newAcceleration = force / mass;

            if (Params.drawVectors)
            {
                LineDrawer.DrawVectors(transform);
            }

            timeDelta = Time.deltaTime * Params.timeModifier;


            if (timeDelta > 0.0f)
            {
                smoothRate = Utilities.Clip(9.0f * timeDelta, 0.15f, 0.4f) / 2.0f;
                Utilities.BlendIntoAccumulator(smoothRate, newAcceleration, ref acceleration);
            }

            velocity += acceleration * timeDelta;

            float speed = velocity.magnitude;

            if (speed > maxSpeed)
            {
                velocity.Normalize();
                velocity *= maxSpeed;
            }
            transform.position += velocity * timeDelta;


            // the length of this global-upward-pointing vector controls the vehicle's
            // tendency to right itself as it is rolled over from turning acceleration
            Vector3 globalUp = new Vector3(0, 0.2f, 0);
            // acceleration points toward the center of local path curvature, the
            // length determines how much the vehicle will roll while turning
            Vector3 accelUp = acceleration * 0.05f;
            // combined banking, sum of UP due to turning and global UP
            Vector3 bankUp = accelUp + globalUp;

            // blend bankUp into vehicle's UP basis vector
            smoothRate = timeDelta * 3.0f;
            Vector3 tempUp = transform.up;

            Utilities.BlendIntoAccumulator(smoothRate, bankUp, ref tempUp);

            if (speed > 0.0001f)
            {
                transform.forward = velocity;
                transform.forward.Normalize();
                transform.LookAt(transform.position + transform.forward, tempUp);
                // Apply damping
                velocity *= 0.99f;
            }



            path.Draw();

            if (Params.enforceNonPenetrationConstraint)
            {
                EnforceNonPenetrationConstraint();
            }
        }
示例#14
0
        Vector3 SceneAvoidance()
        {
            Vector3    force = Vector3.zero;
            RaycastHit info;

            // Check the forward feeler and generate a up force
            Vector3 feeler = Vector3.forward;

            feeler = transform.TransformDirection(feeler);
            if (Physics.Raycast(transform.position, feeler, out info, sceneAvoidanceFeelerDepth))
            {
                // Push me away in the direction of the up vector.
                // The deeper the penetration the bigger the force
                float depth = (info.point - feeler).magnitude;
                force = transform.up * depth;
                if (drawGizmos)
                {
                    LineDrawer.DrawLine(transform.position, transform.position + feeler * sceneAvoidanceFeelerDepth, Color.red);
                }
            }

            // Check the bottom feeler and generate an upwards force
            feeler = Vector3.forward;
            feeler = Quaternion.AngleAxis(45, Vector3.right) * feeler;
            feeler = transform.TransformDirection(feeler);
            if (Physics.Raycast(transform.position, feeler, out info, sceneAvoidanceFeelerDepth))
            {
                // Push me away in the direction of the up vector.
                // The deeper the penetration the bigger the force
                float depth = (info.point - feeler).magnitude;
                force += transform.up * depth;
                if (drawGizmos)
                {
                    LineDrawer.DrawLine(transform.position, transform.position + feeler * sceneAvoidanceFeelerDepth, Color.red);
                }
            }

            // Check the top feeler and generate a downward force
            feeler = Vector3.forward;
            feeler = Quaternion.AngleAxis(-45, Vector3.right) * feeler;
            feeler = transform.TransformDirection(feeler);
            if (Physics.Raycast(transform.position, feeler, out info, sceneAvoidanceFeelerDepth))
            {
                // Push me away in the direction of the up vector.
                // The deeper the penetration the bigger the force
                float depth = (info.point - feeler).magnitude;
                force -= transform.up * depth;
                if (drawGizmos)
                {
                    LineDrawer.DrawLine(transform.position, transform.position + feeler * sceneAvoidanceFeelerDepth, Color.red);
                }
            }

            // Check the left feeler and generate a right force
            feeler = Vector3.forward;
            feeler = Quaternion.AngleAxis(45, Vector3.right) * feeler;
            feeler = transform.TransformDirection(feeler);
            if (Physics.Raycast(transform.position, feeler, out info, sceneAvoidanceFeelerDepth))
            {
                // Push me away in the direction of the up vector.
                // The deeper the penetration the bigger the force
                float depth = (info.point - feeler).magnitude;
                force += transform.right * depth;
                if (drawGizmos)
                {
                    LineDrawer.DrawLine(transform.position, transform.position + feeler * sceneAvoidanceFeelerDepth, Color.red);
                }
            }

            // Check the right feeler and generate a left force
            feeler = Vector3.forward;
            feeler = Quaternion.AngleAxis(-45, Vector3.right) * feeler;
            feeler = transform.TransformDirection(feeler);
            if (Physics.Raycast(transform.position, feeler, out info, sceneAvoidanceFeelerDepth))
            {
                // Push me away in the direction of the up vector.
                // The deeper the penetration the bigger the force
                float depth = (info.point - feeler).magnitude;
                force -= transform.right * depth;
                if (drawGizmos)
                {
                    LineDrawer.DrawLine(transform.position, transform.position + feeler * sceneAvoidanceFeelerDepth, Color.red);
                }
            }



            return(force);
        }
 // Use this for initialization
 void Start()
 {
     instance = this;
 }