Пример #1
0
    private void InitGettingHijackedState()
    {
        GameObject ui = Instantiate(m_HijackedPrefab);

        m_HijackedMeterUI = ui.GetComponent <HijackUI>();
        m_HijackedMeterUI.transform.SetParent(uiRoot.transform, false);

        Vector3 meterScreenPos = uiRoot.transform.InverseTransformPoint(m_HijackedUIAnchor.transform.position);

        m_HijackedMeterUI.transform.localPosition = meterScreenPos;

        m_IsOpeningTimeScale = 0f;
        m_IsOpeningTick      = 0f;
        m_IsOpeningTotalTime = 4f;

        //If tier 2, create mechbot. TODO: have mechbot count be configurable
        if (Tier == DifficultTier.Tier2 && (m_Mechbots == null || m_Mechbots.Count == 0))
        {
            CreateMechbot();
        }
    }
Пример #2
0
    private void ResetState(State state)
    {
        switch (state)
        {
        case State.PlayerControlled:
        {
            if (m_FlightTween != null)
            {
                m_FlightTween.Kill();
            }

            m_FlightTween     = null;
            m_IsMovingForward = false;
        }
        break;

        case State.GettingHijacked:
        {
            Destroy(m_HijackedMeterUI.gameObject);
            m_HijackedMeterUI = null;
        }
        break;
        }
    }
Пример #3
0
    // Update is called once per frame
    void Update()
    {
        float unitsHeight = Camera.main.orthographicSize * 2f;
        float aspectRatio = (float)Screen.width / (float)Screen.height;
        float unitsWidth  = unitsHeight * aspectRatio;

        m_DisplayRoot.transform.localScale = new Vector3(TravelDir, 1f, 1f);

        if (CurrState == State.Patrol)
        {
            bool    playerTravelingRight = m_Player.TravelDir == 1;
            Vector3 vel = Vector3.zero;
            //To make sure enemy stays at screen position when player gets in contact
            //with the hatch
            if (CurrState != State.GettingHijacked)
            {
                vel = new Vector3(-kEnemySpeed * TravelDir, 0f, 0f);
            }

            transform.position += vel * Time.deltaTime;

            if (GetIsEnemyOffscreen())
            {
                if (!m_MessagedOffscreen)
                {
                    m_MessagedOffscreen = true;
                    OnOffscreen?.Invoke();
                }
            }

            if (GetIsEnemyTooFarAway())
            {
                Remove();
                return;
            }
        }

        if (CurrState == State.GettingHijacked)
        {
            m_IsOpeningTick = Mathf.Min(m_IsOpeningTick + Time.deltaTime * m_IsOpeningTimeScale, m_IsOpeningTotalTime);
            m_HijackedMeterUI.SetFillPercent(m_IsOpeningTick / m_IsOpeningTotalTime);

            if (m_IsOpeningTick >= m_IsOpeningTotalTime)
            {
                //This is where the player has finished hijacking and is now controlling this enemy

                CurrState = State.PlayerControlled;
                TravelDir = -TravelDir;

                Destroy(m_HijackedMeterUI.gameObject);
                m_HijackedMeterUI = null;

                if (m_AnchorShipToScreenEdgeTween != null)
                {
                    m_AnchorShipToScreenEdgeTween.Kill();
                }
                if (m_AnimateHatchTween != null)
                {
                    m_AnimateHatchTween.Kill();
                }

                m_HatchSprite.gameObject.SetActive(false);

                m_AnchorShipToScreenEdgeTween = transform.DOMoveX(-unitsWidth * .5f + kScreenHEdgeMargin, 1f);
                m_IsMovingForward             = false;

                if (m_Mechbots != null)
                {
                    foreach (EnemyMechbot bot in m_Mechbots)
                    {
                        bot.CurrentState = EnemyMechbot.State.Destroyed;
                    }
                }

                OnSuccessfullyHijacked?.Invoke();
            }
        }

        if (CurrState == State.PlayerControlled &&
            m_AnchorShipToScreenEdgeTween != null)
        {
            if (Input.GetKey(KeyCode.LeftCommand))
            {
                if (!m_IsMovingForward)
                {
                    m_IsMovingForward = true;

                    if (m_FlightTween != null)
                    {
                        m_FlightTween.Kill();
                    }

                    m_FlightTween = DOTween.To(x => m_BackgroundScroller.SetScrollSpeed(x),
                                               0,
                                               SideviewPlayer.kFlightMaxScrollSpeed,
                                               2f);
                }
            }
            else if (Input.GetKeyUp(KeyCode.LeftCommand))
            {
                if (m_IsMovingForward)
                {
                    m_IsMovingForward = false;

                    if (m_FlightTween != null)
                    {
                        m_FlightTween.Kill();
                    }

                    m_FlightTween = DOTween.To(x => m_BackgroundScroller.SetScrollSpeed(x),
                                               m_BackgroundScroller.GetScrollSpeed(),
                                               0f,
                                               2f);
                }
            }

            Vector3 vel = new Vector3(0f, 5f, 0f) * Time.deltaTime;
            if (Input.GetKey(KeyCode.UpArrow))
            {
                transform.position = GetClampedToScreenAreaPos(transform.position + vel);
            }
            if (Input.GetKey(KeyCode.DownArrow))
            {
                transform.position = GetClampedToScreenAreaPos(transform.position - vel);
            }
        }

        if (m_DidCrash)
        {
            Vector2 nextPos = transform.position + (Vector3)m_CrashedVel * Time.deltaTime;
            float   velDot  = Vector2.Dot(m_CrashedDir, (nextPos - (Vector2)transform.position).normalized);

            bool nextPosWillBeOutsideScreenArea = nextPos.x > m_ScreenMoveMax.x ||
                                                  nextPos.x <m_ScreenMoveMin.x ||
                                                             nextPos.y> m_ScreenMoveMax.y ||
                                                  nextPos.y < m_ScreenMoveMin.y;

            bool clampPosToScreenArea = CurrState != State.Patrol && nextPosWillBeOutsideScreenArea;

            if (velDot > 0f)
            {
                transform.position = new Vector3(nextPos.x, nextPos.y, transform.position.z);
                m_CrashedVel      -= m_CrashedAccel * Time.deltaTime;

                if (clampPosToScreenArea)
                {
                    m_DidCrash = false;

                    //We need to clamp position to screen boundaries...so do that here.
                    transform.position = GetClampedToScreenAreaPos(transform.position);
                }
            }
            else
            {
                m_DidCrash = false;
            }
        }
    }