Пример #1
0
    void Initialize()
    {
        gameObject.name = Hero.Name;

        if (!IsPrison)
        {
            m_HeroRenderer.sprite       = Hero.HeroVisualData.IdleSprites[0];
            m_HeroShadowRenderer.sprite = Hero.HeroVisualData.ShadowIdleSprites[0];

            HeroFlagVisualData _FlagData = m_PlayerColors.Flags[PlayerIndex];

            m_FlagRenderer.SetSprites(_FlagData.IdleSprites);
            m_FlagRenderer.transform.localPosition = new Vector3(Hero.HeroVisualData.IdleFlagOffsets[m_Direction].x, Hero.HeroVisualData.IdleFlagOffsets[m_Direction].y, 0);
        }
        else
        {
            m_HeroRenderer.sprite       = m_PrisonVisualData.m_Sprites[0];
            m_HeroShadowRenderer.sprite = m_PrisonVisualData.m_ShadowSprites[0];
        }

        if (PlayerIndex == m_GameSettings.LocalPlayerIndex)
        {
            m_GameReferences.LocalOwnership.AddHero(this);
        }

        m_LocalPathfindingVersion = -1;
    }
Пример #2
0
    IEnumerator Move()
    {
        if (m_Path.Count == 0)
        {
            yield break;
        }

        IsAsleep = false;

        m_StopMovement = false;

        IsMoving = true;

        m_FlagRenderer.enabled = false;

        HeroFlagVisualData _FlagData = m_PlayerColors.Flags[PlayerIndex];

        m_DynamicObstacle.ClearNodes();

        Pathfinding.PrecomputedNode _Node = m_Path[0];

        Destroy(m_PathNodes[0]);
        Destroy(m_PathNodeShadows[0]);

        m_PathNodes.RemoveAt(0);
        m_PathNodeShadows.RemoveAt(0);

        int _AnimationIndex = 0;
        int _Frame          = 0;

        m_GameReferences.InputBlocker.SetActive(true);

        Vector3 _MovementDirection;

        void SetDirection()
        {
            _MovementDirection = new Vector3
                                 (
                m_Path[0].PosX - m_PathfindingPos.x,
                -(m_Path[0].PosY - m_PathfindingPos.y),
                0
                                 ) / 4;

            if (_MovementDirection.x > 0)
            {
                if (_MovementDirection.y > 0)
                {
                    m_Direction = DIRECTION_NE;
                }
                else if (_MovementDirection.y < 0)
                {
                    m_Direction = DIRECTION_SE;
                }
                else
                {
                    m_Direction = DIRECTION_E;
                }
            }
            else if (_MovementDirection.x < 0)
            {
                if (_MovementDirection.y > 0)
                {
                    m_Direction = DIRECTION_NW;
                }
                else if (_MovementDirection.y < 0)
                {
                    m_Direction = DIRECTION_SW;
                }
                else
                {
                    m_Direction = DIRECTION_W;
                }
            }
            else if (_MovementDirection.y > 0)
            {
                m_Direction = DIRECTION_N;
            }
            else
            {
                m_Direction = DIRECTION_S;
            }
        }

        SetDirection();

        OnStartMovement?.Invoke();

        // We don't check IsMoving here, because when cancelled, we still want to finish walking to the next tile
        while (true)
        {
            if (_Frame == 4)
            {
                _Frame = 0;

                m_PathfindingPos = new Vector2Int(_Node.PosX, _Node.PosY);
                m_Path.RemoveAt(0);

                if (m_Path.Count == 0 ||
                    m_StopMovement)
                {
                    break;
                }

                Destroy(m_PathNodes[0]);
                Destroy(m_PathNodeShadows[0]);

                m_PathNodes.RemoveAt(0);
                m_PathNodeShadows.RemoveAt(0);

                _Node = m_Path[0];

                SetDirection();
            }

            m_HeroRenderer.sprite       = Hero.HeroVisualData.MovingSprites[m_Direction].Array[_AnimationIndex];
            m_HeroShadowRenderer.sprite = Hero.HeroVisualData.ShadowMovingSprites[m_Direction].Array[_AnimationIndex];
            m_FlagSpriteRenderer.sprite = _FlagData.MovingSprites[m_Direction].Array[_AnimationIndex];

            m_HeroRenderer.flipX       = HeroVisualData.SPRITES_FLIPPED[m_Direction];
            m_HeroShadowRenderer.flipX = HeroVisualData.SPRITES_FLIPPED[m_Direction];
            m_FlagSpriteRenderer.flipX = HeroVisualData.SPRITES_FLIPPED[m_Direction];

            if (m_HeroRenderer.flipX)
            {
                m_HeroRenderer.transform.localPosition       = new Vector3(-3, 0, 0);
                m_HeroShadowRenderer.transform.localPosition = new Vector3(-3, 0, 0);
                m_FlagSpriteRenderer.transform.localPosition = new Vector2(-3, 0) + Hero.HeroVisualData.MovingFlagOffsets[m_Direction];
            }
            else
            {
                m_HeroRenderer.transform.localPosition       = Vector3.zero;
                m_HeroShadowRenderer.transform.localPosition = Vector3.zero;
                m_FlagSpriteRenderer.transform.localPosition = Hero.HeroVisualData.MovingFlagOffsets[m_Direction];
            }

            transform.position += _MovementDirection;

            yield return(new WaitForSeconds(0.05f));

            _AnimationIndex++;
            _Frame++;

            if (_AnimationIndex == 8)
            {
                _AnimationIndex = 0;
            }
        }

        m_GameReferences.InputBlocker.SetActive(false);

        m_FlagRenderer.enabled = true;

        m_HeroRenderer.sprite       = Hero.HeroVisualData.IdleSprites[m_Direction];
        m_HeroShadowRenderer.sprite = Hero.HeroVisualData.ShadowIdleSprites[m_Direction];

        m_HeroRenderer.flipX       = HeroVisualData.SPRITES_FLIPPED[m_Direction];
        m_HeroShadowRenderer.flipX = HeroVisualData.SPRITES_FLIPPED[m_Direction];
        m_FlagSpriteRenderer.flipX = HeroVisualData.SPRITES_FLIPPED[m_Direction];

        if (m_HeroRenderer.flipX)
        {
            m_HeroRenderer.transform.localPosition       = new Vector3(-3, 0, 0);
            m_HeroShadowRenderer.transform.localPosition = new Vector3(-3, 0, 0);
            m_FlagSpriteRenderer.transform.localPosition = new Vector2(-3, 0) + Hero.HeroVisualData.IdleFlagOffsets[m_Direction];
        }
        else
        {
            m_HeroRenderer.transform.localPosition       = Vector3.zero;
            m_HeroShadowRenderer.transform.localPosition = Vector3.zero;
            m_FlagSpriteRenderer.transform.localPosition = Hero.HeroVisualData.IdleFlagOffsets[m_Direction];
        }

        Pathfinding.Node _FinalNode = m_GameReferences.Pathfinding.GetNode(m_PathfindingPos, IsUnderground);

        m_DynamicObstacle.AddInteractedNode(_FinalNode);

        for (int i = 0; i < _FinalNode.InteractionObjects.Count; i++)
        {
            MapTown _Town = _FinalNode.InteractionObjects[i] as MapTown;

            if (_Town != null)
            {
                m_GameReferences.TownScreen.OpenTown(_Town);
            }
        }

        m_PathableArea = m_GameReferences.Pathfinding.GetPathableArea(m_PathfindingPos, IsUnderground);

        if (m_Path.Count == 0)
        {
            m_TargetNodeIndex = -1;
            HasPath           = false;
            OnPathRemoved?.Invoke();
        }

        IsMoving = false;
    }