Пример #1
0
    Init(scr_Node m_node)
    {
        m_target         = m_node;
        m_state          = DOGPHASE.Idle;
        m_directionIndex = DOGDIRECTION.None;

        return;
    }
Пример #2
0
    InputController()
    {
        // UP
        if (Input.GetKeyDown(KeyCode.W))
        {
            m_directionIndex = DOGDIRECTION.Up;
            m_anim.SetInteger("DirectionIndex", (int)DOGDIRECTION.Up);
            m_state = DOGPHASE.Moving;
            return;
        }

        // DOWN
        if (Input.GetKeyDown(KeyCode.S))
        {
            m_directionIndex = DOGDIRECTION.Down;
            m_anim.SetInteger("DirectionIndex", (int)DOGDIRECTION.Down);
            m_state = DOGPHASE.Moving;
            return;
        }

        // RIGHT
        if (Input.GetKeyDown(KeyCode.D))
        {
            m_directionIndex = DOGDIRECTION.Right;
            m_anim.SetInteger("DirectionIndex", (int)DOGDIRECTION.Right);
            m_state = DOGPHASE.Moving;
            return;
        }

        // LEFT
        if (Input.GetKeyDown(KeyCode.A))
        {
            m_directionIndex = DOGDIRECTION.Left;
            m_anim.SetInteger("DirectionIndex", (int)DOGDIRECTION.Left);
            m_state = DOGPHASE.Moving;
            return;
        }
    }
Пример #3
0
    NodeCollision()
    {
        //revisar si el nodo esta explorado
        if (m_target.m_explored == false)
        {
            Collider[] objects = Physics.OverlapSphere(m_target.POSITION, m_radio);
            foreach (Collider collider in objects)
            {
                float distance = Vector3.Distance(collider.transform.position, transform.position);
                Color tmp      = collider.GetComponent <SpriteRenderer>().color;
                if (distance < m_radio * 0.4f)
                {
                    tmp.a = 1;
                }
                else if (distance < m_radio * 0.6f)
                {
                    tmp.a += 0.6f;
                }
                else if (distance < m_radio * 0.9f)
                {
                    tmp.a += 0.3f;
                }
                collider.GetComponent <SpriteRenderer>().color = tmp;
            }
            m_target.m_explored = true;
        }

        if (m_target.NODETYPE == NODE_TYPE.kHouse)
        {
            scr_gameMaster.GetSingleton().Win();
        }

        switch (m_directionIndex)
        {
        case DOGDIRECTION.Up:
            if (m_target.UP == null)
            {
                m_state = DOGPHASE.Idle;
                return;
            }

            if (m_target.UP.NODETYPE == NODE_TYPE.kStreet ||
                m_target.UP.NODETYPE == NODE_TYPE.kHouse)
            {
                m_target = m_target.UP;
                return;
            }
            else
            {
                m_state = DOGPHASE.Idle;
                return;
            }

        case DOGDIRECTION.Right:
            if (m_target.RIGHT == null)
            {
                m_state = DOGPHASE.Idle;
                return;
            }

            if (m_target.RIGHT.NODETYPE == NODE_TYPE.kStreet ||
                m_target.RIGHT.NODETYPE == NODE_TYPE.kHouse)
            {
                m_target = m_target.RIGHT;
                return;
            }
            else
            {
                m_state = DOGPHASE.Idle;
                return;
            }

        case DOGDIRECTION.Down:
            if (m_target.DOWN == null)
            {
                m_state = DOGPHASE.Idle;
                return;
            }

            if (m_target.DOWN.NODETYPE == NODE_TYPE.kStreet ||
                m_target.DOWN.NODETYPE == NODE_TYPE.kHouse)
            {
                m_target = m_target.DOWN;
                return;
            }
            else
            {
                m_state = DOGPHASE.Idle;
                return;
            }

        case DOGDIRECTION.Left:
            if (m_target.LEFT == null)
            {
                m_state = DOGPHASE.Idle;
                return;
            }

            if (m_target.LEFT.NODETYPE == NODE_TYPE.kStreet ||
                m_target.LEFT.NODETYPE == NODE_TYPE.kHouse)
            {
                m_target = m_target.LEFT;
                return;
            }
            else
            {
                m_state = DOGPHASE.Idle;
                return;
            }

        default:
            m_state = DOGPHASE.Idle;
            return;
        }
    }