示例#1
0
    private void OnTriggerExit(Collider other)
    {
        Rigidbody otherRb  = other.GetComponent <Rigidbody>();
        Vector3   otherPos = other.transform.position;
        float     zdist    = otherPos.z - startPosZ;
        float     xdist    = otherPos.x - rb.transform.position.x;
        //Debug.Log("We hit " + other.name + " at: " + xdist + " (x), " + zdist + " (z).");

        Vector3 blastForce;

        //blastForce.z = 10000 / zdist;
        //blastForce.x = 100 * xdist;
        //blastForce.y = (2500 / zdist) - Mathf.Abs(10 * xdist);
        blastForce.z = 1800 + (zdist * -40);
        blastForce.x = 150 * xdist;
        blastForce.y = 500 + (zdist * -15);

        //Vector3 blastTorque;

        //blastTorque.z = 100;
        //blastTorque.x = 100;
        //blastTorque.y = 100;

        otherRb.AddForce(blastForce);
        //otherRb.AddTorque(blastTorque);

        obstacleMovementScript = other.GetComponent <obstacle_movement>();
        obstacleMovementScript.Blasted();
    }
    public void changeLanes(float frontTimeToCollision, Collider otherFront, float otherFrontVelocity)
    {
        if (currentLane == destinationLane)
        {
            needToCheckCurrentLanePreference = false;
            preferCurrentLaneToLeft          = false;
            preferCurrentLaneToRight         = false;


            rightLaneChangeSafe = false;
            leftLaneChangeSafe  = false;

            Vector3 overlapBoxSize = new Vector3(4f, 0.25f, 10f);
            Vector3 centerPosition = rb.position;

            Collider[] proximityCheck = Physics.OverlapBox(centerPosition, overlapBoxSize, Quaternion.identity, layermask);

            List <Collider> proximityCheckList = new List <Collider>(proximityCheck);

            proximityCheckList.Remove(col);
            proximityCheckList.Remove(otherFront);

            obstacle_movement closeObstacleScript = otherFront.gameObject.GetComponent <obstacle_movement>();
            int frontDestinationLane = closeObstacleScript.destinationLane;
            int frontCurrentlane     = closeObstacleScript.currentLane;

            float leftTimeToCollision  = 50f;
            float rightTimeToCollision = 50f;

            if (frontDestinationLane == frontCurrentlane) // the obstacle in front is not changing lanes
            {
                needToCheckCurrentLanePreference = true;
            }
            else if (frontDestinationLane > frontCurrentlane) // the obstacle in front is changing lanes to the right
            {
                rightTimeToCollision = frontTimeToCollision;
            }
            else if (frontDestinationLane < frontCurrentlane) // the obstalce in front is changing lanes to the left
            {
                leftTimeToCollision = frontTimeToCollision;
            }


            //string myMessage = rb.name + " wants to change lanes, in da house is: ";



            foreach (Collider go in proximityCheckList)
            {
                //if (go != col)
                //{

                closeObstacleScript = go.gameObject.GetComponent <obstacle_movement>();
                int closeDestinationLane = closeObstacleScript.destinationLane;
                int closeCurrentLane     = closeObstacleScript.currentLane;

                //myMessage += go.name + " (destlane = " + closeDestinationLane;

                if (closeDestinationLane == (currentLane + 1))
                {
                    Rigidbody closeRb            = go.attachedRigidbody;
                    float     distanceFromCenter = closeRb.position.z - transform.position.z;

                    if (distanceFromCenter < 2 && distanceFromCenter > -2)
                    {
                        //myMessage += ", right collision hazard is guaranteed";
                        rightTimeToCollision = 0;
                        //Debug.Break();
                    }
                    else
                    {
                        float closeVelocityDifferenceRight = rb.velocity.z - closeRb.velocity.z;

                        if (closeVelocityDifferenceRight != 0)
                        {
                            float newRightTimeToCollision = distanceFromCenter / closeVelocityDifferenceRight;
                            //myMessage += ", right time to collision = " + newRightTimeToCollision;
                            if (newRightTimeToCollision > 0 && newRightTimeToCollision < rightTimeToCollision)
                            {
                                rightTimeToCollision = newRightTimeToCollision;
                                if (needToCheckCurrentLanePreference == true)
                                {
                                    preferCurrentLaneToRight = false;

                                    if (distanceFromCenter > 0)
                                    {
                                        if (closeRb.velocity.z < otherFrontVelocity)
                                        {
                                            preferCurrentLaneToRight = true;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    //else if (distanceFromCenter < 1 && distanceFromCenter > -1)
                    //{
                    //    rightTimeToCollision = 0;
                    //    myMessage += ", right collision hazard is guaranteed";
                    //}
                }
                else if (closeDestinationLane == (currentLane - 1))
                {
                    Rigidbody closeRb            = go.attachedRigidbody;
                    float     distanceFromCenter = closeRb.position.z - transform.position.z;

                    if (distanceFromCenter < 2 && distanceFromCenter > -2)
                    {
                        //myMessage += ", left collision hazard is guaranteed";
                        leftTimeToCollision = 0;
                        //Debug.Break();
                    }
                    else
                    {
                        float closeVelocityDifferenceLeft = rb.velocity.z - closeRb.velocity.z;

                        if (closeVelocityDifferenceLeft != 0)
                        {
                            float newLeftTimeToCollision = distanceFromCenter / closeVelocityDifferenceLeft;
                            //myMessage += ", left time to collision = " + newLeftTimeToCollision;
                            if (newLeftTimeToCollision > 0 && newLeftTimeToCollision < leftTimeToCollision)
                            {
                                leftTimeToCollision = newLeftTimeToCollision;
                                if (needToCheckCurrentLanePreference == true)
                                {
                                    preferCurrentLaneToLeft = false;

                                    if (distanceFromCenter > 0)
                                    {
                                        if (closeRb.velocity.z < otherFrontVelocity)
                                        {
                                            preferCurrentLaneToLeft = true;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                else if (closeDestinationLane == currentLane && closeDestinationLane != closeCurrentLane)
                {
                    if (closeDestinationLane > closeCurrentLane)     // then they must be changing lanes to the right
                    {
                        Rigidbody closeRb            = go.attachedRigidbody;
                        float     distanceFromCenter = closeRb.position.z - transform.position.z;

                        if (distanceFromCenter < 1 && distanceFromCenter > -1)
                        {
                            leftTimeToCollision = 0;
                        }
                        else
                        {
                            float closeVelocityDifferenceLeft = rb.velocity.z - closeRb.velocity.z;

                            if (closeVelocityDifferenceLeft != 0)
                            {
                                float newLeftTimeToCollision = distanceFromCenter / closeVelocityDifferenceLeft;
                                if (newLeftTimeToCollision > 0 && newLeftTimeToCollision < leftTimeToCollision)
                                {
                                    leftTimeToCollision = newLeftTimeToCollision;
                                }
                            }
                        }
                    }
                    else if (closeDestinationLane < closeCurrentLane)     // then they must be changing lanes to the left
                    {
                        Rigidbody closeRb            = go.attachedRigidbody;
                        float     distanceFromCenter = closeRb.position.z - transform.position.z;

                        if (distanceFromCenter < 1 && distanceFromCenter > -1)
                        {
                            rightTimeToCollision = 0;
                        }
                        else
                        {
                            float closeVelocityDifferenceRight = rb.velocity.z - closeRb.velocity.z;
                            if (closeVelocityDifferenceRight != 0)
                            {
                                float newRightTimeToCollision = distanceFromCenter / closeVelocityDifferenceRight;
                                if (newRightTimeToCollision > 0 && newRightTimeToCollision < rightTimeToCollision)
                                {
                                    rightTimeToCollision = newRightTimeToCollision;
                                }
                            }
                        }
                    }
                }


                //myMessage += "); ";

                //}
                //Debug.Log(rb.name + " wants to change lanes, " + go.name + " in da house");
            }

            //Debug.Log(myMessage);
            //Debug.Break();


            if (currentLane != 3)
            {
                if (rightTimeToCollision < 0)
                {
                    rightLaneChangeSafe = true;
                }
                else if (rightTimeToCollision > 2f)
                {
                    if (preferCurrentLaneToRight == false)
                    {
                        rightLaneChangeSafe = true;
                    }
                    else
                    {
                        //Debug.Log(rb.name + " likes current lane more than right.");
                    }

                    /*
                     * if (rightTimeToCollision > frontTimeToCollision)
                     * {
                     *  rightLaneChangeSafe = true;
                     * }
                     * else
                     * {
                     *  Debug.Log(rb.name + " likes current lane more than right.");
                     *  //Debug.Break();
                     * }
                     */
                }
            }

            if (currentLane != -3)
            {
                if (leftTimeToCollision < 0)
                {
                    leftLaneChangeSafe = true;
                }
                else if (leftTimeToCollision > 2f)
                {
                    if (preferCurrentLaneToLeft == false)
                    {
                        leftLaneChangeSafe = true;
                    }
                    else
                    {
                        //Debug.Log(rb.name + " likes current lane more than left.");
                    }

                    /*
                     * if (leftTimeToCollision > frontTimeToCollision)
                     * {
                     *  leftLaneChangeSafe = true;
                     * }
                     * else
                     * {
                     *  Debug.Log(rb.name + " likes current lane more than left.");
                     *  //Debug.Break();
                     * }
                     */
                }



                /*
                 * if (leftTimeToCollision < 0 || leftTimeToCollision > 2f)
                 * {
                 *  leftLaneChangeSafe = true;
                 * }
                 */
            }

            if (leftLaneChangeSafe == false && rightLaneChangeSafe == false)
            {
                //Debug.Log(rb.name + " has no safe lane to change to!");
                //Debug.Break();
            }

            if (rightLaneChangeSafe == true)
            {
                if (leftLaneChangeSafe == false)
                {
                    destinationLane++;
                    rb.AddForce(75, 0, 0);

                    closeSensorScript.sensorResizeX = 1.5f;
                    closeSensorScript.sensorPosX    = 0.25f;

                    //GetComponent<Renderer>().material = turnSignal;
                    material_chooser.leftOrRight = 1;
                }
                else
                {
                    if (rightTimeToCollision > leftTimeToCollision)
                    {
                        destinationLane++;
                        rb.AddForce(75, 0, 0);

                        closeSensorScript.sensorResizeX = 1.5f;
                        closeSensorScript.sensorPosX    = 0.25f;

                        //GetComponent<Renderer>().material = turnSignal;
                        material_chooser.leftOrRight = 1;
                    }
                    else if (rightTimeToCollision != leftTimeToCollision)
                    {
                        destinationLane--;
                        rb.AddForce(-75, 0, 0);

                        closeSensorScript.sensorResizeX = 1.5f;
                        closeSensorScript.sensorPosX    = -0.25f;

                        //GetComponent<Renderer>().material = turnSignal;
                        material_chooser.leftOrRight = -1;
                    }
                    else
                    {
                        int leftOrRight = Random.Range(1, 3);
                        if (leftOrRight == 1)
                        {
                            destinationLane--;
                            rb.AddForce(-75, 0, 0);

                            closeSensorScript.sensorResizeX = 1.5f;
                            closeSensorScript.sensorPosX    = -0.25f;

                            //GetComponent<Renderer>().material = turnSignal;
                            material_chooser.leftOrRight = -1;
                        }
                        else
                        {
                            destinationLane++;
                            rb.AddForce(75, 0, 0);

                            closeSensorScript.sensorResizeX = 1.5f;
                            closeSensorScript.sensorPosX    = 0.25f;

                            GetComponent <Renderer>().material = turnSignal;
                            material_chooser.leftOrRight       = 1;
                        }
                    }

                    /*
                     * int leftOrRight = Random.Range(0, 2);
                     * if (leftOrRight == 0)
                     * {
                     *  Debug.Log(rb.name + "went to to a tossup and chose left.");
                     *  destinationLane--;
                     *  rb.AddForce(-75, 0, 0);
                     * }
                     * else
                     * {
                     *  Debug.Log(rb.name + "went to to a tossup and chose right.");
                     *  destinationLane++;
                     *  rb.AddForce(75, 0, 0);
                     *
                     * }
                     */
                }
                //Debug.Break();
            }
            else if (leftLaneChangeSafe == true)
            {
                destinationLane--;
                rb.AddForce(-75, 0, 0);

                //GetComponent<Renderer>().material = turnSignal;
                material_chooser.leftOrRight = -1;
                //Debug.Break();
            }
        }
    }