/**********************************************************************************/
    // процессинг строения, производство юнитов
    //
    /**********************************************************************************/
    private void FixedUpdate()
    {
        // стопим все процессы, если игра поставлена на паузу
        if (GameManager.GamePaused)
        {
            return;
        }

        if (IsInitialized() && m_unitProdactionType != Base.GO_TYPE.NONE_TYPE)
        {
            // разрушенные и незахваченные здания ничего не производят
            if (m_isDestroyed && m_ownerId == (int)PLAYER.NEUTRAL)
            {
                return;
            }

            // блокируем производство если у здания уже есть достигли предела по количеству существ
            if (m_createdUnitIDs.Count >= MaxNumberOfProd)
            {
                return;
            }

            // рассчитываем текущий прогресс производства
            m_currentProductionTime -= Time.deltaTime;

            if (m_currentProductionTime <= 0)
            {
                GameObject production = ObjectFactory.GetInstance().CreateGObject(m_productionPosition, Base.DIREC.DOWN, m_unitProdactionType, false);

                // бонусы - недвижимые объекты, потому GMovingObject не имеют
                if (production.tag != "Bonus")
                {
                    CIGameObject gmo = production.GetComponent <CIGameObject>();
                    gmo.Owner = m_ownerId;
                    m_createdUnitIDs.Add(gmo.ID);
                    gmo.ProductionBase = this;
                }
                else
                {
                    BonusCtr bctr = production.GetComponent <BonusCtr>();
                    bctr.ProductionBase = this;
                }

                if (m_ownerId == (int)PLAYER.NEUTRAL)
                {
                    // устанавливаем ранодное стартовое значение для того, чтобы нейтральные войска выходили не в один момент
                    m_currentProductionTime += RateOfProductionNeutral;
                }
                else
                {
                    m_currentProductionTime += RateOfProduction;
                }


                // увеличиваем счётчик очков за производство
                // TODO: производство пока приносит строго 1 очко, подумать над этим на досуге
                GameManager.GetInstance().IncreasePlayerScopeUnitProduction((PLAYER)m_ownerId, 1);
            }
        }
    }
Beispiel #2
0
    /**********************************************************************************/
    //  создаём таблицу объектов
    //
    /**********************************************************************************/
    void Start()
    {
        // обрабатываем все GMovingObject по одному
        // юниты игроков
        CIGameObject gmo = null;

        for (int i = 0; i < Units.Length; i++)
        {
            gmo = Units[i].GetComponent <CIGameObject>();
            m_prefabsCollection[gmo.GOType] = gmo.gameObject;
        }

        // нейтральные юниты
        for (int i = 0; i < NeutralUnits.Length; i++)
        {
            gmo = NeutralUnits[i].GetComponent <CIGameObject>();
            m_prefabsCollection[gmo.GOType] = gmo.gameObject;
        }

        // снаряды
        for (int i = 0; i < Shots.Length; i++)
        {
            gmo = Shots[i].GetComponent <CIGameObject>();
            m_prefabsCollection[gmo.GOType] = gmo.gameObject;
        }


        // здания
        BuildingController bCtr = null;

        for (int i = 0; i < Buildings.Length; i++)
        {
            bCtr = Buildings[i].GetComponent <BuildingController>();
            m_prefabsCollection[bCtr.BuildingType] = bCtr.gameObject;
        }


        // обрабатываем все бонусы
        BonusCtr bonus = null;

        for (int i = 0; i < Bonuses.Length; i++)
        {
            bonus = Bonuses[i].GetComponent <BonusCtr>();
            m_prefabsCollection[(Base.GO_TYPE)bonus.BonusType] = bonus.gameObject;
        }
    }
Beispiel #3
0
    /**********************************************************************************/
    // функция создания игровых объектов
    // пытаемся найти объект в кеше
    /**********************************************************************************/
    protected GameObject GetGObjectFromCash(Vector2 from, Base.DIREC direction, Base.GO_TYPE objectType, bool useOffset)
    {
        GameObject instance        = null;
        Vector2    objectDirection = new Vector2(0f, 0f);
        Vector2    newPosition     = new Vector2(0f, 0f);

        // проверяем кеш объектов
        // если он у нас уже имеется - реиспользуем
        if (m_objectColection.ContainsKey(objectType))
        {
            LinkedList <GameObject> objectPull = m_objectColection[objectType];

            if (objectPull.Count > 0)
            {
                instance = objectPull.First.Value;
                objectPull.RemoveFirst();

                float OffsetSize = offset;
                if (!useOffset)
                {
                    OffsetSize = 0;
                }

                switch (direction)
                {
                case Base.DIREC.DOWN:
                    newPosition       = new Vector2(from.x, from.y - OffsetSize);
                    objectDirection.y = -1f;
                    break;

                case Base.DIREC.UP:
                    newPosition       = new Vector2(from.x, from.y + OffsetSize);
                    objectDirection.y = 1f;
                    break;

                case Base.DIREC.LEFT:
                    newPosition       = new Vector2(from.x - OffsetSize, from.y);
                    objectDirection.x = -1f;
                    break;

                case Base.DIREC.RIGHT:
                    newPosition       = new Vector2(from.x + OffsetSize, from.y);
                    objectDirection.x = 1f;
                    break;
                }
            }
        }
        else
        {
            // если это первое создание объекта - создаем так же для него LinkedList для последующего хранения
            m_objectColection[objectType] = new LinkedList <GameObject>();
        }

        // если нашёлся объект - устанавливаем ему направление
        if (instance != null)
        {
            Transform objTransform = instance.GetComponent <Transform>();
            objTransform.position = new Vector3(newPosition.x, newPosition.y, 0);

            if (instance.tag != "Bonus")
            {
                CIGameObject ctr = instance.GetComponent <CIGameObject>();
                ctr.SetDirection(objectDirection);

                instance.GetComponent <CIGameObject>().ResetGObject();
            }
            else
            {
                BonusCtr ctr = instance.GetComponent <BonusCtr>();
                ctr.ResetBonus();
            }
        }

        return(instance);
    }
Beispiel #4
0
    /**********************************************************************************/
    // процессинг дроп-пода
    //
    /**********************************************************************************/
    private void FixedUpdate()
    {
        // приостанавливаем всё на время паузы
        if (GameManager.GamePaused)
        {
            if (m_rb2d.velocity.sqrMagnitude != 0.0f)
            {
                m_rb2d.velocity = new Vector2(0, 0);
            }
            return;
        }


        // падаем вниз
        if (m_dropState == DR_STATE.ACTIVE)
        {
            m_currentDropTime -= Time.deltaTime;
            if (m_currentDropTime <= 0.0f)
            {
                m_dropState = DR_STATE.DROPPED;
                m_animator.SetBool("Burn", true);

                // включаем звуковой эффект и анимацию частиц
                if (BurstSoundKey != "")
                {
                    GameAudioManager.Instance.PlaySound(BurstSoundKey);
                }
                BurstSystem.Play();

                // трясём камеру
                CameraControllerDuelMode.ShakeCamera();
            }
            else
            {
                MoveGObject(Base.DIREC.DOWN);
            }
        }
        // проверка на окончание анимации
        // после неё объект возвращается в пулл объектов фабрики
        // и создаем объект дропа
        else if (m_dropState == DR_STATE.DROPPED)
        {
            if (m_animator.GetCurrentAnimatorStateInfo(0).IsName("Base_Layer.EndOfAnimation"))
            {
                m_animator.SetBool("Burn", false);
                gameObject.SetActive(false);
                m_dropState = DR_STATE.FINISHED;

                GameObject go = ObjectFactory.GetInstance().CreateGObject(transform.position, Base.DIREC.DOWN, m_dropType, false);  // создаём дроп

                // устанавливаем производстенную базу в null, в случае с дропом этот механизм не используется
                BonusCtr bctr = go.GetComponent <BonusCtr>();
                if (bctr != null)
                {
                    bctr.ProductionBase = null;
                }

                ObjectFactory.GetInstance().ReturnObjectToCash(gameObject, GOType);       // возвращаем объект дроп-пода в кеш фабрики объектов
            }
        }
    }