コード例 #1
0
    public void CollisionStay(PhysXCollision collision)
    {
        // float penCoefficientA = (penForMaxImpulseScale - penForUnitImpulseScale * maxImpulseScale) / (penForUnitImpulseScale * penForUnitImpulseScale * penForMaxImpulseScale - penForUnitImpulseScale * penForMaxImpulseScale * penForMaxImpulseScale);
        // float penCoefficientB = maxImpulseScale / penForMaxImpulseScale - penCoefficientA * penForMaxImpulseScale;
        if (collision.rigidBody != null)
        {
            velocity = (rigidBody.velocity - collision.rigidBody.velocity).magnitude;
        }
        else
        {
            velocity = rigidBody.velocity.magnitude;
        }
        velocity -= velocityOffset;
        if (velocity < 0)
        {
            velocity = 0;
        }


        float penExp = velocityScale / velocity;

        if (penExp > maxPenExp)
        {
            penExp = maxPenExp;
        }

        float penCoefficient = 1 / Mathf.Pow(penForUnitImpulseScale, penExp);

        for (int i = 0; i < collision.contactCount; i++)
        {
            PhysXContactPoint contactPoint = collision.GetContact(i);

            if (contactPoint.ownShape == collider.shape)
            {
                float penetration = -contactPoint.separation;
                if (penetration < 0)
                {
                    penetration = 0;
                }

                //Debug.Log("penetration: " + penetration);

                Vector3 impulse = contactPoint.impulse;
                // float impulseScale = penCoefficientA * penetration * penetration + penCoefficientB * penetration;
                float impulseScale = penCoefficient * Mathf.Pow(penetration, penExp);
                if (impulseScale > maxImpulseScale)
                {
                    impulseScale = maxImpulseScale;
                }
                impulse *= impulseScale;

                rigidBody.AddGhostImpulse(impulse, contactPoint.point);
            }
        }
    }
コード例 #2
0
    public void  CollisionEnter(PhysXCollision collision)
    {
        // Debug.LogError(collision.gameObject);

        Vector3 impactNormal = collision.GetContact(0).normal;

        // if we are the true projectile, then deal with game altering stuff like damage n that
        if (explosionForce > 0)
        {
            Squishing hitMeshSquisher = collision.gameObject.GetComponentInParent <Squishing>();
            if (hitMeshSquisher != null)
            {
                Vector3 explosionPoint = collision.GetContact(0).point + impactNormal * explosionOffset;
                hitMeshSquisher.ExplodeMeshAt(explosionPoint, explosionForce);
            }
        }

        Vector3 hitPoint           = collision.GetContact(0).point;
        VehicleHealthManager hitVm = collision.gameObject.GetComponentInParent <VehicleHealthManager>();

        if (hitVm != null)
        {
            if (hitVm.teamId == weaponDamageDetails.sourceTeamId)
            {
                Destroy(gameObject);
            }
        }
        if (isTrueProjectile)
        {
            DamageCollisionHandler(hitVm, hitPoint);
        }
        VisualCollisionHandler(impactNormal, hitVm != null);

        //   pooledObject.Finish();
        Destroy(gameObject);
    }
コード例 #3
0
    public void CollisionEnter(PhysXCollision collision)
    {
        // Debug.Log("crashed into: " + collision.gameObject);
        float dSpeed = myRb.velocity.magnitude;

        float impulse = collision.impulse.magnitude;

        if (collision.rigidBody != null)
        {
            dSpeed = (myRb.velocity - collision.rigidBody.velocity).magnitude;
        }
        if (myPhotonView.IsMine && collision.contactCount > 0 && dSpeed > 1.5 && collisionTimer < 0)
        {
            collisionTimer = maxCollisionRate;
            Vector3 collisionNormal = collision.GetContact(0).normal;
            Vector3 collisionForce  = collision.impulse;
            if (Vector3.Dot(collisionForce, collisionNormal) < 0)
            {
                collisionForce = -collisionForce;
            }
            collisionForce /= Time.fixedDeltaTime;
            collisionForce  = transform.InverseTransformDirection(collisionForce);

            VehicleHealthManager otherVehicleManager = collision.gameObject.GetComponent <VehicleHealthManager>();

            Vector3 collisionPoint = Vector3.zero;
            for (int i = 0; i < collision.contactCount; i++)
            {
                collisionPoint += collision.GetContact(i).point;
            }
            collisionPoint /= collision.contactCount;

            Vector3 contactDirection = transform.InverseTransformPoint(collisionPoint);
            float   damage           = CalculateCollisionDamage(collisionForce, contactDirection, otherVehicleManager != null);

            // instantiate damage sound over network
            if ((damage > crashSoundsSmallDamageThreshold || (otherVehicleManager != null)) && timeSinceLastRam > 0.25f)
            {
                PlayDamageSoundNetwork(damage);
            }

            damage = damage / rammingDamageResistance;

            if (myPhotonView.IsMine && hasHotPotatoManager && otherVehicleManager != null && timeSinceLastRam > 0.25f)
            {
                if (collisionNpv.GetDriverID() == PhotonNetwork.LocalPlayer.ActorNumber || collisionNpv.GetGunnerID() == PhotonNetwork.LocalPlayer.ActorNumber)
                {
                    // Debug.LogError("Slow down should happen");
                    hotPotatoManager.SlowedCollision();
                }
                if (collisionSparks != null)
                {
                    GameObject a = Instantiate(collisionSparks, collisionPoint, Quaternion.identity);
                    a.transform.parent = transform;
                }

                if (collisionNpv != null && !collisionNpv.botDriver)
                {
                    if (damage > 4)
                    {
                        driverCrashDetector.CrashCollisionCamera(collision, false);
                    }
                    else
                    {
                        driverCrashDetector.CrashCollisionCamera(collision, true);
                    }
                }
            }

            if (damage > 5)
            {
                if (otherVehicleManager != null)
                {
                    if (otherVehicleManager != null)
                    {
                        damage *= otherVehicleManager.rammingDamageMultiplier;
                    }
                    Weapon.WeaponDamageDetails rammingDetails = otherVehicleManager.rammingDetails;

                    rammingDetails.damage = damage;
                    if (markedByTeams.Contains(rammingDetails.sourceTeamId))
                    {
                        rammingDetails.damage *= markedTeamDamageIncrease;
                    }

                    TakeDamage(rammingDetails);
                }
                else
                {
                    TakeDamage(damage);
                }
            }
        }
        if (collision.rigidBody != null)
        {
            timeSinceLastRam = 0f;
        }
    }
コード例 #4
0
    public void CollisionStay(PhysXCollision collision)
    {
        if (collision.contactCount > 0 && collision.GetContact(0).separation < -minPenetration)
        {
            if ((collision.rigidBody == null || collision.rigidBody.mass >= minDeformationMass) &&
                !collision.collider.gameObject.CompareTag("DustGround"))
            {
                meshDeformationMarker.Begin();

                bool isInconvenient = collision.collider is PhysXMeshCollider && !((PhysXMeshCollider)collision.collider).convex;

                Vector3 collisionSurfaceNormal = Vector3.zero;
                Vector3 collisionSurfacePoint  = Vector3.zero;

                for (int i = 0; i < collision.contactCount; i++)
                {
                    PhysXContactPoint contactPoint     = collision.GetContact(i);
                    float             impulseMagnitude = contactPoint.impulse.magnitude;

                    collisionSurfaceNormal += contactPoint.normal;
                    collisionSurfacePoint  += contactPoint.point;
                }



                collisionSurfaceNormal /= collision.contactCount;
                collisionSurfacePoint  /= collision.contactCount;

                collisionSurfaceNormal = transform.InverseTransformDirection(collisionSurfaceNormal);
                collisionSurfacePoint  = transform.InverseTransformPoint(collisionSurfacePoint);

                gizmoSurfaceNormal = collisionSurfaceNormal;
                gizmoSurfacePoint  = collisionSurfacePoint;

                Vector3    oldPosition = collision.body.position;
                Quaternion oldRotation = collision.body.rotation;
                collision.body.position = transform.InverseTransformPoint(collision.body.position);
                collision.body.rotation = Quaternion.Inverse(transform.rotation) * collision.body.rotation;

                VertexGroup[] groups = meshGraph.groups;
                for (int i = 0; i < groups.Length; i++)
                {
                    VertexGroup current = groups[i];
                    Vector3     vertex  = current.pos;

                    if (IsBeyondCollisionSurface(collisionSurfaceNormal, collisionSurfacePoint, vertex))
                    {
                        if (isInconvenient || collision.collider.ClosestPoint(vertex) == vertex)
                        {
                            Vector3 deformation = DeformationFromCollisionSurface(collisionSurfaceNormal, collisionSurfacePoint, vertex);

                            // if (addNoise) deformation *= Random.value * multiplier + addition;

                            current.MoveBy(vertices, deformation, false);
                            current.SetWasMoved(teamId, true);

                            if (!current.GetEnqueued(teamId))
                            {
                                vertexQueue.Enqueue(current);
                                current.SetEnqueued(teamId, true);
                                // Debug.Log("Vertex group " + current.vertexIndices[0] + " enqueued due to collision");
                            }
                        }
                    }
                }

                collision.body.position = oldPosition;
                collision.body.rotation = oldRotation;

                dissipationNeeded = true;

                meshDeformationMarker.End();
            }
        }
    }