コード例 #1
0
            public static Vector3 getForceForDesiredVelocity(Steering steering, Vector3 desiredVelocity)
            {
                // The velocity will be changed by force * deltaTime, so the desired force is deltaV/deltaTime.
                Vector3 desiredForce = (desiredVelocity - steering.GetVelocity()) / Time.fixedDeltaTime;

                return(scaledDownVector(steering.GetAcceleration(), desiredForce));
            }
コード例 #2
0
            public Vector3 GetForce(Steering steering)
            {
                if (isResponsibleForNeighbourUpdate)
                {
                    // TODO: figure out how to add or remove neighbours automatically here or in neighbours
                    neighbours.Update();
                }

                /*
                 * Avoid collisions by determining for each neighbor when their paths will be closest to each other
                 * and then steer laterally to avoid collision.
                 * https://www.red3d.com/cwr/steer/Unaligned.html
                 */
                float distanceToBeginReacting = 4f * (steering.GetSize() + steering.GetStoppingDistance());

                //Debug.Log(doubleStopDistance);
                foreach (Neighbour <Steering> neighbour in neighbours)
                {
                    if (neighbour.dd > distanceToBeginReacting * distanceToBeginReacting)
                    {
                        break;
                    }
                    Steering otherUnit        = neighbour.obj;
                    Vector3  offset           = otherUnit.GetPosition() - steering.GetPosition();
                    Vector3  relativeVelocity = steering.GetVelocity() - otherUnit.GetVelocity();
                    // Decrease the timeToCollision so that closestOffset is nonZero.
                    float combinedSize    = steering.GetSize() + otherUnit.GetSize();
                    float timeToCollision = (offset.magnitude - combinedSize) / SteeringUtilities.parallelComponent(relativeVelocity, offset).magnitude;
                    if (timeToCollision > 2 * steering.GetStoppingTime())
                    {
                        continue;
                    }
                    Vector3 closestOffset     = (offset - (timeToCollision * relativeVelocity));
                    float   preferredDistance = 1.5f * combinedSize;
                    if (closestOffset.sqrMagnitude > preferredDistance * preferredDistance)
                    {
                        continue;
                    }
                    SteeringUtilities.drawDebugVector(steering, timeToCollision * steering.GetVelocity(), Color.cyan);
                    SteeringUtilities.drawDebugPoint(steering.GetPosition() + timeToCollision * steering.GetVelocity(), Color.cyan);
                    SteeringUtilities.drawDebugVector(otherUnit, timeToCollision * otherUnit.GetVelocity(), Color.cyan);
                    SteeringUtilities.drawDebugPoint(otherUnit.GetPosition() + timeToCollision * otherUnit.GetVelocity(), Color.cyan);
                    // TODO: for head-on collisions steer to the right
                    // Steer in the direction of the component of the collision normal that is perpindicular to the current velocity.
                    // This way the unit will turn instead of just slowing down.

                    // TODO: use an amount of acceleration proportionate to the time until collision and the severity of the collision
                    return(SteeringUtilities.scaledVector(steering.GetAcceleration(), SteeringUtilities.perpindicularComponent(-closestOffset, steering.GetVelocity())));
                    //return SteeringUtilities.getForceForDirection(steering, -closestOffset);
                }
                return(Vector3.zero);
            }
コード例 #3
0
            public Vector3 GetForce(Steering steering)
            {
                float raycastDistance = 2f * (2f * steering.GetSize()) + 2f * (steering.GetMaxSpeed() * steering.GetMaxSpeed() / steering.GetAcceleration());
                // TODO: send out 3 rays and define static quaternions to determine the rotated direction vectors.
                Vector3 directionVector = steering.GetVelocity();
                // TODO: update the side raycast lengths based on steering's size, and the center raycast based on speed.
                // TODO: constrain hit normals to the relevant plane in case the collider has a complicated shape
                Vector3 hitNormal1 = RaycastNormal(steering, (Steering.UseXZ ? xzRotateLeft : xyRotateLeft) * directionVector, raycastDistance * 0.5f);
                Vector3 hitNormal2 = RaycastNormal(steering, directionVector, raycastDistance);
                Vector3 hitNormal3 = RaycastNormal(steering, (Steering.UseXZ ? xzRotateRight : xyRotateRight) * directionVector, raycastDistance * 0.5f);
                // If multiple raycasts hit, sum the normals.
                // TODO: weight the normals differently based on which collision point is closest.
                Vector3 combinedNormal = SteeringUtilities.scaledDownVector(1f, hitNormal1 + hitNormal2 + hitNormal3);

                if (combinedNormal.sqrMagnitude > 0f)
                {
                    // For the normal of the wall ahead, steer to have a velocity that is perpindicular to it.
                    Vector3 leftVector       = new Vector3(combinedNormal.y + combinedNormal.z, -Steering.YMult * combinedNormal.x, -Steering.ZMult * combinedNormal.x);
                    Vector3 rightVector      = new Vector3((-combinedNormal.y) - combinedNormal.z, Steering.YMult * combinedNormal.x, Steering.ZMult * combinedNormal.x);
                    float   rayLeftDistance  = RaycastDistance(steering, leftVector, raycastDistance);
                    float   rayRightDistance = RaycastDistance(steering, rightVector, raycastDistance);
                    // TODO: Consider updating the logic when approaching a corner.
                    // Currently the unit kind of turns toward the side that they are coming from even if the other turn is shorter.
                    // Case 1: Wall in front, wall on left, wall on right.
                    if (rayLeftDistance < raycastDistance && rayRightDistance < raycastDistance)
                    {
                        // Move towards the left/right wall that is closer. That should be moving away from the corner point.
                        if (rayLeftDistance < rayRightDistance)
                        {
                            return(SteeringUtilities.getForceForDirection(steering, leftVector));
                        }
                        else // rayRightDistance < rayLeftDistance
                        {
                            return(SteeringUtilities.getForceForDirection(steering, rightVector));
                        }
                    }
                    // Case 2: Wall in front, wall on left
                    else if (rayLeftDistance < raycastDistance)
                    {
                        return(SteeringUtilities.getForceForDirection(steering, rightVector));
                    }
                    // Case 3: Wall in front, wall on right
                    else if (rayRightDistance < raycastDistance)
                    {
                        return(SteeringUtilities.getForceForDirection(steering, leftVector));
                    }
                    // Case 4: Wall in front
                    else
                    {
                        // Move towards whichever of left or right is closer to the current velocity
                        Vector3 perpindicularVector = SteeringUtilities.perpindicularComponent(combinedNormal, steering.GetVelocity());
                        // Edge case: the normal is parallel to velocity. In this case, pick one of the two perpindicular vectors at random.
                        if (perpindicularVector == Vector3.zero)
                        {
                            Debug.Log("Exact perpindicular!");
                            int randomSign = Random.value < .5 ? 1 : -1;
                            perpindicularVector = new Vector3((-combinedNormal.y) - combinedNormal.z, Steering.YMult * combinedNormal.x * randomSign, Steering.ZMult * combinedNormal.x * randomSign);
                        }
                        return(SteeringUtilities.getForceForDirection(steering, perpindicularVector));
                    }
                }
                return(Vector3.zero);
            }