Beispiel #1
0
    /**********************************************************************************/
    //  устанавливаем параметры миссионного дропа
    //
    /**********************************************************************************/
    public void SetLevel(List <DropItemDescriptor> dropSettings, int maxNumOfDropInSceen)
    {
        if (dropSettings.Count == 0)
        {
            Debug.LogError("Drop settings is empty!");
            return;
        }

        m_levelTimer     = 0.0f;
        m_deploedDrops   = new Dictionary <Base.GO_TYPE, int>();
        m_dropDescriptor = new List <DropItemDescriptorEditor>();

        // сохраняем настройки по количеству дропа
        foreach (var drop in dropSettings)
        {
            DropItemDescriptorEditor itemDrop = new DropItemDescriptorEditor(drop);
            m_dropDescriptor.Add(itemDrop);

            // устанавливаем одновременно допустимое на карте количесво конкретного дропа
            if (itemDrop.MaxNumOfDrop != (int)DropItemDescriptorEditor.DROP_MARKER.UNLIMITED)
            {
                m_deploedDrops[itemDrop.DropType] = itemDrop.MaxNumOfDrop;
            }
            else
            {
                m_deploedDrops[itemDrop.DropType] = maxNumOfDropInSceen;
            }
        }

        m_maxNumberOfDroppedBonus     = maxNumOfDropInSceen;
        m_currentNumberOfDroppedBonus = 0;

        m_state = DM_STATE.WAIT_FOR_DEPLAY;
        m_currentTimerToNextDrop = Random.Range(TimeBetweenDropMin, TimeBetweenDropMax);
    }
    /**********************************************************************************/
    // LoadGameData
    // загружаем данные из файла и парсим их в удобоваримый формат
    //
    /**********************************************************************************/
    private void LoadGameData()
    {
        string filePath = EditorUtility.OpenFilePanel("Select company data file", Application.streamingAssetsPath, "json");

        if (!string.IsNullOrEmpty(filePath))
        {
            string            dataAsJson        = File.ReadAllText(filePath);
            CompanyDescriptor companyDescriptor = JsonUtility.FromJson <CompanyDescriptor>(dataAsJson);
            m_lastOpenFile = filePath;  // запоминаем путь к файлу, будет использован в функции сохранения

            CompanyData          = new CompanyDescriptorEditor();
            CompanyData.missions = new MissionDescriptorEditor[companyDescriptor.missions.Length];

            // разбираем миссию за миссией
            for (int missInd = 0; missInd < companyDescriptor.missions.Length; missInd++)
            {
                // создаём MissionDescriptorEditor и заполняем его данными из MissionDescriptor
                MissionDescriptor       mission       = companyDescriptor.missions[missInd];
                MissionDescriptorEditor missionEditor = new MissionDescriptorEditor();
                CompanyData.missions[missInd] = missionEditor;

                missionEditor.MapXSize                  = mission.MapXSize;
                missionEditor.MapYSize                  = mission.MapYSize;
                missionEditor.MissionDifficulties       = mission.MissionDifficulties;
                missionEditor.RequiredStoryLineProgress = mission.RequiredStoryLineProgress;

                // конвертируем здание
                missionEditor.Buildings = new AvailableBuildingEditor[mission.Buildings.Length];
                for (int buildInd = 0; buildInd < mission.Buildings.Length; buildInd++)
                {
                    AvailableBuildingEditor buildingEditor = new AvailableBuildingEditor();
                    missionEditor.Buildings[buildInd] = buildingEditor;

                    buildingEditor.BuildingType = Base.StringToBlockType(mission.Buildings[buildInd].BuildingType);
                    buildingEditor.Weight       = mission.Buildings[buildInd].Weight;
                }

                // конвертируем список боссов
                missionEditor.MissionBosses = new Base.GO_TYPE[mission.MissionBosses.Length];
                for (int bossInd = 0; bossInd < mission.MissionBosses.Length; bossInd++)
                {
                    missionEditor.MissionBosses[bossInd] = Base.StringToGOType(mission.MissionBosses[bossInd]);
                }


                // конвертируем настройки дропа
                missionEditor.DropDescriptor = new DropDescriptorEditor();
                missionEditor.DropDescriptor.MaxNumOfDroppedItem = mission.DropDescriptor.MaxNumOfDroppedItem;
                missionEditor.DropDescriptor.DropItems           = new DropItemDescriptorEditor[mission.DropDescriptor.DropItems.Length];
                for (int dropInd = 0; dropInd < mission.DropDescriptor.DropItems.Length; dropInd++)
                {
                    DropItemDescriptorEditor dropEditor = new DropItemDescriptorEditor();
                    missionEditor.DropDescriptor.DropItems[dropInd] = dropEditor;

                    dropEditor.DropType   = Base.StringToGOType(mission.DropDescriptor.DropItems[dropInd].DropType);
                    dropEditor.DropWeight = mission.DropDescriptor.DropItems[dropInd].DropWeight;
                }
            }
        }
    }
Beispiel #3
0
    /**********************************************************************************/
    //  выбираем тип бонуса бонус
    //
    /**********************************************************************************/
    private Base.GO_TYPE ChoseDropType()
    {
        int weightOfDropSet = 0;

        // формируем список допустимого дропа
        List <DropItemDescriptorEditor> avalibleDrop = new List <DropItemDescriptorEditor>();

        foreach (var possibleDrop in m_dropDescriptor)
        {
            Base.GO_TYPE type = possibleDrop.DropType;

            // отсекаем тех, с кем мы работать не можем
            // по количеству
            if (m_deploedDrops[type] <= 0)
            {
                continue;
            }

            // по времени
            if (possibleDrop.TimeForDropStart > m_levelTimer)
            {
                continue;
            }

            // подсчитываем суммарынй вес всего дропа
            weightOfDropSet += possibleDrop.DropWeight;
            avalibleDrop.Add(possibleDrop);
        }

        // проверочка
        if (avalibleDrop.Count == 0)
        {
            Debug.LogError("avalibleDrop is empty!");
            return(Base.GO_TYPE.NONE_TYPE);
        }

        // определяем бонус для дропа
        int randomDropIndex = Random.Range(1, weightOfDropSet + 1);

        Base.GO_TYPE bonusType     = Base.GO_TYPE.NONE_TYPE;
        int          growingWeight = 0;
        int          itemIndex     = 0;


        do
        {
            DropItemDescriptorEditor potantialDrop = avalibleDrop[itemIndex];
            bonusType      = potantialDrop.DropType;
            growingWeight += potantialDrop.DropWeight;

            itemIndex++;
        }while (growingWeight < randomDropIndex && itemIndex < avalibleDrop.Count);

        return(bonusType);
    }