private void Start()
    {
        Damagable  damagable = GetComponent <Damagable>();
        BlockLevel level     = FindObjectOfType <BlockLevel>();

        Audible audible = GetComponent <Audible>();

        damagable.RegisterOnKilled((d) => audible.playSound());
        damagable.RegisterOnKilled((d) => level.removeBlock(d));

        Animatable animatable = GetComponent <Animatable>();

        damagable.RegisterOnDamaged((healthRemaining) => animatable.changeSprite(healthRemaining));
    }
Пример #2
0
    void OnTriggerEnter(Collider collider)
    {
        Audible audible = collider.GetComponent <Audible>();

        if (audible)
        {
            audible.SoundEvent("Footstep", transform.position);
        }

        Transmissible t = collider.GetComponent <Transmissible>();

        if (t && t.type.audibleType && t.progress == 1 && m_player.isGrounded == true && m_player.inFluid == false)
        {
            Audible.SoundEvent(t.type.audibleType, "Footstep", transform.position);
        }
    }
Пример #3
0
    // Update is called once per frame
    void FixedUpdate()
    {
        bool prevGrounded = m_grounded;

        m_grounded = false;
        m_ground   = null;

        // Check if we're floating in something
        Collider[] colliders = Physics.OverlapSphere(m_rigidbody.position, m_collider.radius, m_groundMask);

        foreach (var c in colliders)
        {
            Transmissible t = c.GetComponent <Transmissible>();
            if (t && t.progress == 1 && t.type.bouyancy > 0)
            {
                m_grounded     = true;
                m_ground       = t.gameObject;
                m_groundNormal = Vector3.up;
            }
        }

        if (m_grounded == false)
        {
            RaycastHit[] hits = Physics.SphereCastAll(m_rigidbody.position,
                                                      m_collider.radius - 0.01f,
                                                      Vector3.down,
                                                      m_collider.height / 2 - m_collider.radius + 0.02f,
                                                      m_groundMask,
                                                      QueryTriggerInteraction.Ignore);

            foreach (RaycastHit hit in hits)
            {
                if (hit.normal.y > 0.5f)
                {
                    float distanceFromRim = Mathf.Abs((m_rigidbody.position.y - m_collider.height / 2) - hit.point.y);

                    distanceFromRimDebug = distanceFromRim;

                    if (distanceFromRim < 0.25f)
                    {
                        m_grounded     = true;
                        m_ground       = hit.collider.gameObject;
                        m_groundNormal = hit.normal;
                    }
                    break;
                }
            }
        }

        Vector2 localDir = m_input.movement;

        // TODO: Check grounded state

        Vector3 force = (Camera.main.transform.right * localDir.x + Camera.main.transform.forward * localDir.y);

        if (m_stunTimer > 0)
        {
            m_stunTimer -= Time.deltaTime;
            force.x      = 0;
            force.z      = 0;
        }

        force.y = 0;

        if (force.magnitude > 0)
        {
            force.Normalize();

            bool abyss = false;
            if (m_fallPreventionEnabled)
            {
                RaycastHit[] hits = Physics.SphereCastAll(m_rigidbody.position + force * m_collider.radius * 2, m_collider.radius, Vector3.down, 100, m_groundMask);

                abyss = true;
                foreach (RaycastHit hit in hits)
                {
                    // Solid object or bouyand object
                    Transmissible t = hit.collider.GetComponent <Transmissible>();
                    if (t)
                    {
                        if ((t.type.hasCollisions == true || (t.type.bouyancy > 0 && t.progress == 1)))
                        {
                            abyss = false;
                            break;
                        }
                    }
                    else if (hit.collider.isTrigger == false)
                    {
                        abyss = false;
                        break;
                    }
                }
            }

            if (m_grounded)
            {
                Vector3 right = Vector3.Cross(force, Vector3.up);
                force = Vector3.Cross(m_groundNormal, right);
            }

            if (abyss)
            {
                force = Vector3.zero;
            }

            m_rigidbody.AddForce(force * m_maxForce);
        }

        Vector3 velocity = m_rigidbody.velocity;
        float   vy       = velocity.y;

        velocity.y = 0;


        if (velocity.magnitude > m_maxVelocity)
        {
            velocity = velocity.normalized * m_maxVelocity;
        }

        //m_rigidbody.drag = velocity.magnitude / m_drag;

        if (velocity.magnitude > 0.25f && m_stunTimer <= 0)
        {
            m_angle = Mathf.Atan2(velocity.x, velocity.z) * Mathf.Rad2Deg;
        }

        transform.localEulerAngles = new Vector3(0, m_angle, 0);

        velocity *= m_friction;

        if (m_grounded && m_ground)
        {
            if (prevGrounded == false)
            {
                Audible a = m_ground.GetComponent <Audible>();
                if (a)
                {
                    a.SoundEvent("Land", transform.position);
                }

                Transmissible t = m_ground.GetComponent <Transmissible>();
                if (t && t.type.audibleType && t.progress == 1)
                {
                    Audible.SoundEvent(t.type.audibleType, "Land", transform.position);
                }
            }

            if (inFluid)
            {
                if (m_input.wasJumpPressed)
                {
                    velocity.y = Mathf.Lerp(velocity.y, m_waterJumpSpeed, 0.25f);
                }
                else
                {
                    velocity.y = vy;
                }

                m_animator.SetFloat("Speed", 0.0f);
                m_animator.SetFloat("Speed2", 0.1f);
            }
            else
            {
                velocity.y = 0;

                if (m_input.wasJumpPressed)
                {
                    m_grounded = false;
                    // TODO: check water
                    velocity.y = m_jumpSpeed;
                    m_animator.SetTrigger("Jump");
                }

                m_animator.SetFloat("Speed", velocity.magnitude / m_maxVelocity);
                m_animator.SetFloat("Speed2", 0.1f + (velocity.magnitude / m_maxVelocity) * 1.5f);
            }
        }
        else
        {
            velocity.y = vy;

            m_animator.SetFloat("Speed", 0.5f);
            m_animator.SetFloat("Speed2", 0.1f);
        }

        m_animator.SetFloat("YSpeed", velocity.y);
        m_animator.SetBool("Grounded", m_grounded && !inFluid);
        m_animator.SetBool("InFluid", inFluid);
        m_rigidbody.velocity = velocity;
    }