예제 #1
0
    void OnCollisionEnter2D(Collision2D collision)
    {
        foreach (ContactPoint2D contact in collision.contacts)
            Debug.DrawRay (contact.point, contact.normal, Color.white);
        foreach (ContactPoint2D contact in collision.contacts)
        {
            if (collision.gameObject.GetComponent<Spring>() != null) {
                //must initiate from here to avoid some race condition
                collision.gameObject.GetComponent<Spring>().SpringCollide(gameObject);
                return;
            }
            if (collision.gameObject.GetComponent<Treadmill>() != null)
                return;
            if (collision.gameObject.GetComponent<Death>() != null)
                return;
            if (collision.gameObject.GetComponent<BounceAbsorption>() != null)
                absorptionFactor = collision.gameObject.GetComponent<BounceAbsorption>().absorptionFactor;
            else
                absorptionFactor = 0f;

            //more hacky code to get spiderball with moving platform working
            if (spiderball && (collision.collider.GetComponent<MovingPlatform>() != null ||
                               (collision.collider.transform.childCount > 0 &&
             				    collision.collider.transform.GetChild(0).GetComponent<MovingPlatform>() != null)))
            {
                spiderOnMovingPlatform = true;
                platformParent = collision.collider.transform;
            }

            if (Mathf.Abs(Vector2.Angle(-Physics2D.gravity, contact.normal)) < groundedThresholdAngle)
                grounded = true;

            //Determine if ball should deform
            float velocityToCheck = boostThresholdVelocity;
            if(wasGrounded)
                velocityToCheck += groundedThresholdBonus;

            if(Mathf.Abs(Vector2.Angle(contact.normal,-Physics2D.gravity)) <= boostThresholdAngle
               && Mathf.Abs (Vector2.Dot (collision.relativeVelocity,contact.normal)) > velocityToCheck
               && dState == DeformationState.Normal)
            {
                dState = DeformationState.Deforming;
                Vector2 collisionNormal = contact.normal;
                Vector2 originalVelocity = -prevVelocity;
                float originalAngularVelocity = prevAngularVelocity;
                this.rigidbody2D.isKinematic = true;//Disable normal physics
                scaleObject = new GameObject("ScaleObject");//Create a gameObject to scale the ball along an axis
                Quaternion rot = Quaternion.LookRotation(collisionNormal);//Rotate the gameObject so that z+ is towards the collision normal
                scaleObject.transform.rotation = rot;

                scaleObject.transform.position = contact.point;//Center the scaleObject at the contact point so that the ball scales from one end

                //Debug.Log ("deforming");
                //deforming onto a moving platform logic - in this case, the scale object should be child of platform
                //if (collision.gameObject.GetComponent<MovingPlatform>() != null)
                //	scaleObject.transform.parent = collision.gameObject.transform;
                if ((onMovingPlatform && Vector2.Angle(contact.normal, -Physics2D.gravity) <= 5f) || spiderOnMovingPlatform)	//odd angles cause screwiness
                {
                    //Debug.Log ("reparenting scale object");
                    scaleObject.transform.parent = platformParent;
                }
                else if (collision.gameObject.transform.childCount > 0
                         && collision.gameObject.transform.GetChild(0).GetComponent<MovingPlatform>() != null
                           && Vector2.Angle(contact.normal, -Physics2D.gravity) <= 2f)	//super-hard-coding
                {
                    //this is cheating a bit - relying on a straight collision with a horizontal platform
                    //we probably won't have any exeptional cases in the game, though, so it should be fine..(?)
                    scaleObject.transform.parent = collision.gameObject.transform;
                }

                //Parent the ball to the scaleObject
                transform.parent.parent = scaleObject.transform;
                originalScale = scaleObject.transform.localScale;
                deformTimer = 0.0f;

                originalMagnitude = originalVelocity.magnitude;
                //Calculate the reflection of originalVelocity about the collision normal to get the ball's new velocity vector
                Vector2 reflection = (2 * Vector2.Dot(originalVelocity,collisionNormal) * collisionNormal - originalVelocity);
                //Create a normalized vector representing the difference between the reflection and the original velocity
                //Vector2 bounceModifier = new Vector2(originalVelocity.x-reflection.x, -originalVelocity.y-reflection.y);
                //bounceModifier.Normalize();

                //Set the rigidbody velocity to the reflection vector and modify it to make the collision inelastic
                //outVelocity = reflection + bounceModifier/bounciness;
                outVelocity = reflection * bounciness * (1f-absorptionFactor);

                //Decrease/Reverse the angular velocity based on whether the ball changed direction on the x axis
                float angleMod = 0.5f*Mathf.Sign(-originalVelocity.x)*Mathf.Sign (outVelocity.x);

                outAngularVelocity = originalAngularVelocity*angleMod;
                //Set the scaleChange based on collision force
                deformScaleChange = Mathf.Clamp(Mathf.Abs (Vector2.Dot (collision.relativeVelocity,contact.normal))*deformScaleFactor,0.2f, 0.8f);
                deformTime = Mathf.Clamp(Mathf.Abs (Vector2.Dot (collision.relativeVelocity, contact.normal)) * deformTimeFactor, 0.02f, 0.08f);
                return;
            }
            //else if (collision.gameObject.GetComponent<MovingPlatform>() != null)
            //	transform.parent.parent = collision.gameObject.transform;	//if we aren't deforming, just do normal parenting
            //else if (onMovingPlatform)
            //	transform.parent.parent = platformParent;	//if we aren't deforming, just do normal parenting

        }
        hasContact = true;
    }
예제 #2
0
 public void ForceUndoDeformation()
 {
     if (dState == DeformationState.Deforming || dState == DeformationState.Reforming)
     {
         this.transform.parent.parent = null;
         GameObject.Destroy (scaleObject);
         this.transform.parent.localScale = Vector3.one;
         this.rigidbody2D.isKinematic = false;
     }
     dState = DeformationState.Normal;
 }
예제 #3
0
    /*
    private void recordButtonDelay()
    {
        timeSinceJump += Time.fixedDeltaTime;
        timeSinceLeft += Time.fixedDeltaTime;
        timeSinceRight += Time.fixedDeltaTime;

        if(Input.GetButtonDown("Jump"))
            timeSinceJump = 0;
        if(Input.GetButtonDown("Left"))
            timeSinceLeft = 0;
        if(Input.GetButtonDown("Right"))
            timeSinceRight = 0;
    }
    */
    void FixedUpdate()
    {
        if (grounded)
            wasGrounded = true;
        float h = Input.GetAxis ("Horizontal");

        //locks the player
        if (playerLock == true) {
            h = 0;
            jumpTimer = 0;
        }

        if(dState == DeformationState.Normal)
        {
            ListenForJump ();
            if(h != 0)
            {
                //recordButtonDelay();
                //translational movement
                if (!spiderball && !balloonActive) {
                    Vector2 relativeRight = new Vector2(-Physics2D.gravity.y, Physics2D.gravity.x).normalized;
                    if(Mathf.Sign(h) != Mathf.Sign (this.rigidbody2D.velocity.x))
                    {
                        this.rigidbody2D.AddForce(relativeRight * h * moveForce * translationStoppingMultiplier);
                    }
                    else if (Mathf.Abs(this.rigidbody2D.velocity.x) < maxPlayerGeneratedSpeed)
                    {
                        this.rigidbody2D.AddForce(relativeRight * h * moveForce);
                    }
                }
                //rotational movement
                if (Mathf.Sign (h) == Mathf.Sign (rigidbody2D.angularVelocity) && !hasContact)
                {
                    this.rigidbody2D.AddTorque(-h * moveTorque * rotationStoppingMultiplier);
                }
                else if(Mathf.Abs (this.rigidbody2D.angularVelocity) < maxAngularVelocity && !hasContact)
                {
                    this.rigidbody2D.AddTorque(-h * moveTorque);
                }
            }
        }
        else if(dState == DeformationState.Deforming)
        {// Scale ball down along z axis of scale object at deformSpeed until it's scale has changed more than the intended change
            //recordButtonDelay();
            checkJumpBoosted();

            if(deformTimer < deformTime)
            {
                deformTimer += Time.deltaTime;
                float compressScale = deformScaleChange * Mathf.Clamp (deformTimer / deformTime, 0.0f, 1.0f);
                //scaleObject.transform.localScale = new Vector3(scaleObject.transform.localScale.x,
                //                                               scaleObject.transform.localScale.y,
                //                                               1.0f - compressScale);
                scaleObject.transform.localScale = new Vector3(originalScale.x, originalScale.y, originalScale.z * (1.0f - compressScale));
            }else{
                dState = DeformationState.Reforming;
                deformTimer = 0.0f;
                //baseScale = scaleObject.transform.localScale.z;
                baseScale = scaleObject.transform.localScale;
            }
        }
        else if(dState == DeformationState.Reforming)
        {//Scale ball up along z axis of scale object at deformSpeed until it's scale has changed more than the intended change

            //recordButtonDelay();
            checkJumpBoosted();
            if(deformTimer < deformTime)
            {
                deformTimer += Time.deltaTime;
                float compressScale = deformScaleChange * Mathf.Clamp (deformTimer / deformTime, 0.0f, 1.0f);
                //scaleObject.transform.localScale = new Vector3(scaleObject.transform.localScale.x,
                //                                               scaleObject.transform.localScale.y,
                //                                               baseScale + compressScale);
                scaleObject.transform.localScale = baseScale + new Vector3(0f, 0f, originalScale.z * compressScale);
            }else{
                //Unparent from scaleObject and destroy scaleObject
                this.transform.parent.parent = null;
                GameObject.Destroy (scaleObject);
                this.transform.parent.localScale = Vector3.one;

                this.rigidbody2D.isKinematic = false;//Re-enabled rigidbody physics
                jumpLastTime = Time.timeSinceLevelLoad;

                if(jumpBoosted)
                {
                    jumpBoosted = false;
                    //timeSinceJump = boostForgiveness;
                    //timeSinceLeft = boostForgiveness;
                    //timeSinceRight = boostForgiveness;
                    //Debug.Log ("Boosted bounce");
                    outVelocity = outVelocity.normalized * originalMagnitude * boostedBounciness * (1f-absorptionFactor);

                    if(outVelocity.magnitude < (jumpForce/this.rigidbody2D.mass)*Time.fixedDeltaTime)
                    {
                        //Debug.Log("Back to original height");
                        outVelocity.Normalize();
                        outVelocity*=(jumpForce/this.rigidbody2D.mass)*Time.fixedDeltaTime;
                    }
                }
                if(jumpDepressed)
                {
                    jumpDepressed = false;
                    outVelocity = outVelocity.normalized*originalMagnitude*depressedBounciness * (1f-absorptionFactor);
                }
                if (GetComponent<Spiderball>().enabled)
                {
                    outVelocity = Vector2.zero;	//super sticky!
                }

                this.rigidbody2D.angularVelocity = outAngularVelocity;
                this.rigidbody2D.velocity = outVelocity;
                dState = DeformationState.Reformed;
                GetComponent<PlayerSoundManager>().PlaySound("Bounce");
            }
        }
        else if(dState == DeformationState.Reformed)
        {//Allow an extra tick before the ball is allowed to deform again
            dState = DeformationState.Normal;
        }

        if (!spiderball && spiderOnMovingPlatform)
        {
            spiderOnMovingPlatform = false;
        }
        if ((onMovingPlatform || spiderOnMovingPlatform) && transform.parent.parent == null)
            transform.parent.parent = platformParent;
        else if (!onMovingPlatform && !spiderOnMovingPlatform && platformParent != null)
        {
            transform.parent.parent = null;
            platformParent = null;
        }

        grounded = false;
        jumpTimer += Time.fixedDeltaTime;
        prevVelocity = this.rigidbody2D.velocity;
        prevAngularVelocity = this.rigidbody2D.angularVelocity;
        //Debug.Log (rigidbody2D.velocity.y);
    }