// Token: 0x06001A90 RID: 6800 RVA: 0x00094CCA File Offset: 0x000930CA
 public ItemFarmAsset(Bundle bundle, Data data, Local localization, ushort id) : base(bundle, data, localization, id)
 {
     this._growth = data.readUInt32("Growth");
     this._grow   = data.readUInt16("Grow");
 }
 // Token: 0x06001D50 RID: 7504 RVA: 0x0009DA54 File Offset: 0x0009BE54
 public ZombieDifficultyAsset(Bundle bundle, Local localization, byte[] hash) : base(bundle, localization, hash)
 {
     this.construct();
 }
Example #3
0
        public static void readConditions(Data data, Local localization, string prefix, INPCCondition[] conditions)
        {
            for (int i = 0; i < conditions.Length; i++)
            {
                if (!data.has(prefix + i + "_Type"))
                {
                    throw new NotSupportedException("Missing condition type");
                }
                ENPCConditionType enpcconditionType = (ENPCConditionType)Enum.Parse(typeof(ENPCConditionType), data.readString(prefix + i + "_Type"), true);
                string            text = localization.read(prefix + i);
                text = ItemTool.filterRarityRichText(text);
                bool          newShouldReset = data.has(prefix + i + "_Reset");
                ENPCLogicType newLogicType   = ENPCLogicType.NONE;
                if (data.has(prefix + i + "_Logic"))
                {
                    newLogicType = (ENPCLogicType)Enum.Parse(typeof(ENPCLogicType), data.readString(prefix + i + "_Logic"), true);
                }
                switch (enpcconditionType)
                {
                case ENPCConditionType.EXPERIENCE:
                    conditions[i] = new NPCExperienceCondition(data.readUInt32(prefix + i + "_Value"), newLogicType, text, newShouldReset);
                    break;

                case ENPCConditionType.REPUTATION:
                    conditions[i] = new NPCReputationCondition(data.readInt32(prefix + i + "_Value"), newLogicType, text);
                    break;

                case ENPCConditionType.FLAG_BOOL:
                    conditions[i] = new NPCBoolFlagCondition(data.readUInt16(prefix + i + "_ID"), data.readBoolean(prefix + i + "_Value"), data.has(prefix + i + "_Allow_Unset"), newLogicType, text, newShouldReset);
                    break;

                case ENPCConditionType.FLAG_SHORT:
                    conditions[i] = new NPCShortFlagCondition(data.readUInt16(prefix + i + "_ID"), data.readInt16(prefix + i + "_Value"), data.has(prefix + i + "_Allow_Unset"), newLogicType, text, newShouldReset);
                    break;

                case ENPCConditionType.QUEST:
                    conditions[i] = new NPCQuestCondition(data.readUInt16(prefix + i + "_ID"), (ENPCQuestStatus)Enum.Parse(typeof(ENPCQuestStatus), data.readString(prefix + i + "_Status"), true), data.has(prefix + i + "_Ignore_NPC"), newLogicType, text, newShouldReset);
                    break;

                case ENPCConditionType.SKILLSET:
                    conditions[i] = new NPCSkillsetCondition((EPlayerSkillset)Enum.Parse(typeof(EPlayerSkillset), data.readString(prefix + i + "_Value"), true), newLogicType, text);
                    break;

                case ENPCConditionType.ITEM:
                    conditions[i] = new NPCItemCondition(data.readUInt16(prefix + i + "_ID"), data.readUInt16(prefix + i + "_Amount"), text, newShouldReset);
                    break;

                case ENPCConditionType.KILLS_ZOMBIE:
                {
                    EZombieSpeciality newZombie = EZombieSpeciality.NONE;
                    if (data.has(prefix + i + "_Zombie"))
                    {
                        newZombie = (EZombieSpeciality)Enum.Parse(typeof(EZombieSpeciality), data.readString(prefix + i + "_Zombie"), true);
                    }
                    conditions[i] = new NPCZombieKillsCondition(data.readUInt16(prefix + i + "_ID"), data.readInt16(prefix + i + "_Value"), newZombie, data.has(prefix + i + "_Spawn"), data.readByte(prefix + i + "_Nav"), text, newShouldReset);
                    break;
                }

                case ENPCConditionType.KILLS_HORDE:
                    conditions[i] = new NPCHordeKillsCondition(data.readUInt16(prefix + i + "_ID"), data.readInt16(prefix + i + "_Value"), data.readByte(prefix + i + "_Nav"), text, newShouldReset);
                    break;
                }
            }
        }
        // Token: 0x06003522 RID: 13602 RVA: 0x00160488 File Offset: 0x0015E888
        public EditorSpawnsAnimalsUI()
        {
            Local  local  = Localization.read("/Editor/EditorSpawnsAnimals.dat");
            Bundle bundle = Bundles.getBundle("/Bundles/Textures/Edit/Icons/EditorSpawnsAnimals/EditorSpawnsAnimals.unity3d");

            EditorSpawnsAnimalsUI.container = new Sleek();
            EditorSpawnsAnimalsUI.container.positionOffset_X = 10;
            EditorSpawnsAnimalsUI.container.positionOffset_Y = 10;
            EditorSpawnsAnimalsUI.container.positionScale_X  = 1f;
            EditorSpawnsAnimalsUI.container.sizeOffset_X     = -20;
            EditorSpawnsAnimalsUI.container.sizeOffset_Y     = -20;
            EditorSpawnsAnimalsUI.container.sizeScale_X      = 1f;
            EditorSpawnsAnimalsUI.container.sizeScale_Y      = 1f;
            EditorUI.window.add(EditorSpawnsAnimalsUI.container);
            EditorSpawnsAnimalsUI.active         = false;
            EditorSpawnsAnimalsUI.tableScrollBox = new SleekScrollBox();
            EditorSpawnsAnimalsUI.tableScrollBox.positionOffset_X = -470;
            EditorSpawnsAnimalsUI.tableScrollBox.positionOffset_Y = 120;
            EditorSpawnsAnimalsUI.tableScrollBox.positionScale_X  = 1f;
            EditorSpawnsAnimalsUI.tableScrollBox.sizeOffset_X     = 470;
            EditorSpawnsAnimalsUI.tableScrollBox.sizeOffset_Y     = 200;
            EditorSpawnsAnimalsUI.container.add(EditorSpawnsAnimalsUI.tableScrollBox);
            EditorSpawnsAnimalsUI.tableNameField = new SleekField();
            EditorSpawnsAnimalsUI.tableNameField.positionOffset_X = -230;
            EditorSpawnsAnimalsUI.tableNameField.positionOffset_Y = 330;
            EditorSpawnsAnimalsUI.tableNameField.positionScale_X  = 1f;
            EditorSpawnsAnimalsUI.tableNameField.sizeOffset_X     = 230;
            EditorSpawnsAnimalsUI.tableNameField.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.tableNameField.maxLength        = 64;
            EditorSpawnsAnimalsUI.tableNameField.addLabel(local.format("TableNameFieldLabelText"), ESleekSide.LEFT);
            SleekField sleekField = EditorSpawnsAnimalsUI.tableNameField;
            Delegate   onTyped    = sleekField.onTyped;

            if (EditorSpawnsAnimalsUI.< > f__mg$cache4 == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cache4 = new Typed(EditorSpawnsAnimalsUI.onTypedNameField);
            }
            sleekField.onTyped = (Typed)Delegate.Combine(onTyped, EditorSpawnsAnimalsUI.< > f__mg$cache4);
            EditorSpawnsAnimalsUI.container.add(EditorSpawnsAnimalsUI.tableNameField);
            EditorSpawnsAnimalsUI.addTableButton = new SleekButtonIcon((Texture2D)bundle.load("Add"));
            EditorSpawnsAnimalsUI.addTableButton.positionOffset_X = -230;
            EditorSpawnsAnimalsUI.addTableButton.positionOffset_Y = 370;
            EditorSpawnsAnimalsUI.addTableButton.positionScale_X  = 1f;
            EditorSpawnsAnimalsUI.addTableButton.sizeOffset_X     = 110;
            EditorSpawnsAnimalsUI.addTableButton.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.addTableButton.text             = local.format("AddTableButtonText");
            EditorSpawnsAnimalsUI.addTableButton.tooltip          = local.format("AddTableButtonTooltip");
            SleekButton sleekButton = EditorSpawnsAnimalsUI.addTableButton;

            if (EditorSpawnsAnimalsUI.< > f__mg$cache5 == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cache5 = new ClickedButton(EditorSpawnsAnimalsUI.onClickedAddTableButton);
            }
            sleekButton.onClickedButton = EditorSpawnsAnimalsUI.< > f__mg$cache5;
            EditorSpawnsAnimalsUI.container.add(EditorSpawnsAnimalsUI.addTableButton);
            EditorSpawnsAnimalsUI.removeTableButton = new SleekButtonIcon((Texture2D)bundle.load("Remove"));
            EditorSpawnsAnimalsUI.removeTableButton.positionOffset_X = -110;
            EditorSpawnsAnimalsUI.removeTableButton.positionOffset_Y = 370;
            EditorSpawnsAnimalsUI.removeTableButton.positionScale_X  = 1f;
            EditorSpawnsAnimalsUI.removeTableButton.sizeOffset_X     = 110;
            EditorSpawnsAnimalsUI.removeTableButton.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.removeTableButton.text             = local.format("RemoveTableButtonText");
            EditorSpawnsAnimalsUI.removeTableButton.tooltip          = local.format("RemoveTableButtonTooltip");
            SleekButton sleekButton2 = EditorSpawnsAnimalsUI.removeTableButton;

            if (EditorSpawnsAnimalsUI.< > f__mg$cache6 == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cache6 = new ClickedButton(EditorSpawnsAnimalsUI.onClickedRemoveTableButton);
            }
            sleekButton2.onClickedButton = EditorSpawnsAnimalsUI.< > f__mg$cache6;
            EditorSpawnsAnimalsUI.container.add(EditorSpawnsAnimalsUI.removeTableButton);
            EditorSpawnsAnimalsUI.updateTables();
            EditorSpawnsAnimalsUI.spawnsScrollBox = new SleekScrollBox();
            EditorSpawnsAnimalsUI.spawnsScrollBox.positionOffset_X = -470;
            EditorSpawnsAnimalsUI.spawnsScrollBox.positionOffset_Y = 410;
            EditorSpawnsAnimalsUI.spawnsScrollBox.positionScale_X  = 1f;
            EditorSpawnsAnimalsUI.spawnsScrollBox.sizeOffset_X     = 470;
            EditorSpawnsAnimalsUI.spawnsScrollBox.sizeOffset_Y     = -410;
            EditorSpawnsAnimalsUI.spawnsScrollBox.sizeScale_Y      = 1f;
            EditorSpawnsAnimalsUI.spawnsScrollBox.area             = new Rect(0f, 0f, 5f, 1000f);
            EditorSpawnsAnimalsUI.container.add(EditorSpawnsAnimalsUI.spawnsScrollBox);
            EditorSpawnsAnimalsUI.tableColorPicker = new SleekColorPicker();
            EditorSpawnsAnimalsUI.tableColorPicker.positionOffset_X = 200;
            SleekColorPicker sleekColorPicker = EditorSpawnsAnimalsUI.tableColorPicker;

            if (EditorSpawnsAnimalsUI.< > f__mg$cache7 == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cache7 = new ColorPicked(EditorSpawnsAnimalsUI.onAnimalColorPicked);
            }
            sleekColorPicker.onColorPicked = EditorSpawnsAnimalsUI.< > f__mg$cache7;
            EditorSpawnsAnimalsUI.spawnsScrollBox.add(EditorSpawnsAnimalsUI.tableColorPicker);
            EditorSpawnsAnimalsUI.tableIDField = new SleekUInt16Field();
            EditorSpawnsAnimalsUI.tableIDField.positionOffset_X = 240;
            EditorSpawnsAnimalsUI.tableIDField.positionOffset_Y = 130;
            EditorSpawnsAnimalsUI.tableIDField.sizeOffset_X     = 200;
            EditorSpawnsAnimalsUI.tableIDField.sizeOffset_Y     = 30;
            SleekUInt16Field sleekUInt16Field = EditorSpawnsAnimalsUI.tableIDField;

            if (EditorSpawnsAnimalsUI.< > f__mg$cache8 == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cache8 = new TypedUInt16(EditorSpawnsAnimalsUI.onTableIDFieldTyped);
            }
            sleekUInt16Field.onTypedUInt16 = EditorSpawnsAnimalsUI.< > f__mg$cache8;
            EditorSpawnsAnimalsUI.tableIDField.addLabel(local.format("TableIDFieldLabelText"), ESleekSide.LEFT);
            EditorSpawnsAnimalsUI.spawnsScrollBox.add(EditorSpawnsAnimalsUI.tableIDField);
            EditorSpawnsAnimalsUI.tierNameField = new SleekField();
            EditorSpawnsAnimalsUI.tierNameField.positionOffset_X = 240;
            EditorSpawnsAnimalsUI.tierNameField.sizeOffset_X     = 200;
            EditorSpawnsAnimalsUI.tierNameField.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.tierNameField.maxLength        = 64;
            EditorSpawnsAnimalsUI.tierNameField.addLabel(local.format("TierNameFieldLabelText"), ESleekSide.LEFT);
            SleekField sleekField2 = EditorSpawnsAnimalsUI.tierNameField;

            if (EditorSpawnsAnimalsUI.< > f__mg$cache9 == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cache9 = new Typed(EditorSpawnsAnimalsUI.onTypedTierNameField);
            }
            sleekField2.onTyped = EditorSpawnsAnimalsUI.< > f__mg$cache9;
            EditorSpawnsAnimalsUI.spawnsScrollBox.add(EditorSpawnsAnimalsUI.tierNameField);
            EditorSpawnsAnimalsUI.addTierButton = new SleekButtonIcon((Texture2D)bundle.load("Add"));
            EditorSpawnsAnimalsUI.addTierButton.positionOffset_X = 240;
            EditorSpawnsAnimalsUI.addTierButton.sizeOffset_X     = 95;
            EditorSpawnsAnimalsUI.addTierButton.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.addTierButton.text             = local.format("AddTierButtonText");
            EditorSpawnsAnimalsUI.addTierButton.tooltip          = local.format("AddTierButtonTooltip");
            SleekButton sleekButton3 = EditorSpawnsAnimalsUI.addTierButton;

            if (EditorSpawnsAnimalsUI.< > f__mg$cacheA == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cacheA = new ClickedButton(EditorSpawnsAnimalsUI.onClickedAddTierButton);
            }
            sleekButton3.onClickedButton = EditorSpawnsAnimalsUI.< > f__mg$cacheA;
            EditorSpawnsAnimalsUI.spawnsScrollBox.add(EditorSpawnsAnimalsUI.addTierButton);
            EditorSpawnsAnimalsUI.removeTierButton = new SleekButtonIcon((Texture2D)bundle.load("Remove"));
            EditorSpawnsAnimalsUI.removeTierButton.positionOffset_X = 345;
            EditorSpawnsAnimalsUI.removeTierButton.sizeOffset_X     = 95;
            EditorSpawnsAnimalsUI.removeTierButton.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.removeTierButton.text             = local.format("RemoveTierButtonText");
            EditorSpawnsAnimalsUI.removeTierButton.tooltip          = local.format("RemoveTierButtonTooltip");
            SleekButton sleekButton4 = EditorSpawnsAnimalsUI.removeTierButton;

            if (EditorSpawnsAnimalsUI.< > f__mg$cacheB == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cacheB = new ClickedButton(EditorSpawnsAnimalsUI.onClickedRemoveTierButton);
            }
            sleekButton4.onClickedButton = EditorSpawnsAnimalsUI.< > f__mg$cacheB;
            EditorSpawnsAnimalsUI.spawnsScrollBox.add(EditorSpawnsAnimalsUI.removeTierButton);
            EditorSpawnsAnimalsUI.animalIDField = new SleekUInt16Field();
            EditorSpawnsAnimalsUI.animalIDField.positionOffset_X = 240;
            EditorSpawnsAnimalsUI.animalIDField.sizeOffset_X     = 200;
            EditorSpawnsAnimalsUI.animalIDField.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.animalIDField.addLabel(local.format("AnimalIDFieldLabelText"), ESleekSide.LEFT);
            EditorSpawnsAnimalsUI.spawnsScrollBox.add(EditorSpawnsAnimalsUI.animalIDField);
            EditorSpawnsAnimalsUI.addAnimalButton = new SleekButtonIcon((Texture2D)bundle.load("Add"));
            EditorSpawnsAnimalsUI.addAnimalButton.positionOffset_X = 240;
            EditorSpawnsAnimalsUI.addAnimalButton.sizeOffset_X     = 95;
            EditorSpawnsAnimalsUI.addAnimalButton.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.addAnimalButton.text             = local.format("AddAnimalButtonText");
            EditorSpawnsAnimalsUI.addAnimalButton.tooltip          = local.format("AddAnimalButtonTooltip");
            SleekButton sleekButton5 = EditorSpawnsAnimalsUI.addAnimalButton;

            if (EditorSpawnsAnimalsUI.< > f__mg$cacheC == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cacheC = new ClickedButton(EditorSpawnsAnimalsUI.onClickedAddAnimalButton);
            }
            sleekButton5.onClickedButton = EditorSpawnsAnimalsUI.< > f__mg$cacheC;
            EditorSpawnsAnimalsUI.spawnsScrollBox.add(EditorSpawnsAnimalsUI.addAnimalButton);
            EditorSpawnsAnimalsUI.removeAnimalButton = new SleekButtonIcon((Texture2D)bundle.load("Remove"));
            EditorSpawnsAnimalsUI.removeAnimalButton.positionOffset_X = 345;
            EditorSpawnsAnimalsUI.removeAnimalButton.sizeOffset_X     = 95;
            EditorSpawnsAnimalsUI.removeAnimalButton.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.removeAnimalButton.text             = local.format("RemoveAnimalButtonText");
            EditorSpawnsAnimalsUI.removeAnimalButton.tooltip          = local.format("RemoveAnimalButtonTooltip");
            SleekButton sleekButton6 = EditorSpawnsAnimalsUI.removeAnimalButton;

            if (EditorSpawnsAnimalsUI.< > f__mg$cacheD == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cacheD = new ClickedButton(EditorSpawnsAnimalsUI.onClickedRemoveAnimalButton);
            }
            sleekButton6.onClickedButton = EditorSpawnsAnimalsUI.< > f__mg$cacheD;
            EditorSpawnsAnimalsUI.spawnsScrollBox.add(EditorSpawnsAnimalsUI.removeAnimalButton);
            EditorSpawnsAnimalsUI.selectedBox = new SleekBox();
            EditorSpawnsAnimalsUI.selectedBox.positionOffset_X = -230;
            EditorSpawnsAnimalsUI.selectedBox.positionOffset_Y = 80;
            EditorSpawnsAnimalsUI.selectedBox.positionScale_X  = 1f;
            EditorSpawnsAnimalsUI.selectedBox.sizeOffset_X     = 230;
            EditorSpawnsAnimalsUI.selectedBox.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.selectedBox.addLabel(local.format("SelectionBoxLabelText"), ESleekSide.LEFT);
            EditorSpawnsAnimalsUI.container.add(EditorSpawnsAnimalsUI.selectedBox);
            EditorSpawnsAnimalsUI.updateSelection();
            EditorSpawnsAnimalsUI.radiusSlider = new SleekSlider();
            EditorSpawnsAnimalsUI.radiusSlider.positionOffset_Y = -100;
            EditorSpawnsAnimalsUI.radiusSlider.positionScale_Y  = 1f;
            EditorSpawnsAnimalsUI.radiusSlider.sizeOffset_X     = 200;
            EditorSpawnsAnimalsUI.radiusSlider.sizeOffset_Y     = 20;
            EditorSpawnsAnimalsUI.radiusSlider.state            = (float)(EditorSpawns.radius - EditorSpawns.MIN_REMOVE_SIZE) / (float)EditorSpawns.MAX_REMOVE_SIZE;
            EditorSpawnsAnimalsUI.radiusSlider.orientation      = ESleekOrientation.HORIZONTAL;
            EditorSpawnsAnimalsUI.radiusSlider.addLabel(local.format("RadiusSliderLabelText"), ESleekSide.RIGHT);
            SleekSlider sleekSlider = EditorSpawnsAnimalsUI.radiusSlider;

            if (EditorSpawnsAnimalsUI.< > f__mg$cacheE == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cacheE = new Dragged(EditorSpawnsAnimalsUI.onDraggedRadiusSlider);
            }
            sleekSlider.onDragged = EditorSpawnsAnimalsUI.< > f__mg$cacheE;
            EditorSpawnsAnimalsUI.container.add(EditorSpawnsAnimalsUI.radiusSlider);
            EditorSpawnsAnimalsUI.addButton = new SleekButtonIcon((Texture2D)bundle.load("Add"));
            EditorSpawnsAnimalsUI.addButton.positionOffset_Y = -70;
            EditorSpawnsAnimalsUI.addButton.positionScale_Y  = 1f;
            EditorSpawnsAnimalsUI.addButton.sizeOffset_X     = 200;
            EditorSpawnsAnimalsUI.addButton.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.addButton.text             = local.format("AddButtonText", new object[]
            {
                ControlsSettings.tool_0
            });
            EditorSpawnsAnimalsUI.addButton.tooltip = local.format("AddButtonTooltip");
            SleekButton sleekButton7 = EditorSpawnsAnimalsUI.addButton;

            if (EditorSpawnsAnimalsUI.< > f__mg$cacheF == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cacheF = new ClickedButton(EditorSpawnsAnimalsUI.onClickedAddButton);
            }
            sleekButton7.onClickedButton = EditorSpawnsAnimalsUI.< > f__mg$cacheF;
            EditorSpawnsAnimalsUI.container.add(EditorSpawnsAnimalsUI.addButton);
            EditorSpawnsAnimalsUI.removeButton = new SleekButtonIcon((Texture2D)bundle.load("Remove"));
            EditorSpawnsAnimalsUI.removeButton.positionOffset_Y = -30;
            EditorSpawnsAnimalsUI.removeButton.positionScale_Y  = 1f;
            EditorSpawnsAnimalsUI.removeButton.sizeOffset_X     = 200;
            EditorSpawnsAnimalsUI.removeButton.sizeOffset_Y     = 30;
            EditorSpawnsAnimalsUI.removeButton.text             = local.format("RemoveButtonText", new object[]
            {
                ControlsSettings.tool_1
            });
            EditorSpawnsAnimalsUI.removeButton.tooltip = local.format("RemoveButtonTooltip");
            SleekButton sleekButton8 = EditorSpawnsAnimalsUI.removeButton;

            if (EditorSpawnsAnimalsUI.< > f__mg$cache10 == null)
            {
                EditorSpawnsAnimalsUI.< > f__mg$cache10 = new ClickedButton(EditorSpawnsAnimalsUI.onClickedRemoveButton);
            }
            sleekButton8.onClickedButton = EditorSpawnsAnimalsUI.< > f__mg$cache10;
            EditorSpawnsAnimalsUI.container.add(EditorSpawnsAnimalsUI.removeButton);
            bundle.unload();
        }
Example #5
0
        // Token: 0x060026D9 RID: 9945 RVA: 0x000E60A4 File Offset: 0x000E44A4
        public static void updateScene()
        {
            if (!Dedicator.isDedicated)
            {
                if (!LoadingUI.hasInitSplashscreen)
                {
                    LoadingUI.hasInitSplashscreen = true;
                    if (OptionsSettings.splashscreen)
                    {
                        LoadingUI.loader.GetComponent <LoadingUI>().splashscreenMovieTexture.Play();
                        LoadingUI.loader.GetComponent <AudioSource>().Play();
                    }
                    LoadingUI.needsToCleanupAfterSplashscreen = true;
                }
                if (LoadingUI.backgroundImage == null)
                {
                    return;
                }
                if (LoadingUI.loadingImage == null)
                {
                    return;
                }
                LoadingUI.updateProgress(0f);
                Local local = Localization.read("/Menu/MenuTips.dat");
                byte  b;
                do
                {
                    b = (byte)UnityEngine.Random.Range(1, (int)(LoadingUI.TIP_COUNT + 1));
                }while (b == (byte)LoadingUI.tip);
                LoadingUI.tip = (ELoadingTip)b;
                string text;
                if (OptionsSettings.streamer && Provider.streamerNames != null && Provider.streamerNames.Count > 0 && Provider.streamerNames[0] == "Nelson AI")
                {
                    text = local.format("Streamer");
                }
                else
                {
                    switch (LoadingUI.tip)
                    {
                    case ELoadingTip.HOTKEY:
                        text = local.format("Hotkey");
                        break;

                    case ELoadingTip.EQUIP:
                        text = local.format("Equip", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.other)
                        });
                        break;

                    case ELoadingTip.DROP:
                        text = local.format("Drop", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.other)
                        });
                        break;

                    case ELoadingTip.SIRENS:
                        text = local.format("Sirens", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.other)
                        });
                        break;

                    case ELoadingTip.TRANSFORM:
                        text = local.format("Transform");
                        break;

                    case ELoadingTip.QUALITY:
                        text = local.format("Quality");
                        break;

                    case ELoadingTip.UMBRELLA:
                        text = local.format("Umbrella");
                        break;

                    case ELoadingTip.HEAL:
                        text = local.format("Heal");
                        break;

                    case ELoadingTip.ROTATE:
                        text = local.format("Rotate");
                        break;

                    case ELoadingTip.BASE:
                        text = local.format("Base");
                        break;

                    case ELoadingTip.DEQUIP:
                        text = local.format("Dequip", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.dequip)
                        });
                        break;

                    case ELoadingTip.NIGHTVISION:
                        text = local.format("Nightvision", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.vision)
                        });
                        break;

                    case ELoadingTip.TRANSFER:
                        text = local.format("Transfer", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.other)
                        });
                        break;

                    case ELoadingTip.SURFACE:
                        text = local.format("Surface", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.jump)
                        });
                        break;

                    case ELoadingTip.ARREST:
                        text = local.format("Arrest", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.leanLeft),
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.leanRight)
                        });
                        break;

                    case ELoadingTip.SAFEZONE:
                        text = local.format("Safezone");
                        break;

                    case ELoadingTip.CLAIM:
                        text = local.format("Claim");
                        break;

                    case ELoadingTip.GROUP:
                        text = local.format("Group");
                        break;

                    case ELoadingTip.MAP:
                        text = local.format("Map", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.map)
                        });
                        break;

                    case ELoadingTip.BEACON:
                        text = local.format("Beacon");
                        break;

                    case ELoadingTip.HORN:
                        text = local.format("Horn", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.primary)
                        });
                        break;

                    case ELoadingTip.LIGHTS:
                        text = local.format("Lights", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.secondary)
                        });
                        break;

                    case ELoadingTip.SNAP:
                        text = local.format("Snap", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.snap)
                        });
                        break;

                    case ELoadingTip.UPGRADE:
                        text = local.format("Upgrade", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.other)
                        });
                        break;

                    case ELoadingTip.GRAB:
                        text = local.format("Grab", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.other)
                        });
                        break;

                    case ELoadingTip.SKYCRANE:
                        text = local.format("Skycrane", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.other)
                        });
                        break;

                    case ELoadingTip.SEAT:
                        text = local.format("Seat");
                        break;

                    case ELoadingTip.RARITY:
                        text = local.format("Rarity");
                        break;

                    case ELoadingTip.ORIENTATION:
                        text = local.format("Orientation", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.rotate)
                        });
                        break;

                    case ELoadingTip.RED:
                        text = local.format("Red");
                        break;

                    case ELoadingTip.STEADY:
                        text = local.format("Steady", new object[]
                        {
                            MenuConfigurationControlsUI.getKeyCodeText(ControlsSettings.sprint)
                        });
                        break;

                    default:
                        text = "#" + LoadingUI.tip.ToString();
                        break;
                    }
                }
                LoadingUI.tipBox.text = ItemTool.filterRarityRichText(local.format("Tip", new object[]
                {
                    text
                }));
                if (Level.info != null)
                {
                    if (!LoadingUI.pickBackgroundImage(Level.info.path + "/Screenshots") && !LoadingUI.loadBackgroundImage(Level.info.path + "/Level.png"))
                    {
                        LoadingUI.pickBackgroundImage(ReadWrite.PATH + "/Screenshots");
                    }
                    Local local2 = Localization.tryRead(Level.info.path, false);
                    if (local2 != null)
                    {
                        if (Provider.isConnected)
                        {
                            string text2;
                            if (Provider.isServer)
                            {
                                text2 = LoadingUI.localization.format("Offline");
                            }
                            else
                            {
                                if (Provider.currentServerInfo.IsVACSecure)
                                {
                                    text2 = LoadingUI.localization.format("VAC_Secure");
                                }
                                else
                                {
                                    text2 = LoadingUI.localization.format("VAC_Insecure");
                                }
                                if (Provider.currentServerInfo.IsBattlEyeSecure)
                                {
                                    text2 = text2 + " + " + LoadingUI.localization.format("BattlEye_Secure");
                                }
                                else
                                {
                                    text2 = text2 + " + " + LoadingUI.localization.format("BattlEye_Insecure");
                                }
                            }
                            LoadingUI.loadingLabel.text = local2.format("Loading_Server", new object[]
                            {
                                (!OptionsSettings.streamer) ? Provider.currentServerInfo.name : LoadingUI.localization.format("Streamer"),
                                text2
                            });
                            if (Provider.mode == EGameMode.EASY)
                            {
                                LoadingUI.loadingImage.backgroundColor = Palette.COLOR_G;
                                LoadingUI.loadingImage.foregroundColor = Palette.COLOR_G;
                            }
                            else if (Provider.mode == EGameMode.HARD)
                            {
                                LoadingUI.loadingImage.backgroundColor = Palette.COLOR_R;
                                LoadingUI.loadingImage.foregroundColor = Palette.COLOR_R;
                            }
                            else
                            {
                                LoadingUI.loadingImage.backgroundColor = Color.white;
                                LoadingUI.loadingImage.foregroundColor = Color.white;
                            }
                        }
                        else
                        {
                            LoadingUI.loadingLabel.text            = local2.format("Loading_Editor");
                            LoadingUI.loadingImage.backgroundColor = Color.white;
                            LoadingUI.loadingImage.foregroundColor = Color.white;
                        }
                    }
                    else
                    {
                        LoadingUI.loadingLabel.text            = string.Empty;
                        LoadingUI.loadingImage.backgroundColor = Color.white;
                        LoadingUI.loadingImage.foregroundColor = Color.white;
                    }
                    int num = 0;
                    if (Level.info.configData.Creators.Length > 0 || Level.info.configData.Collaborators.Length > 0 || Level.info.configData.Thanks.Length > 0)
                    {
                        int    num2  = 0;
                        string text3 = string.Empty;
                        if (Level.info.configData.Creators.Length > 0)
                        {
                            text3 += LoadingUI.localization.format("Creators");
                            num2  += 15;
                            for (int i = 0; i < Level.info.configData.Creators.Length; i++)
                            {
                                text3 = text3 + "\n" + Level.info.configData.Creators[i];
                                num2 += 15;
                            }
                        }
                        if (Level.info.configData.Collaborators.Length > 0)
                        {
                            if (text3.Length > 0)
                            {
                                text3 += "\n\n";
                                num2  += 30;
                            }
                            text3 += LoadingUI.localization.format("Collaborators");
                            num2  += 15;
                            for (int j = 0; j < Level.info.configData.Collaborators.Length; j++)
                            {
                                text3 = text3 + "\n" + Level.info.configData.Collaborators[j];
                                num2 += 15;
                            }
                        }
                        if (Level.info.configData.Thanks.Length > 0)
                        {
                            if (text3.Length > 0)
                            {
                                text3 += "\n\n";
                                num2  += 30;
                            }
                            text3 += LoadingUI.localization.format("Thanks");
                            num2  += 15;
                            for (int k = 0; k < Level.info.configData.Thanks.Length; k++)
                            {
                                text3 = text3 + "\n" + Level.info.configData.Thanks[k];
                                num2 += 15;
                            }
                        }
                        num2 = Mathf.Max(num2, 40);
                        LoadingUI.creditsBox.positionOffset_Y = -num2 / 2;
                        LoadingUI.creditsBox.sizeOffset_Y     = num2;
                        LoadingUI.creditsBox.text             = text3;
                        LoadingUI.creditsBox.isVisible        = true;
                        num = num2 / 2 + 10;
                    }
                    else
                    {
                        LoadingUI.creditsBox.isVisible = false;
                    }
                    if (Level.info.configData.Category == ESingleplayerMapCategory.CURATED && Level.info.configData.CuratedMapMode == ECuratedMapMode.TIMED)
                    {
                        LoadingUI.timedBox.positionOffset_Y = num;
                        LoadingUI.timedBox.text             = MenuPlaySingleplayerUI.localization.format("Timed_Text", new object[]
                        {
                            MenuPlaySingleplayerUI.localization.format("Curated_Map_Timestamp", new object[]
                            {
                                Level.info.configData.getCuratedMapTimestamp().ToString(MenuPlaySingleplayerUI.localization.format("Curated_Map_Timestamp_Format"))
                            })
                        });
                        LoadingUI.timedBox.isVisible = true;
                        num += LoadingUI.timedBox.sizeOffset_Y + 10;
                    }
                    else
                    {
                        LoadingUI.timedBox.isVisible = false;
                    }
                }
                else
                {
                    LoadingUI.pickBackgroundImage(ReadWrite.PATH + "/Screenshots");
                    LoadingUI.loadingLabel.text            = LoadingUI.localization.format("Loading");
                    LoadingUI.loadingImage.backgroundColor = Color.white;
                    LoadingUI.loadingImage.foregroundColor = Color.white;
                    LoadingUI.creditsBox.isVisible         = false;
                    LoadingUI.timedBox.isVisible           = false;
                }
                LoadingUI.loadingBox.sizeOffset_X = -20;
                LoadingUI.cancelButton.isVisible  = false;
            }
        }
        public PlayerBarricadeSignUI()
        {
            Local local = Localization.read("/Player/PlayerBarricadeSign.dat");

            PlayerBarricadeSignUI.container = new Sleek();
            PlayerBarricadeSignUI.container.positionScale_Y  = 1f;
            PlayerBarricadeSignUI.container.positionOffset_X = 10;
            PlayerBarricadeSignUI.container.positionOffset_Y = 10;
            PlayerBarricadeSignUI.container.sizeOffset_X     = -20;
            PlayerBarricadeSignUI.container.sizeOffset_Y     = -20;
            PlayerBarricadeSignUI.container.sizeScale_X      = 1f;
            PlayerBarricadeSignUI.container.sizeScale_Y      = 1f;
            PlayerUI.container.add(PlayerBarricadeSignUI.container);
            PlayerBarricadeSignUI.active    = false;
            PlayerBarricadeSignUI.sign      = null;
            PlayerBarricadeSignUI.textField = new SleekField();
            PlayerBarricadeSignUI.textField.positionOffset_X = -200;
            PlayerBarricadeSignUI.textField.positionScale_X  = 0.5f;
            PlayerBarricadeSignUI.textField.positionScale_Y  = 0.1f;
            PlayerBarricadeSignUI.textField.sizeOffset_X     = 400;
            PlayerBarricadeSignUI.textField.sizeScale_Y      = 0.8f;
            PlayerBarricadeSignUI.textField.maxLength        = 200;
            PlayerBarricadeSignUI.textField.multiline        = true;
            PlayerBarricadeSignUI.container.add(PlayerBarricadeSignUI.textField);
            PlayerBarricadeSignUI.textBox = new SleekBox();
            PlayerBarricadeSignUI.textBox.positionOffset_X = -200;
            PlayerBarricadeSignUI.textBox.positionScale_X  = 0.5f;
            PlayerBarricadeSignUI.textBox.positionScale_Y  = 0.1f;
            PlayerBarricadeSignUI.textBox.sizeOffset_X     = 400;
            PlayerBarricadeSignUI.textBox.sizeScale_Y      = 0.8f;
            PlayerBarricadeSignUI.container.add(PlayerBarricadeSignUI.textBox);
            PlayerBarricadeSignUI.yesButton = new SleekButton();
            PlayerBarricadeSignUI.yesButton.positionOffset_X = -200;
            PlayerBarricadeSignUI.yesButton.positionOffset_Y = 5;
            PlayerBarricadeSignUI.yesButton.positionScale_X  = 0.5f;
            PlayerBarricadeSignUI.yesButton.positionScale_Y  = 0.9f;
            PlayerBarricadeSignUI.yesButton.sizeOffset_X     = 195;
            PlayerBarricadeSignUI.yesButton.sizeOffset_Y     = 30;
            PlayerBarricadeSignUI.yesButton.text             = local.format("Yes_Button");
            PlayerBarricadeSignUI.yesButton.tooltip          = local.format("Yes_Button_Tooltip");
            SleekButton sleekButton = PlayerBarricadeSignUI.yesButton;

            if (PlayerBarricadeSignUI.< > f__mg$cache0 == null)
            {
                PlayerBarricadeSignUI.< > f__mg$cache0 = new ClickedButton(PlayerBarricadeSignUI.onClickedYesButton);
            }
            sleekButton.onClickedButton = PlayerBarricadeSignUI.< > f__mg$cache0;
            PlayerBarricadeSignUI.container.add(PlayerBarricadeSignUI.yesButton);
            PlayerBarricadeSignUI.noButton = new SleekButton();
            PlayerBarricadeSignUI.noButton.positionOffset_X = 5;
            PlayerBarricadeSignUI.noButton.positionOffset_Y = 5;
            PlayerBarricadeSignUI.noButton.positionScale_X  = 0.5f;
            PlayerBarricadeSignUI.noButton.positionScale_Y  = 0.9f;
            PlayerBarricadeSignUI.noButton.sizeOffset_X     = 195;
            PlayerBarricadeSignUI.noButton.sizeOffset_Y     = 30;
            PlayerBarricadeSignUI.noButton.text             = local.format("No_Button");
            PlayerBarricadeSignUI.noButton.tooltip          = local.format("No_Button_Tooltip");
            SleekButton sleekButton2 = PlayerBarricadeSignUI.noButton;

            if (PlayerBarricadeSignUI.< > f__mg$cache1 == null)
            {
                PlayerBarricadeSignUI.< > f__mg$cache1 = new ClickedButton(PlayerBarricadeSignUI.onClickedNoButton);
            }
            sleekButton2.onClickedButton = PlayerBarricadeSignUI.< > f__mg$cache1;
            PlayerBarricadeSignUI.container.add(PlayerBarricadeSignUI.noButton);
        }
        // Token: 0x06003708 RID: 14088 RVA: 0x0017D1E4 File Offset: 0x0017B5E4
        public MenuPlayUI()
        {
            Local  local  = Localization.read("/Menu/Play/MenuPlay.dat");
            Bundle bundle = Bundles.getBundle("/Bundles/Textures/Menu/Icons/Play/MenuPlay/MenuPlay.unity3d");

            MenuPlayUI.container = new Sleek();
            MenuPlayUI.container.positionOffset_X = 10;
            MenuPlayUI.container.positionOffset_Y = 10;
            MenuPlayUI.container.positionScale_Y  = -1f;
            MenuPlayUI.container.sizeOffset_X     = -20;
            MenuPlayUI.container.sizeOffset_Y     = -20;
            MenuPlayUI.container.sizeScale_X      = 1f;
            MenuPlayUI.container.sizeScale_Y      = 1f;
            MenuUI.container.add(MenuPlayUI.container);
            MenuPlayUI.active        = false;
            MenuPlayUI.connectButton = new SleekButtonIcon((Texture2D)bundle.load("Connect"));
            MenuPlayUI.connectButton.positionOffset_X         = -100;
            MenuPlayUI.connectButton.positionOffset_Y         = 95;
            MenuPlayUI.connectButton.positionScale_X          = 0.5f;
            MenuPlayUI.connectButton.positionScale_Y          = 0.5f;
            MenuPlayUI.connectButton.sizeOffset_X             = 200;
            MenuPlayUI.connectButton.sizeOffset_Y             = 50;
            MenuPlayUI.connectButton.text                     = local.format("ConnectButtonText");
            MenuPlayUI.connectButton.tooltip                  = local.format("ConnectButtonTooltip");
            MenuPlayUI.connectButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            SleekButton sleekButton = MenuPlayUI.connectButton;

            if (MenuPlayUI.< > f__mg$cache0 == null)
            {
                MenuPlayUI.< > f__mg$cache0 = new ClickedButton(MenuPlayUI.onClickedConnectButton);
            }
            sleekButton.onClickedButton       = MenuPlayUI.< > f__mg$cache0;
            MenuPlayUI.connectButton.fontSize = 14;
            MenuPlayUI.container.add(MenuPlayUI.connectButton);
            MenuPlayUI.serversButton = new SleekButtonIcon((Texture2D)bundle.load("Servers"));
            MenuPlayUI.serversButton.positionOffset_X         = -100;
            MenuPlayUI.serversButton.positionOffset_Y         = 35;
            MenuPlayUI.serversButton.positionScale_X          = 0.5f;
            MenuPlayUI.serversButton.positionScale_Y          = 0.5f;
            MenuPlayUI.serversButton.sizeOffset_X             = 200;
            MenuPlayUI.serversButton.sizeOffset_Y             = 50;
            MenuPlayUI.serversButton.text                     = local.format("ServersButtonText");
            MenuPlayUI.serversButton.tooltip                  = local.format("ServersButtonTooltip");
            MenuPlayUI.serversButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            SleekButton sleekButton2 = MenuPlayUI.serversButton;

            if (MenuPlayUI.< > f__mg$cache1 == null)
            {
                MenuPlayUI.< > f__mg$cache1 = new ClickedButton(MenuPlayUI.onClickedServersButton);
            }
            sleekButton2.onClickedButton      = MenuPlayUI.< > f__mg$cache1;
            MenuPlayUI.serversButton.fontSize = 14;
            MenuPlayUI.container.add(MenuPlayUI.serversButton);
            MenuPlayUI.singleplayerButton = new SleekButtonIcon((Texture2D)bundle.load("Singleplayer"));
            MenuPlayUI.singleplayerButton.positionOffset_X = -100;
            MenuPlayUI.singleplayerButton.positionOffset_Y = -145;
            MenuPlayUI.singleplayerButton.positionScale_X  = 0.5f;
            MenuPlayUI.singleplayerButton.positionScale_Y  = 0.5f;
            MenuPlayUI.singleplayerButton.sizeOffset_X     = 200;
            MenuPlayUI.singleplayerButton.sizeOffset_Y     = 50;
            MenuPlayUI.singleplayerButton.text             = local.format("SingleplayerButtonText");
            MenuPlayUI.singleplayerButton.tooltip          = local.format("SingleplayerButtonTooltip");
            SleekButton sleekButton3 = MenuPlayUI.singleplayerButton;

            if (MenuPlayUI.< > f__mg$cache2 == null)
            {
                MenuPlayUI.< > f__mg$cache2 = new ClickedButton(MenuPlayUI.onClickedSingleplayerButton);
            }
            sleekButton3.onClickedButton = MenuPlayUI.< > f__mg$cache2;
            MenuPlayUI.singleplayerButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            MenuPlayUI.singleplayerButton.fontSize = 14;
            MenuPlayUI.container.add(MenuPlayUI.singleplayerButton);
            MenuPlayUI.matchmakingButton = new SleekButtonIcon((Texture2D)bundle.load("Matchmaking"));
            MenuPlayUI.matchmakingButton.positionOffset_X = -100;
            MenuPlayUI.matchmakingButton.positionOffset_Y = -85;
            MenuPlayUI.matchmakingButton.positionScale_X  = 0.5f;
            MenuPlayUI.matchmakingButton.positionScale_Y  = 0.5f;
            MenuPlayUI.matchmakingButton.sizeOffset_X     = 200;
            MenuPlayUI.matchmakingButton.sizeOffset_Y     = 50;
            MenuPlayUI.matchmakingButton.text             = local.format("MatchmakingButtonText");
            MenuPlayUI.matchmakingButton.tooltip          = local.format("MatchmakingButtonTooltip");
            SleekButton sleekButton4 = MenuPlayUI.matchmakingButton;

            if (MenuPlayUI.< > f__mg$cache3 == null)
            {
                MenuPlayUI.< > f__mg$cache3 = new ClickedButton(MenuPlayUI.onClickedMatchmakingButton);
            }
            sleekButton4.onClickedButton = MenuPlayUI.< > f__mg$cache3;
            MenuPlayUI.matchmakingButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            MenuPlayUI.matchmakingButton.fontSize = 14;
            MenuPlayUI.container.add(MenuPlayUI.matchmakingButton);
            MenuPlayUI.lobbiesButton = new SleekButtonIcon((Texture2D)bundle.load("Lobbies"));
            MenuPlayUI.lobbiesButton.positionOffset_X = -100;
            MenuPlayUI.lobbiesButton.positionOffset_Y = -25;
            MenuPlayUI.lobbiesButton.positionScale_X  = 0.5f;
            MenuPlayUI.lobbiesButton.positionScale_Y  = 0.5f;
            MenuPlayUI.lobbiesButton.sizeOffset_X     = 200;
            MenuPlayUI.lobbiesButton.sizeOffset_Y     = 50;
            MenuPlayUI.lobbiesButton.text             = local.format("LobbiesButtonText");
            MenuPlayUI.lobbiesButton.tooltip          = local.format("LobbiesButtonTooltip");
            SleekButton sleekButton5 = MenuPlayUI.lobbiesButton;

            if (MenuPlayUI.< > f__mg$cache4 == null)
            {
                MenuPlayUI.< > f__mg$cache4 = new ClickedButton(MenuPlayUI.onClickedLobbiesButton);
            }
            sleekButton5.onClickedButton = MenuPlayUI.< > f__mg$cache4;
            MenuPlayUI.lobbiesButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            MenuPlayUI.lobbiesButton.fontSize = 14;
            MenuPlayUI.container.add(MenuPlayUI.lobbiesButton);
            MenuPlayUI.tutorialButton = new SleekButtonIcon((Texture2D)bundle.load("Tutorial"));
            MenuPlayUI.tutorialButton.positionOffset_X = -100;
            MenuPlayUI.tutorialButton.positionOffset_Y = -205;
            MenuPlayUI.tutorialButton.positionScale_X  = 0.5f;
            MenuPlayUI.tutorialButton.positionScale_Y  = 0.5f;
            MenuPlayUI.tutorialButton.sizeOffset_X     = 200;
            MenuPlayUI.tutorialButton.sizeOffset_Y     = 50;
            MenuPlayUI.tutorialButton.text             = local.format("TutorialButtonText");
            MenuPlayUI.tutorialButton.tooltip          = local.format("TutorialButtonTooltip");
            SleekButton sleekButton6 = MenuPlayUI.tutorialButton;

            if (MenuPlayUI.< > f__mg$cache5 == null)
            {
                MenuPlayUI.< > f__mg$cache5 = new ClickedButton(MenuPlayUI.onClickedTutorialButton);
            }
            sleekButton6.onClickedButton       = MenuPlayUI.< > f__mg$cache5;
            MenuPlayUI.tutorialButton.fontSize = 14;
            MenuPlayUI.tutorialButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            MenuPlayUI.container.add(MenuPlayUI.tutorialButton);
            MenuPlayUI.backButton = new SleekButtonIcon((Texture2D)MenuDashboardUI.icons.load("Exit"));
            MenuPlayUI.backButton.positionOffset_X = -100;
            MenuPlayUI.backButton.positionOffset_Y = 155;
            MenuPlayUI.backButton.positionScale_X  = 0.5f;
            MenuPlayUI.backButton.positionScale_Y  = 0.5f;
            MenuPlayUI.backButton.sizeOffset_X     = 200;
            MenuPlayUI.backButton.sizeOffset_Y     = 50;
            MenuPlayUI.backButton.text             = MenuDashboardUI.localization.format("BackButtonText");
            MenuPlayUI.backButton.tooltip          = MenuDashboardUI.localization.format("BackButtonTooltip");
            SleekButton sleekButton7 = MenuPlayUI.backButton;

            if (MenuPlayUI.< > f__mg$cache6 == null)
            {
                MenuPlayUI.< > f__mg$cache6 = new ClickedButton(MenuPlayUI.onClickedBackButton);
            }
            sleekButton7.onClickedButton   = MenuPlayUI.< > f__mg$cache6;
            MenuPlayUI.backButton.fontSize = 14;
            MenuPlayUI.backButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            MenuPlayUI.container.add(MenuPlayUI.backButton);
            bundle.unload();
            new MenuPlayConnectUI();
            new MenuPlayServersUI();
            new MenuPlayServerInfoUI();
            new MenuPlaySingleplayerUI();
            new MenuPlayMatchmakingUI();
            new MenuPlayLobbiesUI();
        }
        // Token: 0x060034EC RID: 13548 RVA: 0x0015D980 File Offset: 0x0015BD80
        public EditorLevelObjectsUI()
        {
            Local  local  = Localization.read("/Editor/EditorLevelObjects.dat");
            Bundle bundle = Bundles.getBundle("/Bundles/Textures/Edit/Icons/EditorLevelObjects/EditorLevelObjects.unity3d");

            EditorLevelObjectsUI.container = new Sleek();
            EditorLevelObjectsUI.container.positionOffset_X = 10;
            EditorLevelObjectsUI.container.positionOffset_Y = 10;
            EditorLevelObjectsUI.container.positionScale_X  = 1f;
            EditorLevelObjectsUI.container.sizeOffset_X     = -20;
            EditorLevelObjectsUI.container.sizeOffset_Y     = -20;
            EditorLevelObjectsUI.container.sizeScale_X      = 1f;
            EditorLevelObjectsUI.container.sizeScale_Y      = 1f;
            EditorUI.window.add(EditorLevelObjectsUI.container);
            EditorLevelObjectsUI.active      = false;
            EditorLevelObjectsUI.assets      = new List <Asset>();
            EditorLevelObjectsUI.selectedBox = new SleekBox();
            EditorLevelObjectsUI.selectedBox.positionOffset_X = -230;
            EditorLevelObjectsUI.selectedBox.positionOffset_Y = 80;
            EditorLevelObjectsUI.selectedBox.positionScale_X  = 1f;
            EditorLevelObjectsUI.selectedBox.sizeOffset_X     = 230;
            EditorLevelObjectsUI.selectedBox.sizeOffset_Y     = 30;
            EditorLevelObjectsUI.selectedBox.addLabel(local.format("SelectionBoxLabelText"), ESleekSide.LEFT);
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.selectedBox);
            EditorLevelObjectsUI.searchField = new SleekField();
            EditorLevelObjectsUI.searchField.positionOffset_X = -230;
            EditorLevelObjectsUI.searchField.positionOffset_Y = 120;
            EditorLevelObjectsUI.searchField.positionScale_X  = 1f;
            EditorLevelObjectsUI.searchField.sizeOffset_X     = 160;
            EditorLevelObjectsUI.searchField.sizeOffset_Y     = 30;
            EditorLevelObjectsUI.searchField.hint             = local.format("Search_Field_Hint");
            EditorLevelObjectsUI.searchField.control          = "Search";
            SleekField sleekField = EditorLevelObjectsUI.searchField;

            if (EditorLevelObjectsUI.< > f__mg$cache1 == null)
            {
                EditorLevelObjectsUI.< > f__mg$cache1 = new Entered(EditorLevelObjectsUI.onEnteredSearchField);
            }
            sleekField.onEntered = EditorLevelObjectsUI.< > f__mg$cache1;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.searchField);
            EditorLevelObjectsUI.searchButton = new SleekButton();
            EditorLevelObjectsUI.searchButton.positionOffset_X = -60;
            EditorLevelObjectsUI.searchButton.positionOffset_Y = 120;
            EditorLevelObjectsUI.searchButton.positionScale_X  = 1f;
            EditorLevelObjectsUI.searchButton.sizeOffset_X     = 60;
            EditorLevelObjectsUI.searchButton.sizeOffset_Y     = 30;
            EditorLevelObjectsUI.searchButton.text             = local.format("Search");
            EditorLevelObjectsUI.searchButton.tooltip          = local.format("Search_Tooltip");
            SleekButton sleekButton = EditorLevelObjectsUI.searchButton;

            if (EditorLevelObjectsUI.< > f__mg$cache2 == null)
            {
                EditorLevelObjectsUI.< > f__mg$cache2 = new ClickedButton(EditorLevelObjectsUI.onClickedSearchButton);
            }
            sleekButton.onClickedButton = EditorLevelObjectsUI.< > f__mg$cache2;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.searchButton);
            EditorLevelObjectsUI.largeToggle = new SleekToggle();
            EditorLevelObjectsUI.largeToggle.positionOffset_X = -230;
            EditorLevelObjectsUI.largeToggle.positionOffset_Y = 160;
            EditorLevelObjectsUI.largeToggle.positionScale_X  = 1f;
            EditorLevelObjectsUI.largeToggle.sizeOffset_X     = 40;
            EditorLevelObjectsUI.largeToggle.sizeOffset_Y     = 40;
            EditorLevelObjectsUI.largeToggle.addLabel(local.format("LargeLabel"), ESleekSide.RIGHT);
            EditorLevelObjectsUI.largeToggle.state = true;
            SleekToggle sleekToggle = EditorLevelObjectsUI.largeToggle;

            if (EditorLevelObjectsUI.< > f__mg$cache3 == null)
            {
                EditorLevelObjectsUI.< > f__mg$cache3 = new Toggled(EditorLevelObjectsUI.onToggledLargeToggle);
            }
            sleekToggle.onToggled = EditorLevelObjectsUI.< > f__mg$cache3;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.largeToggle);
            EditorLevelObjectsUI.mediumToggle = new SleekToggle();
            EditorLevelObjectsUI.mediumToggle.positionOffset_X = -230;
            EditorLevelObjectsUI.mediumToggle.positionOffset_Y = 210;
            EditorLevelObjectsUI.mediumToggle.positionScale_X  = 1f;
            EditorLevelObjectsUI.mediumToggle.sizeOffset_X     = 40;
            EditorLevelObjectsUI.mediumToggle.sizeOffset_Y     = 40;
            EditorLevelObjectsUI.mediumToggle.addLabel(local.format("MediumLabel"), ESleekSide.RIGHT);
            EditorLevelObjectsUI.mediumToggle.state = true;
            SleekToggle sleekToggle2 = EditorLevelObjectsUI.mediumToggle;

            if (EditorLevelObjectsUI.< > f__mg$cache4 == null)
            {
                EditorLevelObjectsUI.< > f__mg$cache4 = new Toggled(EditorLevelObjectsUI.onToggledMediumToggle);
            }
            sleekToggle2.onToggled = EditorLevelObjectsUI.< > f__mg$cache4;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.mediumToggle);
            EditorLevelObjectsUI.smallToggle = new SleekToggle();
            EditorLevelObjectsUI.smallToggle.positionOffset_X = -230;
            EditorLevelObjectsUI.smallToggle.positionOffset_Y = 260;
            EditorLevelObjectsUI.smallToggle.positionScale_X  = 1f;
            EditorLevelObjectsUI.smallToggle.sizeOffset_X     = 40;
            EditorLevelObjectsUI.smallToggle.sizeOffset_Y     = 40;
            EditorLevelObjectsUI.smallToggle.addLabel(local.format("SmallLabel"), ESleekSide.RIGHT);
            EditorLevelObjectsUI.smallToggle.state = true;
            SleekToggle sleekToggle3 = EditorLevelObjectsUI.smallToggle;

            if (EditorLevelObjectsUI.< > f__mg$cache5 == null)
            {
                EditorLevelObjectsUI.< > f__mg$cache5 = new Toggled(EditorLevelObjectsUI.onToggledSmallToggle);
            }
            sleekToggle3.onToggled = EditorLevelObjectsUI.< > f__mg$cache5;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.smallToggle);
            EditorLevelObjectsUI.barricadesToggle = new SleekToggle();
            EditorLevelObjectsUI.barricadesToggle.positionOffset_X = -130;
            EditorLevelObjectsUI.barricadesToggle.positionOffset_Y = 160;
            EditorLevelObjectsUI.barricadesToggle.positionScale_X  = 1f;
            EditorLevelObjectsUI.barricadesToggle.sizeOffset_X     = 40;
            EditorLevelObjectsUI.barricadesToggle.sizeOffset_Y     = 40;
            EditorLevelObjectsUI.barricadesToggle.addLabel(local.format("BarricadesLabel"), ESleekSide.RIGHT);
            EditorLevelObjectsUI.barricadesToggle.state = true;
            SleekToggle sleekToggle4 = EditorLevelObjectsUI.barricadesToggle;

            if (EditorLevelObjectsUI.< > f__mg$cache6 == null)
            {
                EditorLevelObjectsUI.< > f__mg$cache6 = new Toggled(EditorLevelObjectsUI.onToggledBarricadesToggle);
            }
            sleekToggle4.onToggled = EditorLevelObjectsUI.< > f__mg$cache6;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.barricadesToggle);
            EditorLevelObjectsUI.structuresToggle = new SleekToggle();
            EditorLevelObjectsUI.structuresToggle.positionOffset_X = -130;
            EditorLevelObjectsUI.structuresToggle.positionOffset_Y = 210;
            EditorLevelObjectsUI.structuresToggle.positionScale_X  = 1f;
            EditorLevelObjectsUI.structuresToggle.sizeOffset_X     = 40;
            EditorLevelObjectsUI.structuresToggle.sizeOffset_Y     = 40;
            EditorLevelObjectsUI.structuresToggle.addLabel(local.format("StructuresLabel"), ESleekSide.RIGHT);
            EditorLevelObjectsUI.structuresToggle.state = true;
            SleekToggle sleekToggle5 = EditorLevelObjectsUI.structuresToggle;

            if (EditorLevelObjectsUI.< > f__mg$cache7 == null)
            {
                EditorLevelObjectsUI.< > f__mg$cache7 = new Toggled(EditorLevelObjectsUI.onToggledStructuresToggle);
            }
            sleekToggle5.onToggled = EditorLevelObjectsUI.< > f__mg$cache7;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.structuresToggle);
            EditorLevelObjectsUI.npcsToggle = new SleekToggle();
            EditorLevelObjectsUI.npcsToggle.positionOffset_X = -130;
            EditorLevelObjectsUI.npcsToggle.positionOffset_Y = 260;
            EditorLevelObjectsUI.npcsToggle.positionScale_X  = 1f;
            EditorLevelObjectsUI.npcsToggle.sizeOffset_X     = 40;
            EditorLevelObjectsUI.npcsToggle.sizeOffset_Y     = 40;
            EditorLevelObjectsUI.npcsToggle.addLabel(local.format("NPCsLabel"), ESleekSide.RIGHT);
            EditorLevelObjectsUI.npcsToggle.state = true;
            SleekToggle sleekToggle6 = EditorLevelObjectsUI.npcsToggle;

            if (EditorLevelObjectsUI.< > f__mg$cache8 == null)
            {
                EditorLevelObjectsUI.< > f__mg$cache8 = new Toggled(EditorLevelObjectsUI.onToggledNPCsToggle);
            }
            sleekToggle6.onToggled = EditorLevelObjectsUI.< > f__mg$cache8;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.npcsToggle);
            EditorLevelObjectsUI.assetsScrollBox = new SleekScrollBox();
            EditorLevelObjectsUI.assetsScrollBox.positionOffset_X = -230;
            EditorLevelObjectsUI.assetsScrollBox.positionOffset_Y = 310;
            EditorLevelObjectsUI.assetsScrollBox.positionScale_X  = 1f;
            EditorLevelObjectsUI.assetsScrollBox.sizeOffset_X     = 230;
            EditorLevelObjectsUI.assetsScrollBox.sizeOffset_Y     = -310;
            EditorLevelObjectsUI.assetsScrollBox.sizeScale_Y      = 1f;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.assetsScrollBox);
            EditorObjects.selectedObjectAsset = null;
            EditorObjects.selectedItemAsset   = null;
            if (EditorLevelObjectsUI.< > f__mg$cache9 == null)
            {
                EditorLevelObjectsUI.< > f__mg$cache9 = new DragStarted(EditorLevelObjectsUI.onDragStarted);
            }
            EditorObjects.onDragStarted = EditorLevelObjectsUI.< > f__mg$cache9;
            if (EditorLevelObjectsUI.< > f__mg$cacheA == null)
            {
                EditorLevelObjectsUI.< > f__mg$cacheA = new DragStopped(EditorLevelObjectsUI.onDragStopped);
            }
            EditorObjects.onDragStopped  = EditorLevelObjectsUI.< > f__mg$cacheA;
            EditorLevelObjectsUI.dragBox = new SleekBox();
            EditorUI.window.add(EditorLevelObjectsUI.dragBox);
            EditorLevelObjectsUI.dragBox.isVisible  = false;
            EditorLevelObjectsUI.snapTransformField = new SleekSingleField();
            EditorLevelObjectsUI.snapTransformField.positionOffset_Y = -230;
            EditorLevelObjectsUI.snapTransformField.positionScale_Y  = 1f;
            EditorLevelObjectsUI.snapTransformField.sizeOffset_X     = 200;
            EditorLevelObjectsUI.snapTransformField.sizeOffset_Y     = 30;
            EditorLevelObjectsUI.snapTransformField.text             = (Mathf.Floor(EditorObjects.snapTransform * 100f) / 100f).ToString();
            EditorLevelObjectsUI.snapTransformField.addLabel(local.format("SnapTransformLabelText"), ESleekSide.RIGHT);
            SleekSingleField sleekSingleField = EditorLevelObjectsUI.snapTransformField;

            if (EditorLevelObjectsUI.< > f__mg$cacheB == null)
            {
                EditorLevelObjectsUI.< > f__mg$cacheB = new TypedSingle(EditorLevelObjectsUI.onTypedSnapTransformField);
            }
            sleekSingleField.onTypedSingle = EditorLevelObjectsUI.< > f__mg$cacheB;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.snapTransformField);
            EditorLevelObjectsUI.snapRotationField = new SleekSingleField();
            EditorLevelObjectsUI.snapRotationField.positionOffset_Y = -190;
            EditorLevelObjectsUI.snapRotationField.positionScale_Y  = 1f;
            EditorLevelObjectsUI.snapRotationField.sizeOffset_X     = 200;
            EditorLevelObjectsUI.snapRotationField.sizeOffset_Y     = 30;
            EditorLevelObjectsUI.snapRotationField.text             = (Mathf.Floor(EditorObjects.snapRotation * 100f) / 100f).ToString();
            EditorLevelObjectsUI.snapRotationField.addLabel(local.format("SnapRotationLabelText"), ESleekSide.RIGHT);
            SleekSingleField sleekSingleField2 = EditorLevelObjectsUI.snapRotationField;

            if (EditorLevelObjectsUI.< > f__mg$cacheC == null)
            {
                EditorLevelObjectsUI.< > f__mg$cacheC = new TypedSingle(EditorLevelObjectsUI.onTypedSnapRotationField);
            }
            sleekSingleField2.onTypedSingle = EditorLevelObjectsUI.< > f__mg$cacheC;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.snapRotationField);
            EditorLevelObjectsUI.transformButton = new SleekButtonIcon((Texture2D)bundle.load("Transform"));
            EditorLevelObjectsUI.transformButton.positionOffset_Y = -150;
            EditorLevelObjectsUI.transformButton.positionScale_Y  = 1f;
            EditorLevelObjectsUI.transformButton.sizeOffset_X     = 200;
            EditorLevelObjectsUI.transformButton.sizeOffset_Y     = 30;
            EditorLevelObjectsUI.transformButton.text             = local.format("TransformButtonText", new object[]
            {
                ControlsSettings.tool_0
            });
            EditorLevelObjectsUI.transformButton.tooltip = local.format("TransformButtonTooltip");
            SleekButton sleekButton2 = EditorLevelObjectsUI.transformButton;

            if (EditorLevelObjectsUI.< > f__mg$cacheD == null)
            {
                EditorLevelObjectsUI.< > f__mg$cacheD = new ClickedButton(EditorLevelObjectsUI.onClickedTransformButton);
            }
            sleekButton2.onClickedButton = EditorLevelObjectsUI.< > f__mg$cacheD;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.transformButton);
            EditorLevelObjectsUI.rotateButton = new SleekButtonIcon((Texture2D)bundle.load("Rotate"));
            EditorLevelObjectsUI.rotateButton.positionOffset_Y = -110;
            EditorLevelObjectsUI.rotateButton.positionScale_Y  = 1f;
            EditorLevelObjectsUI.rotateButton.sizeOffset_X     = 200;
            EditorLevelObjectsUI.rotateButton.sizeOffset_Y     = 30;
            EditorLevelObjectsUI.rotateButton.text             = local.format("RotateButtonText", new object[]
            {
                ControlsSettings.tool_1
            });
            EditorLevelObjectsUI.rotateButton.tooltip = local.format("RotateButtonTooltip");
            SleekButton sleekButton3 = EditorLevelObjectsUI.rotateButton;

            if (EditorLevelObjectsUI.< > f__mg$cacheE == null)
            {
                EditorLevelObjectsUI.< > f__mg$cacheE = new ClickedButton(EditorLevelObjectsUI.onClickedRotateButton);
            }
            sleekButton3.onClickedButton = EditorLevelObjectsUI.< > f__mg$cacheE;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.rotateButton);
            EditorLevelObjectsUI.scaleButton = new SleekButtonIcon((Texture2D)bundle.load("Scale"));
            EditorLevelObjectsUI.scaleButton.positionOffset_Y = -70;
            EditorLevelObjectsUI.scaleButton.positionScale_Y  = 1f;
            EditorLevelObjectsUI.scaleButton.sizeOffset_X     = 200;
            EditorLevelObjectsUI.scaleButton.sizeOffset_Y     = 30;
            EditorLevelObjectsUI.scaleButton.text             = local.format("ScaleButtonText", new object[]
            {
                ControlsSettings.tool_3
            });
            EditorLevelObjectsUI.scaleButton.tooltip = local.format("ScaleButtonTooltip");
            SleekButton sleekButton4 = EditorLevelObjectsUI.scaleButton;

            if (EditorLevelObjectsUI.< > f__mg$cacheF == null)
            {
                EditorLevelObjectsUI.< > f__mg$cacheF = new ClickedButton(EditorLevelObjectsUI.onClickedScaleButton);
            }
            sleekButton4.onClickedButton = EditorLevelObjectsUI.< > f__mg$cacheF;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.scaleButton);
            EditorLevelObjectsUI.coordinateButton = new SleekButtonState(new GUIContent[]
            {
                new GUIContent(local.format("CoordinateButtonTextGlobal"), (Texture)bundle.load("Global")),
                new GUIContent(local.format("CoordinateButtonTextLocal"), (Texture)bundle.load("Local"))
            });
            EditorLevelObjectsUI.coordinateButton.positionOffset_Y = -30;
            EditorLevelObjectsUI.coordinateButton.positionScale_Y  = 1f;
            EditorLevelObjectsUI.coordinateButton.sizeOffset_X     = 200;
            EditorLevelObjectsUI.coordinateButton.sizeOffset_Y     = 30;
            EditorLevelObjectsUI.coordinateButton.tooltip          = local.format("CoordinateButtonTooltip");
            SleekButtonState sleekButtonState = EditorLevelObjectsUI.coordinateButton;

            if (EditorLevelObjectsUI.< > f__mg$cache10 == null)
            {
                EditorLevelObjectsUI.< > f__mg$cache10 = new SwappedState(EditorLevelObjectsUI.onSwappedStateCoordinate);
            }
            sleekButtonState.onSwappedState = EditorLevelObjectsUI.< > f__mg$cache10;
            EditorLevelObjectsUI.container.add(EditorLevelObjectsUI.coordinateButton);
            bundle.unload();
            EditorLevelObjectsUI.onAssetsRefreshed();
            if (EditorLevelObjectsUI.< > f__mg$cache11 == null)
            {
                EditorLevelObjectsUI.< > f__mg$cache11 = new AssetsRefreshed(EditorLevelObjectsUI.onAssetsRefreshed);
            }
            Assets.onAssetsRefreshed = EditorLevelObjectsUI.< > f__mg$cache11;
        }
Example #9
0
        public EditorLevelPlayersUI()
        {
            Local  local  = Localization.read("/Editor/EditorLevelPlayers.dat");
            Bundle bundle = Bundles.getBundle("/Bundles/Textures/Edit/Icons/EditorLevelPlayers/EditorLevelPlayers.unity3d");

            EditorLevelPlayersUI.container = new Sleek();
            EditorLevelPlayersUI.container.positionOffset_X = 10;
            EditorLevelPlayersUI.container.positionOffset_Y = 10;
            EditorLevelPlayersUI.container.positionScale_X  = 1f;
            EditorLevelPlayersUI.container.sizeOffset_X     = -20;
            EditorLevelPlayersUI.container.sizeOffset_Y     = -20;
            EditorLevelPlayersUI.container.sizeScale_X      = 1f;
            EditorLevelPlayersUI.container.sizeScale_Y      = 1f;
            EditorUI.window.add(EditorLevelPlayersUI.container);
            EditorLevelPlayersUI.active    = false;
            EditorLevelPlayersUI.altToggle = new SleekToggle();
            EditorLevelPlayersUI.altToggle.positionOffset_Y = -180;
            EditorLevelPlayersUI.altToggle.positionScale_Y  = 1f;
            EditorLevelPlayersUI.altToggle.sizeOffset_X     = 40;
            EditorLevelPlayersUI.altToggle.sizeOffset_Y     = 40;
            EditorLevelPlayersUI.altToggle.state            = EditorSpawns.selectedAlt;
            EditorLevelPlayersUI.altToggle.addLabel(local.format("AltLabelText"), ESleekSide.RIGHT);
            SleekToggle sleekToggle = EditorLevelPlayersUI.altToggle;

            if (EditorLevelPlayersUI.< > f__mg$cache0 == null)
            {
                EditorLevelPlayersUI.< > f__mg$cache0 = new Toggled(EditorLevelPlayersUI.onToggledAltToggle);
            }
            sleekToggle.onToggled = EditorLevelPlayersUI.< > f__mg$cache0;
            EditorLevelPlayersUI.container.add(EditorLevelPlayersUI.altToggle);
            EditorLevelPlayersUI.radiusSlider = new SleekSlider();
            EditorLevelPlayersUI.radiusSlider.positionOffset_Y = -130;
            EditorLevelPlayersUI.radiusSlider.positionScale_Y  = 1f;
            EditorLevelPlayersUI.radiusSlider.sizeOffset_X     = 200;
            EditorLevelPlayersUI.radiusSlider.sizeOffset_Y     = 20;
            EditorLevelPlayersUI.radiusSlider.state            = (float)(EditorSpawns.radius - EditorSpawns.MIN_REMOVE_SIZE) / (float)EditorSpawns.MAX_REMOVE_SIZE;
            EditorLevelPlayersUI.radiusSlider.orientation      = ESleekOrientation.HORIZONTAL;
            EditorLevelPlayersUI.radiusSlider.addLabel(local.format("RadiusSliderLabelText"), ESleekSide.RIGHT);
            SleekSlider sleekSlider = EditorLevelPlayersUI.radiusSlider;

            if (EditorLevelPlayersUI.< > f__mg$cache1 == null)
            {
                EditorLevelPlayersUI.< > f__mg$cache1 = new Dragged(EditorLevelPlayersUI.onDraggedRadiusSlider);
            }
            sleekSlider.onDragged = EditorLevelPlayersUI.< > f__mg$cache1;
            EditorLevelPlayersUI.container.add(EditorLevelPlayersUI.radiusSlider);
            EditorLevelPlayersUI.rotationSlider = new SleekSlider();
            EditorLevelPlayersUI.rotationSlider.positionOffset_Y = -100;
            EditorLevelPlayersUI.rotationSlider.positionScale_Y  = 1f;
            EditorLevelPlayersUI.rotationSlider.sizeOffset_X     = 200;
            EditorLevelPlayersUI.rotationSlider.sizeOffset_Y     = 20;
            EditorLevelPlayersUI.rotationSlider.state            = EditorSpawns.rotation / 360f;
            EditorLevelPlayersUI.rotationSlider.orientation      = ESleekOrientation.HORIZONTAL;
            EditorLevelPlayersUI.rotationSlider.addLabel(local.format("RotationSliderLabelText"), ESleekSide.RIGHT);
            SleekSlider sleekSlider2 = EditorLevelPlayersUI.rotationSlider;

            if (EditorLevelPlayersUI.< > f__mg$cache2 == null)
            {
                EditorLevelPlayersUI.< > f__mg$cache2 = new Dragged(EditorLevelPlayersUI.onDraggedRotationSlider);
            }
            sleekSlider2.onDragged = EditorLevelPlayersUI.< > f__mg$cache2;
            EditorLevelPlayersUI.container.add(EditorLevelPlayersUI.rotationSlider);
            EditorLevelPlayersUI.addButton = new SleekButtonIcon((Texture2D)bundle.load("Add"));
            EditorLevelPlayersUI.addButton.positionOffset_Y = -70;
            EditorLevelPlayersUI.addButton.positionScale_Y  = 1f;
            EditorLevelPlayersUI.addButton.sizeOffset_X     = 200;
            EditorLevelPlayersUI.addButton.sizeOffset_Y     = 30;
            EditorLevelPlayersUI.addButton.text             = local.format("AddButtonText", new object[]
            {
                ControlsSettings.tool_0
            });
            EditorLevelPlayersUI.addButton.tooltip = local.format("AddButtonTooltip");
            SleekButton sleekButton = EditorLevelPlayersUI.addButton;

            if (EditorLevelPlayersUI.< > f__mg$cache3 == null)
            {
                EditorLevelPlayersUI.< > f__mg$cache3 = new ClickedButton(EditorLevelPlayersUI.onClickedAddButton);
            }
            sleekButton.onClickedButton = EditorLevelPlayersUI.< > f__mg$cache3;
            EditorLevelPlayersUI.container.add(EditorLevelPlayersUI.addButton);
            EditorLevelPlayersUI.removeButton = new SleekButtonIcon((Texture2D)bundle.load("Remove"));
            EditorLevelPlayersUI.removeButton.positionOffset_Y = -30;
            EditorLevelPlayersUI.removeButton.positionScale_Y  = 1f;
            EditorLevelPlayersUI.removeButton.sizeOffset_X     = 200;
            EditorLevelPlayersUI.removeButton.sizeOffset_Y     = 30;
            EditorLevelPlayersUI.removeButton.text             = local.format("RemoveButtonText", new object[]
            {
                ControlsSettings.tool_1
            });
            EditorLevelPlayersUI.removeButton.tooltip = local.format("RemoveButtonTooltip");
            SleekButton sleekButton2 = EditorLevelPlayersUI.removeButton;

            if (EditorLevelPlayersUI.< > f__mg$cache4 == null)
            {
                EditorLevelPlayersUI.< > f__mg$cache4 = new ClickedButton(EditorLevelPlayersUI.onClickedRemoveButton);
            }
            sleekButton2.onClickedButton = EditorLevelPlayersUI.< > f__mg$cache4;
            EditorLevelPlayersUI.container.add(EditorLevelPlayersUI.removeButton);
            bundle.unload();
        }
Example #10
0
        public EditorPauseUI()
        {
            Local  local  = Localization.read("/Editor/EditorPause.dat");
            Bundle bundle = Bundles.getBundle("/Bundles/Textures/Edit/Icons/EditorPause/EditorPause.unity3d");

            EditorPauseUI.container = new Sleek();
            EditorPauseUI.container.positionOffset_X = 10;
            EditorPauseUI.container.positionOffset_Y = 10;
            EditorPauseUI.container.positionScale_X  = 1f;
            EditorPauseUI.container.sizeOffset_X     = -20;
            EditorPauseUI.container.sizeOffset_Y     = -20;
            EditorPauseUI.container.sizeScale_X      = 1f;
            EditorPauseUI.container.sizeScale_Y      = 1f;
            EditorUI.window.add(EditorPauseUI.container);
            EditorPauseUI.active     = false;
            EditorPauseUI.saveButton = new SleekButtonIcon((Texture2D)bundle.load("Save"));
            EditorPauseUI.saveButton.positionOffset_X = -100;
            EditorPauseUI.saveButton.positionOffset_Y = -115;
            EditorPauseUI.saveButton.positionScale_X  = 0.5f;
            EditorPauseUI.saveButton.positionScale_Y  = 0.5f;
            EditorPauseUI.saveButton.sizeOffset_X     = 200;
            EditorPauseUI.saveButton.sizeOffset_Y     = 30;
            EditorPauseUI.saveButton.text             = local.format("Save_Button");
            EditorPauseUI.saveButton.tooltip          = local.format("Save_Button_Tooltip");
            SleekButton sleekButton = EditorPauseUI.saveButton;

            if (EditorPauseUI.< > f__mg$cache0 == null)
            {
                EditorPauseUI.< > f__mg$cache0 = new ClickedButton(EditorPauseUI.onClickedSaveButton);
            }
            sleekButton.onClickedButton = EditorPauseUI.< > f__mg$cache0;
            EditorPauseUI.container.add(EditorPauseUI.saveButton);
            EditorPauseUI.mapButton = new SleekButtonIcon((Texture2D)bundle.load("Map"));
            EditorPauseUI.mapButton.positionOffset_X = -100;
            EditorPauseUI.mapButton.positionOffset_Y = -75;
            EditorPauseUI.mapButton.positionScale_X  = 0.5f;
            EditorPauseUI.mapButton.positionScale_Y  = 0.5f;
            EditorPauseUI.mapButton.sizeOffset_X     = 200;
            EditorPauseUI.mapButton.sizeOffset_Y     = 30;
            EditorPauseUI.mapButton.text             = local.format("Map_Button");
            EditorPauseUI.mapButton.tooltip          = local.format("Map_Button_Tooltip");
            SleekButton sleekButton2 = EditorPauseUI.mapButton;

            if (EditorPauseUI.< > f__mg$cache1 == null)
            {
                EditorPauseUI.< > f__mg$cache1 = new ClickedButton(EditorPauseUI.onClickedMapButton);
            }
            sleekButton2.onClickedButton = EditorPauseUI.< > f__mg$cache1;
            EditorPauseUI.container.add(EditorPauseUI.mapButton);
            EditorPauseUI.chartButton = new SleekButtonIcon((Texture2D)bundle.load("Chart"));
            EditorPauseUI.chartButton.positionOffset_X = -100;
            EditorPauseUI.chartButton.positionOffset_Y = -35;
            EditorPauseUI.chartButton.positionScale_X  = 0.5f;
            EditorPauseUI.chartButton.positionScale_Y  = 0.5f;
            EditorPauseUI.chartButton.sizeOffset_X     = 200;
            EditorPauseUI.chartButton.sizeOffset_Y     = 30;
            EditorPauseUI.chartButton.text             = local.format("Chart_Button");
            EditorPauseUI.chartButton.tooltip          = local.format("Chart_Button_Tooltip");
            SleekButton sleekButton3 = EditorPauseUI.chartButton;

            if (EditorPauseUI.< > f__mg$cache2 == null)
            {
                EditorPauseUI.< > f__mg$cache2 = new ClickedButton(EditorPauseUI.onClickedChartButton);
            }
            sleekButton3.onClickedButton = EditorPauseUI.< > f__mg$cache2;
            EditorPauseUI.container.add(EditorPauseUI.chartButton);
            EditorPauseUI.legacyIDField = new SleekUInt16Field();
            EditorPauseUI.legacyIDField.positionOffset_X = -100;
            EditorPauseUI.legacyIDField.positionOffset_Y = 5;
            EditorPauseUI.legacyIDField.positionScale_X  = 0.5f;
            EditorPauseUI.legacyIDField.positionScale_Y  = 0.5f;
            EditorPauseUI.legacyIDField.sizeOffset_X     = 50;
            EditorPauseUI.legacyIDField.sizeOffset_Y     = 30;
            EditorPauseUI.container.add(EditorPauseUI.legacyIDField);
            EditorPauseUI.legacyButton = new SleekButton();
            EditorPauseUI.legacyButton.positionOffset_X = -40;
            EditorPauseUI.legacyButton.positionOffset_Y = 5;
            EditorPauseUI.legacyButton.positionScale_X  = 0.5f;
            EditorPauseUI.legacyButton.positionScale_Y  = 0.5f;
            EditorPauseUI.legacyButton.sizeOffset_X     = 140;
            EditorPauseUI.legacyButton.sizeOffset_Y     = 30;
            EditorPauseUI.legacyButton.text             = local.format("Legacy_Spawns");
            EditorPauseUI.legacyButton.tooltip          = local.format("Legacy_Spawns_Tooltip");
            SleekButton sleekButton4 = EditorPauseUI.legacyButton;

            if (EditorPauseUI.< > f__mg$cache3 == null)
            {
                EditorPauseUI.< > f__mg$cache3 = new ClickedButton(EditorPauseUI.onClickedLegacyButton);
            }
            sleekButton4.onClickedButton = EditorPauseUI.< > f__mg$cache3;
            EditorPauseUI.container.add(EditorPauseUI.legacyButton);
            EditorPauseUI.proxyIDField = new SleekUInt16Field();
            EditorPauseUI.proxyIDField.positionOffset_X = -100;
            EditorPauseUI.proxyIDField.positionOffset_Y = 45;
            EditorPauseUI.proxyIDField.positionScale_X  = 0.5f;
            EditorPauseUI.proxyIDField.positionScale_Y  = 0.5f;
            EditorPauseUI.proxyIDField.sizeOffset_X     = 50;
            EditorPauseUI.proxyIDField.sizeOffset_Y     = 30;
            EditorPauseUI.container.add(EditorPauseUI.proxyIDField);
            EditorPauseUI.proxyButton = new SleekButton();
            EditorPauseUI.proxyButton.positionOffset_X = -40;
            EditorPauseUI.proxyButton.positionOffset_Y = 45;
            EditorPauseUI.proxyButton.positionScale_X  = 0.5f;
            EditorPauseUI.proxyButton.positionScale_Y  = 0.5f;
            EditorPauseUI.proxyButton.sizeOffset_X     = 140;
            EditorPauseUI.proxyButton.sizeOffset_Y     = 30;
            EditorPauseUI.proxyButton.text             = local.format("Proxy_Spawns");
            EditorPauseUI.proxyButton.tooltip          = local.format("Proxy_Spawns_Tooltip");
            SleekButton sleekButton5 = EditorPauseUI.proxyButton;

            if (EditorPauseUI.< > f__mg$cache4 == null)
            {
                EditorPauseUI.< > f__mg$cache4 = new ClickedButton(EditorPauseUI.onClickedProxyButton);
            }
            sleekButton5.onClickedButton = EditorPauseUI.< > f__mg$cache4;
            EditorPauseUI.container.add(EditorPauseUI.proxyButton);
            EditorPauseUI.exitButton = new SleekButtonIcon((Texture2D)bundle.load("Exit"));
            EditorPauseUI.exitButton.positionOffset_X = -100;
            EditorPauseUI.exitButton.positionOffset_Y = 85;
            EditorPauseUI.exitButton.positionScale_X  = 0.5f;
            EditorPauseUI.exitButton.positionScale_Y  = 0.5f;
            EditorPauseUI.exitButton.sizeOffset_X     = 200;
            EditorPauseUI.exitButton.sizeOffset_Y     = 30;
            EditorPauseUI.exitButton.text             = local.format("Exit_Button");
            EditorPauseUI.exitButton.tooltip          = local.format("Exit_Button_Tooltip");
            SleekButton sleekButton6 = EditorPauseUI.exitButton;

            if (EditorPauseUI.< > f__mg$cache5 == null)
            {
                EditorPauseUI.< > f__mg$cache5 = new ClickedButton(EditorPauseUI.onClickedExitButton);
            }
            sleekButton6.onClickedButton = EditorPauseUI.< > f__mg$cache5;
            EditorPauseUI.container.add(EditorPauseUI.exitButton);
            bundle.unload();
        }
Example #11
0
 // Token: 0x06001A1D RID: 6685 RVA: 0x00093BCD File Offset: 0x00091FCD
 public ItemArrestStartAsset(Bundle bundle, Data data, Local localization, ushort id) : base(bundle, data, localization, id)
 {
     this._use      = (AudioClip)bundle.load("Use");
     this._strength = data.readUInt16("Strength");
     bundle.unload();
 }
Example #12
0
        public PlayerWorkzoneUI()
        {
            Local  local  = Localization.read("/Editor/EditorLevelObjects.dat");
            Bundle bundle = Bundles.getBundle("/Bundles/Textures/Edit/Icons/EditorLevelObjects/EditorLevelObjects.unity3d");

            PlayerWorkzoneUI.container = new Sleek();
            PlayerWorkzoneUI.container.positionOffset_X = 10;
            PlayerWorkzoneUI.container.positionOffset_Y = 10;
            PlayerWorkzoneUI.container.positionScale_X  = 1f;
            PlayerWorkzoneUI.container.sizeOffset_X     = -20;
            PlayerWorkzoneUI.container.sizeOffset_Y     = -20;
            PlayerWorkzoneUI.container.sizeScale_X      = 1f;
            PlayerWorkzoneUI.container.sizeScale_Y      = 1f;
            PlayerUI.window.add(PlayerWorkzoneUI.container);
            PlayerWorkzoneUI.active = false;
            PlayerWorkzone workzone = Player.player.workzone;

            if (PlayerWorkzoneUI.< > f__mg$cache0 == null)
            {
                PlayerWorkzoneUI.< > f__mg$cache0 = new DragStarted(PlayerWorkzoneUI.onDragStarted);
            }
            workzone.onDragStarted = PlayerWorkzoneUI.< > f__mg$cache0;
            PlayerWorkzone workzone2 = Player.player.workzone;

            if (PlayerWorkzoneUI.< > f__mg$cache1 == null)
            {
                PlayerWorkzoneUI.< > f__mg$cache1 = new DragStopped(PlayerWorkzoneUI.onDragStopped);
            }
            workzone2.onDragStopped  = PlayerWorkzoneUI.< > f__mg$cache1;
            PlayerWorkzoneUI.dragBox = new SleekBox();
            PlayerUI.window.add(PlayerWorkzoneUI.dragBox);
            PlayerWorkzoneUI.dragBox.isVisible  = false;
            PlayerWorkzoneUI.snapTransformField = new SleekSingleField();
            PlayerWorkzoneUI.snapTransformField.positionOffset_Y = -190;
            PlayerWorkzoneUI.snapTransformField.positionScale_Y  = 1f;
            PlayerWorkzoneUI.snapTransformField.sizeOffset_X     = 200;
            PlayerWorkzoneUI.snapTransformField.sizeOffset_Y     = 30;
            PlayerWorkzoneUI.snapTransformField.text             = (Mathf.Floor(Player.player.workzone.snapTransform * 100f) / 100f).ToString();
            PlayerWorkzoneUI.snapTransformField.addLabel(local.format("SnapTransformLabelText"), ESleekSide.RIGHT);
            SleekSingleField sleekSingleField = PlayerWorkzoneUI.snapTransformField;

            if (PlayerWorkzoneUI.< > f__mg$cache2 == null)
            {
                PlayerWorkzoneUI.< > f__mg$cache2 = new TypedSingle(PlayerWorkzoneUI.onTypedSnapTransformField);
            }
            sleekSingleField.onTypedSingle = PlayerWorkzoneUI.< > f__mg$cache2;
            PlayerWorkzoneUI.container.add(PlayerWorkzoneUI.snapTransformField);
            PlayerWorkzoneUI.snapRotationField = new SleekSingleField();
            PlayerWorkzoneUI.snapRotationField.positionOffset_Y = -150;
            PlayerWorkzoneUI.snapRotationField.positionScale_Y  = 1f;
            PlayerWorkzoneUI.snapRotationField.sizeOffset_X     = 200;
            PlayerWorkzoneUI.snapRotationField.sizeOffset_Y     = 30;
            PlayerWorkzoneUI.snapRotationField.text             = (Mathf.Floor(Player.player.workzone.snapRotation * 100f) / 100f).ToString();
            PlayerWorkzoneUI.snapRotationField.addLabel(local.format("SnapRotationLabelText"), ESleekSide.RIGHT);
            SleekSingleField sleekSingleField2 = PlayerWorkzoneUI.snapRotationField;

            if (PlayerWorkzoneUI.< > f__mg$cache3 == null)
            {
                PlayerWorkzoneUI.< > f__mg$cache3 = new TypedSingle(PlayerWorkzoneUI.onTypedSnapRotationField);
            }
            sleekSingleField2.onTypedSingle = PlayerWorkzoneUI.< > f__mg$cache3;
            PlayerWorkzoneUI.container.add(PlayerWorkzoneUI.snapRotationField);
            PlayerWorkzoneUI.transformButton = new SleekButtonIcon((Texture2D)bundle.load("Transform"));
            PlayerWorkzoneUI.transformButton.positionOffset_Y = -110;
            PlayerWorkzoneUI.transformButton.positionScale_Y  = 1f;
            PlayerWorkzoneUI.transformButton.sizeOffset_X     = 200;
            PlayerWorkzoneUI.transformButton.sizeOffset_Y     = 30;
            PlayerWorkzoneUI.transformButton.text             = local.format("TransformButtonText", new object[]
            {
                ControlsSettings.tool_0
            });
            PlayerWorkzoneUI.transformButton.tooltip = local.format("TransformButtonTooltip");
            SleekButton sleekButton = PlayerWorkzoneUI.transformButton;

            if (PlayerWorkzoneUI.< > f__mg$cache4 == null)
            {
                PlayerWorkzoneUI.< > f__mg$cache4 = new ClickedButton(PlayerWorkzoneUI.onClickedTransformButton);
            }
            sleekButton.onClickedButton = PlayerWorkzoneUI.< > f__mg$cache4;
            PlayerWorkzoneUI.container.add(PlayerWorkzoneUI.transformButton);
            PlayerWorkzoneUI.rotateButton = new SleekButtonIcon((Texture2D)bundle.load("Rotate"));
            PlayerWorkzoneUI.rotateButton.positionOffset_Y = -70;
            PlayerWorkzoneUI.rotateButton.positionScale_Y  = 1f;
            PlayerWorkzoneUI.rotateButton.sizeOffset_X     = 200;
            PlayerWorkzoneUI.rotateButton.sizeOffset_Y     = 30;
            PlayerWorkzoneUI.rotateButton.text             = local.format("RotateButtonText", new object[]
            {
                ControlsSettings.tool_1
            });
            PlayerWorkzoneUI.rotateButton.tooltip = local.format("RotateButtonTooltip");
            SleekButton sleekButton2 = PlayerWorkzoneUI.rotateButton;

            if (PlayerWorkzoneUI.< > f__mg$cache5 == null)
            {
                PlayerWorkzoneUI.< > f__mg$cache5 = new ClickedButton(PlayerWorkzoneUI.onClickedRotateButton);
            }
            sleekButton2.onClickedButton = PlayerWorkzoneUI.< > f__mg$cache5;
            PlayerWorkzoneUI.container.add(PlayerWorkzoneUI.rotateButton);
            PlayerWorkzoneUI.coordinateButton = new SleekButtonState(new GUIContent[]
            {
                new GUIContent(local.format("CoordinateButtonTextGlobal"), (Texture)bundle.load("Global")),
                new GUIContent(local.format("CoordinateButtonTextLocal"), (Texture)bundle.load("Local"))
            });
            PlayerWorkzoneUI.coordinateButton.positionOffset_Y = -30;
            PlayerWorkzoneUI.coordinateButton.positionScale_Y  = 1f;
            PlayerWorkzoneUI.coordinateButton.sizeOffset_X     = 200;
            PlayerWorkzoneUI.coordinateButton.sizeOffset_Y     = 30;
            PlayerWorkzoneUI.coordinateButton.tooltip          = local.format("CoordinateButtonTooltip");
            SleekButtonState sleekButtonState = PlayerWorkzoneUI.coordinateButton;

            if (PlayerWorkzoneUI.< > f__mg$cache6 == null)
            {
                PlayerWorkzoneUI.< > f__mg$cache6 = new SwappedState(PlayerWorkzoneUI.onSwappedStateCoordinate);
            }
            sleekButtonState.onSwappedState = PlayerWorkzoneUI.< > f__mg$cache6;
            PlayerWorkzoneUI.container.add(PlayerWorkzoneUI.coordinateButton);
            bundle.unload();
        }
Example #13
0
        // Token: 0x0600377D RID: 14205 RVA: 0x00184C9C File Offset: 0x0018309C
        public MenuWorkshopEditorUI()
        {
            if (MenuWorkshopEditorUI.icons != null)
            {
                MenuWorkshopEditorUI.icons.unload();
                MenuWorkshopEditorUI.icons = null;
            }
            Local local = Localization.read("/Menu/Workshop/MenuWorkshopEditor.dat");

            MenuWorkshopEditorUI.icons     = Bundles.getBundle("/Bundles/Textures/Menu/Icons/Workshop/MenuWorkshopEditor/MenuWorkshopEditor.unity3d");
            MenuWorkshopEditorUI.container = new Sleek();
            MenuWorkshopEditorUI.container.positionOffset_X = 10;
            MenuWorkshopEditorUI.container.positionOffset_Y = 10;
            MenuWorkshopEditorUI.container.positionScale_Y  = 1f;
            MenuWorkshopEditorUI.container.sizeOffset_X     = -20;
            MenuWorkshopEditorUI.container.sizeOffset_Y     = -20;
            MenuWorkshopEditorUI.container.sizeScale_X      = 1f;
            MenuWorkshopEditorUI.container.sizeScale_Y      = 1f;
            MenuUI.container.add(MenuWorkshopEditorUI.container);
            MenuWorkshopEditorUI.active     = false;
            MenuWorkshopEditorUI.previewBox = new SleekBox();
            MenuWorkshopEditorUI.previewBox.positionOffset_X = -305;
            MenuWorkshopEditorUI.previewBox.positionOffset_Y = 100;
            MenuWorkshopEditorUI.previewBox.positionScale_X  = 0.5f;
            MenuWorkshopEditorUI.previewBox.sizeOffset_X     = 340;
            MenuWorkshopEditorUI.previewBox.sizeOffset_Y     = 180;
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.previewBox);
            MenuWorkshopEditorUI.previewImage = new SleekImageTexture();
            MenuWorkshopEditorUI.previewImage.positionOffset_X     = 10;
            MenuWorkshopEditorUI.previewImage.positionOffset_Y     = 10;
            MenuWorkshopEditorUI.previewImage.sizeOffset_X         = -20;
            MenuWorkshopEditorUI.previewImage.sizeOffset_Y         = -20;
            MenuWorkshopEditorUI.previewImage.sizeScale_X          = 1f;
            MenuWorkshopEditorUI.previewImage.sizeScale_Y          = 1f;
            MenuWorkshopEditorUI.previewImage.shouldDestroyTexture = true;
            MenuWorkshopEditorUI.previewBox.add(MenuWorkshopEditorUI.previewImage);
            MenuWorkshopEditorUI.levelScrollBox = new SleekScrollBox();
            MenuWorkshopEditorUI.levelScrollBox.positionOffset_X = -95;
            MenuWorkshopEditorUI.levelScrollBox.positionOffset_Y = 290;
            MenuWorkshopEditorUI.levelScrollBox.positionScale_X  = 0.5f;
            MenuWorkshopEditorUI.levelScrollBox.sizeOffset_X     = 430;
            MenuWorkshopEditorUI.levelScrollBox.sizeOffset_Y     = -390;
            MenuWorkshopEditorUI.levelScrollBox.sizeScale_Y      = 1f;
            MenuWorkshopEditorUI.levelScrollBox.area             = new Rect(0f, 0f, 5f, 0f);
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.levelScrollBox);
            MenuWorkshopEditorUI.selectedBox = new SleekBox();
            MenuWorkshopEditorUI.selectedBox.positionOffset_X = 45;
            MenuWorkshopEditorUI.selectedBox.positionOffset_Y = 100;
            MenuWorkshopEditorUI.selectedBox.positionScale_X  = 0.5f;
            MenuWorkshopEditorUI.selectedBox.sizeOffset_X     = 260;
            MenuWorkshopEditorUI.selectedBox.sizeOffset_Y     = 30;
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.selectedBox);
            MenuWorkshopEditorUI.descriptionBox = new SleekBox();
            MenuWorkshopEditorUI.descriptionBox.positionOffset_X = 45;
            MenuWorkshopEditorUI.descriptionBox.positionOffset_Y = 140;
            MenuWorkshopEditorUI.descriptionBox.positionScale_X  = 0.5f;
            MenuWorkshopEditorUI.descriptionBox.sizeOffset_X     = 260;
            MenuWorkshopEditorUI.descriptionBox.sizeOffset_Y     = 140;
            MenuWorkshopEditorUI.descriptionBox.fontAlignment    = TextAnchor.UpperCenter;
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.descriptionBox);
            MenuWorkshopEditorUI.mapNameField = new SleekField();
            MenuWorkshopEditorUI.mapNameField.positionOffset_X = -305;
            MenuWorkshopEditorUI.mapNameField.positionOffset_Y = 370;
            MenuWorkshopEditorUI.mapNameField.positionScale_X  = 0.5f;
            MenuWorkshopEditorUI.mapNameField.sizeOffset_X     = 200;
            MenuWorkshopEditorUI.mapNameField.sizeOffset_Y     = 30;
            MenuWorkshopEditorUI.mapNameField.maxLength        = 24;
            MenuWorkshopEditorUI.mapNameField.addLabel(local.format("Name_Field_Label"), ESleekSide.LEFT);
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.mapNameField);
            MenuWorkshopEditorUI.mapSizeState = new SleekButtonState(new GUIContent[]
            {
                new GUIContent(MenuPlaySingleplayerUI.localization.format("Small")),
                new GUIContent(MenuPlaySingleplayerUI.localization.format("Medium")),
                new GUIContent(MenuPlaySingleplayerUI.localization.format("Large"))
            });
            MenuWorkshopEditorUI.mapSizeState.positionOffset_X = -305;
            MenuWorkshopEditorUI.mapSizeState.positionOffset_Y = 410;
            MenuWorkshopEditorUI.mapSizeState.positionScale_X  = 0.5f;
            MenuWorkshopEditorUI.mapSizeState.sizeOffset_X     = 200;
            MenuWorkshopEditorUI.mapSizeState.sizeOffset_Y     = 30;
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.mapSizeState);
            MenuWorkshopEditorUI.mapTypeState = new SleekButtonState(new GUIContent[]
            {
                new GUIContent(MenuPlaySingleplayerUI.localization.format("Survival")),
                new GUIContent(MenuPlaySingleplayerUI.localization.format("Arena"))
            });
            MenuWorkshopEditorUI.mapTypeState.positionOffset_X = -305;
            MenuWorkshopEditorUI.mapTypeState.positionOffset_Y = 450;
            MenuWorkshopEditorUI.mapTypeState.positionScale_X  = 0.5f;
            MenuWorkshopEditorUI.mapTypeState.sizeOffset_X     = 200;
            MenuWorkshopEditorUI.mapTypeState.sizeOffset_Y     = 30;
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.mapTypeState);
            MenuWorkshopEditorUI.addButton = new SleekButtonIcon((Texture2D)MenuWorkshopEditorUI.icons.load("Add"));
            MenuWorkshopEditorUI.addButton.positionOffset_X = -305;
            MenuWorkshopEditorUI.addButton.positionOffset_Y = 490;
            MenuWorkshopEditorUI.addButton.positionScale_X  = 0.5f;
            MenuWorkshopEditorUI.addButton.sizeOffset_X     = 200;
            MenuWorkshopEditorUI.addButton.sizeOffset_Y     = 30;
            MenuWorkshopEditorUI.addButton.text             = local.format("Add_Button");
            MenuWorkshopEditorUI.addButton.tooltip          = local.format("Add_Button_Tooltip");
            SleekButton sleekButton = MenuWorkshopEditorUI.addButton;

            if (MenuWorkshopEditorUI.< > f__mg$cache1 == null)
            {
                MenuWorkshopEditorUI.< > f__mg$cache1 = new ClickedButton(MenuWorkshopEditorUI.onClickedAddButton);
            }
            sleekButton.onClickedButton = MenuWorkshopEditorUI.< > f__mg$cache1;
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.addButton);
            MenuWorkshopEditorUI.removeButton = new SleekButtonIconConfirm((Texture2D)MenuWorkshopEditorUI.icons.load("Remove"), local.format("Remove_Button_Confirm"), local.format("Remove_Button_Confirm_Tooltip"), local.format("Remove_Button_Deny"), local.format("Remove_Button_Deny_Tooltip"));
            MenuWorkshopEditorUI.removeButton.positionOffset_X = -305;
            MenuWorkshopEditorUI.removeButton.positionOffset_Y = 530;
            MenuWorkshopEditorUI.removeButton.positionScale_X  = 0.5f;
            MenuWorkshopEditorUI.removeButton.sizeOffset_X     = 200;
            MenuWorkshopEditorUI.removeButton.sizeOffset_Y     = 30;
            MenuWorkshopEditorUI.removeButton.text             = local.format("Remove_Button");
            MenuWorkshopEditorUI.removeButton.tooltip          = local.format("Remove_Button_Tooltip");
            SleekButtonIconConfirm sleekButtonIconConfirm = MenuWorkshopEditorUI.removeButton;

            if (MenuWorkshopEditorUI.< > f__mg$cache2 == null)
            {
                MenuWorkshopEditorUI.< > f__mg$cache2 = new Confirm(MenuWorkshopEditorUI.onClickedRemoveButton);
            }
            sleekButtonIconConfirm.onConfirmed = MenuWorkshopEditorUI.< > f__mg$cache2;
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.removeButton);
            MenuWorkshopEditorUI.editButton = new SleekButtonIcon((Texture2D)MenuWorkshopEditorUI.icons.load("Edit"));
            MenuWorkshopEditorUI.editButton.positionOffset_X         = -305;
            MenuWorkshopEditorUI.editButton.positionOffset_Y         = 290;
            MenuWorkshopEditorUI.editButton.positionScale_X          = 0.5f;
            MenuWorkshopEditorUI.editButton.sizeOffset_X             = 200;
            MenuWorkshopEditorUI.editButton.sizeOffset_Y             = 30;
            MenuWorkshopEditorUI.editButton.text                     = local.format("Edit_Button");
            MenuWorkshopEditorUI.editButton.tooltip                  = local.format("Edit_Button_Tooltip");
            MenuWorkshopEditorUI.editButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            SleekButton sleekButton2 = MenuWorkshopEditorUI.editButton;

            if (MenuWorkshopEditorUI.< > f__mg$cache3 == null)
            {
                MenuWorkshopEditorUI.< > f__mg$cache3 = new ClickedButton(MenuWorkshopEditorUI.onClickedEditButton);
            }
            sleekButton2.onClickedButton = MenuWorkshopEditorUI.< > f__mg$cache3;
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.editButton);
            MenuWorkshopEditorUI.edit2Button = new SleekButtonIcon((Texture2D)MenuWorkshopEditorUI.icons.load("Edit"));
            MenuWorkshopEditorUI.edit2Button.positionOffset_X         = -305;
            MenuWorkshopEditorUI.edit2Button.positionOffset_Y         = 330;
            MenuWorkshopEditorUI.edit2Button.positionScale_X          = 0.5f;
            MenuWorkshopEditorUI.edit2Button.sizeOffset_X             = 200;
            MenuWorkshopEditorUI.edit2Button.sizeOffset_Y             = 30;
            MenuWorkshopEditorUI.edit2Button.text                     = local.format("Edit2_Button");
            MenuWorkshopEditorUI.edit2Button.tooltip                  = local.format("Edit2_Button_Tooltip");
            MenuWorkshopEditorUI.edit2Button.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            SleekButton sleekButton3 = MenuWorkshopEditorUI.edit2Button;

            if (MenuWorkshopEditorUI.< > f__mg$cache4 == null)
            {
                MenuWorkshopEditorUI.< > f__mg$cache4 = new ClickedButton(MenuWorkshopEditorUI.onClickedEdit2Button);
            }
            sleekButton3.onClickedButton = MenuWorkshopEditorUI.< > f__mg$cache4;
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.edit2Button);
            MenuWorkshopEditorUI.backButton = new SleekButtonIcon((Texture2D)MenuDashboardUI.icons.load("Exit"));
            MenuWorkshopEditorUI.backButton.positionOffset_Y = -50;
            MenuWorkshopEditorUI.backButton.positionScale_Y  = 1f;
            MenuWorkshopEditorUI.backButton.sizeOffset_X     = 200;
            MenuWorkshopEditorUI.backButton.sizeOffset_Y     = 50;
            MenuWorkshopEditorUI.backButton.text             = MenuDashboardUI.localization.format("BackButtonText");
            MenuWorkshopEditorUI.backButton.tooltip          = MenuDashboardUI.localization.format("BackButtonTooltip");
            SleekButton sleekButton4 = MenuWorkshopEditorUI.backButton;

            if (MenuWorkshopEditorUI.< > f__mg$cache5 == null)
            {
                MenuWorkshopEditorUI.< > f__mg$cache5 = new ClickedButton(MenuWorkshopEditorUI.onClickedBackButton);
            }
            sleekButton4.onClickedButton             = MenuWorkshopEditorUI.< > f__mg$cache5;
            MenuWorkshopEditorUI.backButton.fontSize = 14;
            MenuWorkshopEditorUI.backButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            MenuWorkshopEditorUI.container.add(MenuWorkshopEditorUI.backButton);
            MenuWorkshopEditorUI.onLevelsRefreshed();
            Delegate onLevelsRefreshed = Level.onLevelsRefreshed;

            if (MenuWorkshopEditorUI.< > f__mg$cache6 == null)
            {
                MenuWorkshopEditorUI.< > f__mg$cache6 = new LevelsRefreshed(MenuWorkshopEditorUI.onLevelsRefreshed);
            }
            Level.onLevelsRefreshed = (LevelsRefreshed)Delegate.Combine(onLevelsRefreshed, MenuWorkshopEditorUI.< > f__mg$cache6);
        }
Example #14
0
        public static void readRewards(Data data, Local localization, string prefix, INPCReward[] rewards)
        {
            for (int i = 0; i < rewards.Length; i++)
            {
                if (!data.has(prefix + i + "_Type"))
                {
                    throw new NotSupportedException("Missing reward type");
                }
                ENPCRewardType enpcrewardType = (ENPCRewardType)Enum.Parse(typeof(ENPCRewardType), data.readString(prefix + i + "_Type"), true);
                string         text           = localization.read(prefix + i);
                text = ItemTool.filterRarityRichText(text);
                switch (enpcrewardType)
                {
                case ENPCRewardType.EXPERIENCE:
                    rewards[i] = new NPCExperienceReward(data.readUInt32(prefix + i + "_Value"), text);
                    break;

                case ENPCRewardType.REPUTATION:
                    rewards[i] = new NPCReputationReward(data.readInt32(prefix + i + "_Value"), text);
                    break;

                case ENPCRewardType.FLAG_BOOL:
                    rewards[i] = new NPCBoolFlagReward(data.readUInt16(prefix + i + "_ID"), data.readBoolean(prefix + i + "_Value"), text);
                    break;

                case ENPCRewardType.FLAG_SHORT:
                    rewards[i] = new NPCShortFlagReward(data.readUInt16(prefix + i + "_ID"), data.readInt16(prefix + i + "_Value"), (ENPCModificationType)Enum.Parse(typeof(ENPCModificationType), data.readString(prefix + i + "_Modification"), true), text);
                    break;

                case ENPCRewardType.FLAG_SHORT_RANDOM:
                    rewards[i] = new NPCRandomShortFlagReward(data.readUInt16(prefix + i + "_ID"), data.readInt16(prefix + i + "_Min_Value"), data.readInt16(prefix + i + "_Max_Value"), (ENPCModificationType)Enum.Parse(typeof(ENPCModificationType), data.readString(prefix + i + "_Modification"), true), text);
                    break;

                case ENPCRewardType.QUEST:
                    rewards[i] = new NPCQuestReward(data.readUInt16(prefix + i + "_ID"), text);
                    break;

                case ENPCRewardType.ITEM:
                    rewards[i] = new NPCItemReward(data.readUInt16(prefix + i + "_ID"), data.readByte(prefix + i + "_Amount"), data.readUInt16(prefix + i + "_Sight"), data.readUInt16(prefix + i + "_Tactical"), data.readUInt16(prefix + i + "_Grip"), data.readUInt16(prefix + i + "_Barrel"), data.readUInt16(prefix + i + "_Magazine"), data.readByte(prefix + i + "_Ammo"), text);
                    break;

                case ENPCRewardType.ITEM_RANDOM:
                    rewards[i] = new NPCRandomItemReward(data.readUInt16(prefix + i + "_ID"), data.readByte(prefix + i + "_Amount"), text);
                    break;

                case ENPCRewardType.ACHIEVEMENT:
                    rewards[i] = new NPCAchievementReward(data.readString(prefix + i + "_ID"), text);
                    break;

                case ENPCRewardType.VEHICLE:
                    rewards[i] = new NPCVehicleReward(data.readUInt16(prefix + i + "_ID"), data.readString(prefix + i + "_Spawnpoint"), text);
                    break;

                case ENPCRewardType.TELEPORT:
                    rewards[i] = new NPCTeleportReward(data.readString(prefix + i + "_Spawnpoint"), text);
                    break;

                case ENPCRewardType.EVENT:
                    rewards[i] = new NPCEventReward(data.readString(prefix + i + "_ID"), text);
                    break;
                }
            }
        }
Example #15
0
        // Token: 0x06003775 RID: 14197 RVA: 0x001846A4 File Offset: 0x00182AA4
        public MenuSurvivorsUI()
        {
            Local  local  = Localization.read("/Menu/Survivors/MenuSurvivors.dat");
            Bundle bundle = Bundles.getBundle("/Bundles/Textures/Menu/Icons/Survivors/MenuSurvivors/MenuSurvivors.unity3d");

            MenuSurvivorsUI.container = new Sleek();
            MenuSurvivorsUI.container.positionOffset_X = 10;
            MenuSurvivorsUI.container.positionOffset_Y = 10;
            MenuSurvivorsUI.container.positionScale_Y  = -1f;
            MenuSurvivorsUI.container.sizeOffset_X     = -20;
            MenuSurvivorsUI.container.sizeOffset_Y     = -20;
            MenuSurvivorsUI.container.sizeScale_X      = 1f;
            MenuSurvivorsUI.container.sizeScale_Y      = 1f;
            MenuUI.container.add(MenuSurvivorsUI.container);
            MenuSurvivorsUI.active          = false;
            MenuSurvivorsUI.characterButton = new SleekButtonIcon((Texture2D)bundle.load("Character"));
            MenuSurvivorsUI.characterButton.positionOffset_X = -100;
            MenuSurvivorsUI.characterButton.positionOffset_Y = -145;
            MenuSurvivorsUI.characterButton.positionScale_X  = 0.5f;
            MenuSurvivorsUI.characterButton.positionScale_Y  = 0.5f;
            MenuSurvivorsUI.characterButton.sizeOffset_X     = 200;
            MenuSurvivorsUI.characterButton.sizeOffset_Y     = 50;
            MenuSurvivorsUI.characterButton.text             = local.format("CharacterButtonText");
            MenuSurvivorsUI.characterButton.tooltip          = local.format("CharacterButtonTooltip");
            SleekButton sleekButton = MenuSurvivorsUI.characterButton;

            if (MenuSurvivorsUI.< > f__mg$cache0 == null)
            {
                MenuSurvivorsUI.< > f__mg$cache0 = new ClickedButton(MenuSurvivorsUI.onClickedCharacterButton);
            }
            sleekButton.onClickedButton = MenuSurvivorsUI.< > f__mg$cache0;
            MenuSurvivorsUI.characterButton.fontSize = 14;
            MenuSurvivorsUI.characterButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            MenuSurvivorsUI.container.add(MenuSurvivorsUI.characterButton);
            MenuSurvivorsUI.appearanceButton = new SleekButtonIcon((Texture2D)bundle.load("Appearance"));
            MenuSurvivorsUI.appearanceButton.positionOffset_X = -100;
            MenuSurvivorsUI.appearanceButton.positionOffset_Y = -85;
            MenuSurvivorsUI.appearanceButton.positionScale_X  = 0.5f;
            MenuSurvivorsUI.appearanceButton.positionScale_Y  = 0.5f;
            MenuSurvivorsUI.appearanceButton.sizeOffset_X     = 200;
            MenuSurvivorsUI.appearanceButton.sizeOffset_Y     = 50;
            MenuSurvivorsUI.appearanceButton.text             = local.format("AppearanceButtonText");
            MenuSurvivorsUI.appearanceButton.tooltip          = local.format("AppearanceButtonTooltip");
            SleekButton sleekButton2 = MenuSurvivorsUI.appearanceButton;

            if (MenuSurvivorsUI.< > f__mg$cache1 == null)
            {
                MenuSurvivorsUI.< > f__mg$cache1 = new ClickedButton(MenuSurvivorsUI.onClickedAppearanceButton);
            }
            sleekButton2.onClickedButton = MenuSurvivorsUI.< > f__mg$cache1;
            MenuSurvivorsUI.appearanceButton.fontSize = 14;
            MenuSurvivorsUI.appearanceButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            MenuSurvivorsUI.container.add(MenuSurvivorsUI.appearanceButton);
            MenuSurvivorsUI.groupButton = new SleekButtonIcon((Texture2D)bundle.load("Group"));
            MenuSurvivorsUI.groupButton.positionOffset_X = -100;
            MenuSurvivorsUI.groupButton.positionOffset_Y = -25;
            MenuSurvivorsUI.groupButton.positionScale_X  = 0.5f;
            MenuSurvivorsUI.groupButton.positionScale_Y  = 0.5f;
            MenuSurvivorsUI.groupButton.sizeOffset_X     = 200;
            MenuSurvivorsUI.groupButton.sizeOffset_Y     = 50;
            MenuSurvivorsUI.groupButton.text             = local.format("GroupButtonText");
            MenuSurvivorsUI.groupButton.tooltip          = local.format("GroupButtonTooltip");
            SleekButton sleekButton3 = MenuSurvivorsUI.groupButton;

            if (MenuSurvivorsUI.< > f__mg$cache2 == null)
            {
                MenuSurvivorsUI.< > f__mg$cache2 = new ClickedButton(MenuSurvivorsUI.onClickedGroupButton);
            }
            sleekButton3.onClickedButton = MenuSurvivorsUI.< > f__mg$cache2;
            MenuSurvivorsUI.groupButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            MenuSurvivorsUI.groupButton.fontSize = 14;
            MenuSurvivorsUI.container.add(MenuSurvivorsUI.groupButton);
            MenuSurvivorsUI.clothingButton = new SleekButtonIcon((Texture2D)bundle.load("Clothing"));
            MenuSurvivorsUI.clothingButton.positionOffset_X = -100;
            MenuSurvivorsUI.clothingButton.positionOffset_Y = 35;
            MenuSurvivorsUI.clothingButton.positionScale_X  = 0.5f;
            MenuSurvivorsUI.clothingButton.positionScale_Y  = 0.5f;
            MenuSurvivorsUI.clothingButton.sizeOffset_X     = 200;
            MenuSurvivorsUI.clothingButton.sizeOffset_Y     = 50;
            MenuSurvivorsUI.clothingButton.text             = local.format("ClothingButtonText");
            MenuSurvivorsUI.clothingButton.tooltip          = local.format("ClothingButtonTooltip");
            SleekButton sleekButton4 = MenuSurvivorsUI.clothingButton;

            if (MenuSurvivorsUI.< > f__mg$cache3 == null)
            {
                MenuSurvivorsUI.< > f__mg$cache3 = new ClickedButton(MenuSurvivorsUI.onClickedClothingButton);
            }
            sleekButton4.onClickedButton            = MenuSurvivorsUI.< > f__mg$cache3;
            MenuSurvivorsUI.clothingButton.fontSize = 14;
            MenuSurvivorsUI.clothingButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            MenuSurvivorsUI.container.add(MenuSurvivorsUI.clothingButton);
            MenuSurvivorsUI.backButton = new SleekButtonIcon((Texture2D)MenuDashboardUI.icons.load("Exit"));
            MenuSurvivorsUI.backButton.positionOffset_X = -100;
            MenuSurvivorsUI.backButton.positionOffset_Y = 95;
            MenuSurvivorsUI.backButton.positionScale_X  = 0.5f;
            MenuSurvivorsUI.backButton.positionScale_Y  = 0.5f;
            MenuSurvivorsUI.backButton.sizeOffset_X     = 200;
            MenuSurvivorsUI.backButton.sizeOffset_Y     = 50;
            MenuSurvivorsUI.backButton.text             = MenuDashboardUI.localization.format("BackButtonText");
            MenuSurvivorsUI.backButton.tooltip          = MenuDashboardUI.localization.format("BackButtonTooltip");
            SleekButton sleekButton5 = MenuSurvivorsUI.backButton;

            if (MenuSurvivorsUI.< > f__mg$cache4 == null)
            {
                MenuSurvivorsUI.< > f__mg$cache4 = new ClickedButton(MenuSurvivorsUI.onClickedBackButton);
            }
            sleekButton5.onClickedButton        = MenuSurvivorsUI.< > f__mg$cache4;
            MenuSurvivorsUI.backButton.fontSize = 14;
            MenuSurvivorsUI.backButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            MenuSurvivorsUI.container.add(MenuSurvivorsUI.backButton);
            bundle.unload();
            new MenuSurvivorsCharacterUI();
            new MenuSurvivorsAppearanceUI();
            new MenuSurvivorsGroupUI();
            new MenuSurvivorsClothingUI();
        }
Example #16
0
        // Token: 0x060032EC RID: 13036 RVA: 0x00149C74 File Offset: 0x00148074
        public SleekLevel(LevelInfo level, bool isEditor)
        {
            base.init();
            base.sizeOffset_X        = 400;
            base.sizeOffset_Y        = 100;
            this.button              = new SleekButton();
            this.button.sizeOffset_X = 0;
            this.button.sizeOffset_Y = 0;
            this.button.sizeScale_X  = 1f;
            this.button.sizeScale_Y  = 1f;
            if (level.isEditable || !isEditor)
            {
                this.button.onClickedButton = new ClickedButton(this.onClickedButton);
            }
            base.add(this.button);
            if (ReadWrite.fileExists(level.path + "/Icon.png", false, false))
            {
                byte[]    data      = ReadWrite.readBytes(level.path + "/Icon.png", false, false);
                Texture2D texture2D = new Texture2D(380, 80, TextureFormat.ARGB32, false, true);
                texture2D.name      = "Icon_" + level.name + "_List_Icon";
                texture2D.hideFlags = HideFlags.HideAndDontSave;
                texture2D.LoadImage(data);
                this.icon = new SleekImageTexture();
                this.icon.positionOffset_X     = 10;
                this.icon.positionOffset_Y     = 10;
                this.icon.sizeOffset_X         = -20;
                this.icon.sizeOffset_Y         = -20;
                this.icon.sizeScale_X          = 1f;
                this.icon.sizeScale_Y          = 1f;
                this.icon.texture              = texture2D;
                this.icon.shouldDestroyTexture = true;
                this.button.add(this.icon);
            }
            this.nameLabel = new SleekLabel();
            this.nameLabel.positionOffset_Y = 10;
            this.nameLabel.sizeScale_X      = 1f;
            this.nameLabel.sizeOffset_Y     = 50;
            this.nameLabel.fontAlignment    = TextAnchor.MiddleCenter;
            this.nameLabel.fontSize         = 14;
            this.button.add(this.nameLabel);
            Local local = Localization.tryRead(level.path, false);

            if (local != null && local.has("Name"))
            {
                this.nameLabel.text = local.format("Name");
            }
            else
            {
                this.nameLabel.text = level.name;
            }
            this.infoLabel = new SleekLabel();
            this.infoLabel.positionOffset_Y = 60;
            this.infoLabel.sizeScale_X      = 1f;
            this.infoLabel.sizeOffset_Y     = 30;
            this.infoLabel.fontAlignment    = TextAnchor.MiddleCenter;
            string text = "#SIZE";

            if (level.size == ELevelSize.TINY)
            {
                text = MenuPlaySingleplayerUI.localization.format("Tiny");
            }
            else if (level.size == ELevelSize.SMALL)
            {
                text = MenuPlaySingleplayerUI.localization.format("Small");
            }
            else if (level.size == ELevelSize.MEDIUM)
            {
                text = MenuPlaySingleplayerUI.localization.format("Medium");
            }
            else if (level.size == ELevelSize.LARGE)
            {
                text = MenuPlaySingleplayerUI.localization.format("Large");
            }
            else if (level.size == ELevelSize.INSANE)
            {
                text = MenuPlaySingleplayerUI.localization.format("Insane");
            }
            string text2 = "#TYPE";

            if (level.type == ELevelType.SURVIVAL)
            {
                text2 = MenuPlaySingleplayerUI.localization.format("Survival");
            }
            else if (level.type == ELevelType.HORDE)
            {
                text2 = MenuPlaySingleplayerUI.localization.format("Horde");
            }
            else if (level.type == ELevelType.ARENA)
            {
                text2 = MenuPlaySingleplayerUI.localization.format("Arena");
            }
            this.infoLabel.text = MenuPlaySingleplayerUI.localization.format("Info", new object[]
            {
                text,
                text2
            });
            this.button.add(this.infoLabel);
            if (!level.isEditable && isEditor)
            {
                Bundle            bundle            = Bundles.getBundle("/Bundles/Textures/Menu/Icons/Workshop/MenuWorkshopEditor/MenuWorkshopEditor.unity3d");
                SleekImageTexture sleekImageTexture = new SleekImageTexture();
                sleekImageTexture.positionOffset_X = 20;
                sleekImageTexture.positionOffset_Y = -20;
                sleekImageTexture.positionScale_Y  = 0.5f;
                sleekImageTexture.sizeOffset_X     = 40;
                sleekImageTexture.sizeOffset_Y     = 40;
                sleekImageTexture.texture          = (Texture2D)bundle.load("Lock");
                sleekImageTexture.backgroundTint   = ESleekTint.FOREGROUND;
                this.button.add(sleekImageTexture);
                bundle.unload();
            }
            if (level.configData != null && level.configData.Status != EMapStatus.NONE)
            {
                SleekNew sleek = new SleekNew(level.configData.Status == EMapStatus.UPDATED);
                if (this.icon != null)
                {
                    this.icon.add(sleek);
                }
                else
                {
                    base.add(sleek);
                }
            }
            if (level.configData != null && level.configData.Category == ESingleplayerMapCategory.CURATED && level.configData.CuratedMapMode == ECuratedMapMode.TIMED)
            {
                SleekLabel sleekLabel = new SleekLabel();
                sleekLabel.positionOffset_X = -105;
                sleekLabel.positionScale_X  = 1f;
                sleekLabel.sizeOffset_X     = 100;
                sleekLabel.sizeOffset_Y     = 30;
                sleekLabel.fontAlignment    = TextAnchor.MiddleRight;
                sleekLabel.text             = MenuPlaySingleplayerUI.localization.format("Curated_Map_Timed");
                sleekLabel.foregroundTint   = ESleekTint.NONE;
                sleekLabel.foregroundColor  = Color.green;
                if (level.configData.Status != EMapStatus.NONE)
                {
                    sleekLabel.positionOffset_Y += 30;
                }
                SleekLabel sleekLabel2 = new SleekLabel();
                sleekLabel2.positionOffset_X = -205;
                sleekLabel2.positionOffset_Y = -30;
                sleekLabel2.positionScale_X  = 1f;
                sleekLabel2.positionScale_Y  = 1f;
                sleekLabel2.sizeOffset_X     = 200;
                sleekLabel2.sizeOffset_Y     = 30;
                sleekLabel2.fontAlignment    = TextAnchor.MiddleRight;
                sleekLabel2.text             = MenuPlaySingleplayerUI.localization.format("Curated_Map_Timestamp", new object[]
                {
                    level.configData.getCuratedMapTimestamp().ToString(MenuPlaySingleplayerUI.localization.format("Curated_Map_Timestamp_Format"))
                });
                sleekLabel2.foregroundTint  = ESleekTint.NONE;
                sleekLabel2.foregroundColor = Color.green;
                if (this.icon != null)
                {
                    this.icon.add(sleekLabel);
                    this.icon.add(sleekLabel2);
                }
                else
                {
                    base.add(sleekLabel);
                    base.add(sleekLabel2);
                }
            }
        }
Example #17
0
 public ItemBeaconAsset(Bundle bundle, Data data, Local localization, ushort id) : base(bundle, data, localization, id)
 {
     this._wave     = data.readUInt16("Wave");
     this._rewards  = data.readByte("Rewards");
     this._rewardID = data.readUInt16("Reward_ID");
 }
 // Token: 0x06001B47 RID: 6983 RVA: 0x00097356 File Offset: 0x00095756
 public ItemVehicleRepairToolAsset(Bundle bundle, Data data, Local localization, ushort id) : base(bundle, data, localization, id)
 {
     bundle.unload();
 }
        // Token: 0x0600349F RID: 13471 RVA: 0x00159C74 File Offset: 0x00158074
        public EditorEnvironmentLightingUI()
        {
            Local local = Localization.read("/Editor/EditorEnvironmentLighting.dat");

            EditorEnvironmentLightingUI.container = new Sleek();
            EditorEnvironmentLightingUI.container.positionOffset_X = 10;
            EditorEnvironmentLightingUI.container.positionOffset_Y = 10;
            EditorEnvironmentLightingUI.container.positionScale_X  = 1f;
            EditorEnvironmentLightingUI.container.sizeOffset_X     = -20;
            EditorEnvironmentLightingUI.container.sizeOffset_Y     = -20;
            EditorEnvironmentLightingUI.container.sizeScale_X      = 1f;
            EditorEnvironmentLightingUI.container.sizeScale_Y      = 1f;
            EditorUI.window.add(EditorEnvironmentLightingUI.container);
            EditorEnvironmentLightingUI.active        = false;
            EditorEnvironmentLightingUI.selectedTime  = ELightingTime.DAWN;
            EditorEnvironmentLightingUI.azimuthSlider = new SleekSlider();
            EditorEnvironmentLightingUI.azimuthSlider.positionOffset_X = -230;
            EditorEnvironmentLightingUI.azimuthSlider.positionOffset_Y = 80;
            EditorEnvironmentLightingUI.azimuthSlider.positionScale_X  = 1f;
            EditorEnvironmentLightingUI.azimuthSlider.sizeOffset_X     = 230;
            EditorEnvironmentLightingUI.azimuthSlider.sizeOffset_Y     = 20;
            EditorEnvironmentLightingUI.azimuthSlider.state            = LevelLighting.azimuth / 360f;
            EditorEnvironmentLightingUI.azimuthSlider.orientation      = ESleekOrientation.HORIZONTAL;
            EditorEnvironmentLightingUI.azimuthSlider.addLabel(local.format("AzimuthSliderLabelText"), ESleekSide.LEFT);
            SleekSlider sleekSlider = EditorEnvironmentLightingUI.azimuthSlider;

            if (EditorEnvironmentLightingUI.< > f__mg$cache0 == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cache0 = new Dragged(EditorEnvironmentLightingUI.onDraggedAzimuthSlider);
            }
            sleekSlider.onDragged = EditorEnvironmentLightingUI.< > f__mg$cache0;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.azimuthSlider);
            EditorEnvironmentLightingUI.biasSlider = new SleekSlider();
            EditorEnvironmentLightingUI.biasSlider.positionOffset_X = -230;
            EditorEnvironmentLightingUI.biasSlider.positionOffset_Y = 110;
            EditorEnvironmentLightingUI.biasSlider.positionScale_X  = 1f;
            EditorEnvironmentLightingUI.biasSlider.sizeOffset_X     = 230;
            EditorEnvironmentLightingUI.biasSlider.sizeOffset_Y     = 20;
            EditorEnvironmentLightingUI.biasSlider.state            = LevelLighting.bias;
            EditorEnvironmentLightingUI.biasSlider.orientation      = ESleekOrientation.HORIZONTAL;
            EditorEnvironmentLightingUI.biasSlider.addLabel(local.format("BiasSliderLabelText"), ESleekSide.LEFT);
            SleekSlider sleekSlider2 = EditorEnvironmentLightingUI.biasSlider;

            if (EditorEnvironmentLightingUI.< > f__mg$cache1 == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cache1 = new Dragged(EditorEnvironmentLightingUI.onDraggedBiasSlider);
            }
            sleekSlider2.onDragged = EditorEnvironmentLightingUI.< > f__mg$cache1;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.biasSlider);
            EditorEnvironmentLightingUI.fadeSlider = new SleekSlider();
            EditorEnvironmentLightingUI.fadeSlider.positionOffset_X = -230;
            EditorEnvironmentLightingUI.fadeSlider.positionOffset_Y = 140;
            EditorEnvironmentLightingUI.fadeSlider.positionScale_X  = 1f;
            EditorEnvironmentLightingUI.fadeSlider.sizeOffset_X     = 230;
            EditorEnvironmentLightingUI.fadeSlider.sizeOffset_Y     = 20;
            EditorEnvironmentLightingUI.fadeSlider.state            = LevelLighting.fade;
            EditorEnvironmentLightingUI.fadeSlider.orientation      = ESleekOrientation.HORIZONTAL;
            EditorEnvironmentLightingUI.fadeSlider.addLabel(local.format("FadeSliderLabelText"), ESleekSide.LEFT);
            SleekSlider sleekSlider3 = EditorEnvironmentLightingUI.fadeSlider;

            if (EditorEnvironmentLightingUI.< > f__mg$cache2 == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cache2 = new Dragged(EditorEnvironmentLightingUI.onDraggedFadeSlider);
            }
            sleekSlider3.onDragged = EditorEnvironmentLightingUI.< > f__mg$cache2;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.fadeSlider);
            EditorEnvironmentLightingUI.lightingScrollBox = new SleekScrollBox();
            EditorEnvironmentLightingUI.lightingScrollBox.positionOffset_X = -470;
            EditorEnvironmentLightingUI.lightingScrollBox.positionOffset_Y = 170;
            EditorEnvironmentLightingUI.lightingScrollBox.positionScale_X  = 1f;
            EditorEnvironmentLightingUI.lightingScrollBox.sizeOffset_X     = 470;
            EditorEnvironmentLightingUI.lightingScrollBox.sizeOffset_Y     = -170;
            EditorEnvironmentLightingUI.lightingScrollBox.sizeScale_Y      = 1f;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.lightingScrollBox);
            EditorEnvironmentLightingUI.seaLevelSlider = new SleekValue();
            EditorEnvironmentLightingUI.seaLevelSlider.positionOffset_Y = -130;
            EditorEnvironmentLightingUI.seaLevelSlider.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.seaLevelSlider.sizeOffset_X     = 200;
            EditorEnvironmentLightingUI.seaLevelSlider.sizeOffset_Y     = 30;
            EditorEnvironmentLightingUI.seaLevelSlider.state            = LevelLighting.seaLevel;
            EditorEnvironmentLightingUI.seaLevelSlider.addLabel(local.format("Sea_Level_Slider_Label"), ESleekSide.RIGHT);
            SleekValue sleekValue = EditorEnvironmentLightingUI.seaLevelSlider;

            if (EditorEnvironmentLightingUI.< > f__mg$cache3 == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cache3 = new Valued(EditorEnvironmentLightingUI.onValuedSeaLevelSlider);
            }
            sleekValue.onValued = EditorEnvironmentLightingUI.< > f__mg$cache3;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.seaLevelSlider);
            EditorEnvironmentLightingUI.snowLevelSlider = new SleekValue();
            EditorEnvironmentLightingUI.snowLevelSlider.positionOffset_Y = -90;
            EditorEnvironmentLightingUI.snowLevelSlider.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.snowLevelSlider.sizeOffset_X     = 200;
            EditorEnvironmentLightingUI.snowLevelSlider.sizeOffset_Y     = 30;
            EditorEnvironmentLightingUI.snowLevelSlider.state            = LevelLighting.snowLevel;
            EditorEnvironmentLightingUI.snowLevelSlider.addLabel(local.format("Snow_Level_Slider_Label"), ESleekSide.RIGHT);
            SleekValue sleekValue2 = EditorEnvironmentLightingUI.snowLevelSlider;

            if (EditorEnvironmentLightingUI.< > f__mg$cache4 == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cache4 = new Valued(EditorEnvironmentLightingUI.onValuedSnowLevelSlider);
            }
            sleekValue2.onValued = EditorEnvironmentLightingUI.< > f__mg$cache4;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.snowLevelSlider);
            EditorEnvironmentLightingUI.rainFreqField = new SleekSingleField();
            EditorEnvironmentLightingUI.rainFreqField.positionOffset_Y = -370;
            EditorEnvironmentLightingUI.rainFreqField.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.rainFreqField.sizeOffset_X     = 100;
            EditorEnvironmentLightingUI.rainFreqField.sizeOffset_Y     = 30;
            EditorEnvironmentLightingUI.rainFreqField.state            = LevelLighting.rainFreq;
            EditorEnvironmentLightingUI.rainFreqField.addLabel(local.format("Rain_Freq_Label"), ESleekSide.RIGHT);
            SleekSingleField sleekSingleField = EditorEnvironmentLightingUI.rainFreqField;

            if (EditorEnvironmentLightingUI.< > f__mg$cache5 == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cache5 = new TypedSingle(EditorEnvironmentLightingUI.onTypedRainFreqField);
            }
            sleekSingleField.onTypedSingle = EditorEnvironmentLightingUI.< > f__mg$cache5;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.rainFreqField);
            EditorEnvironmentLightingUI.rainDurField = new SleekSingleField();
            EditorEnvironmentLightingUI.rainDurField.positionOffset_Y = -330;
            EditorEnvironmentLightingUI.rainDurField.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.rainDurField.sizeOffset_X     = 100;
            EditorEnvironmentLightingUI.rainDurField.sizeOffset_Y     = 30;
            EditorEnvironmentLightingUI.rainDurField.state            = LevelLighting.rainDur;
            EditorEnvironmentLightingUI.rainDurField.addLabel(local.format("Rain_Dur_Label"), ESleekSide.RIGHT);
            SleekSingleField sleekSingleField2 = EditorEnvironmentLightingUI.rainDurField;

            if (EditorEnvironmentLightingUI.< > f__mg$cache6 == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cache6 = new TypedSingle(EditorEnvironmentLightingUI.onTypedRainDurField);
            }
            sleekSingleField2.onTypedSingle = EditorEnvironmentLightingUI.< > f__mg$cache6;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.rainDurField);
            EditorEnvironmentLightingUI.snowFreqField = new SleekSingleField();
            EditorEnvironmentLightingUI.snowFreqField.positionOffset_Y = -290;
            EditorEnvironmentLightingUI.snowFreqField.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.snowFreqField.sizeOffset_X     = 100;
            EditorEnvironmentLightingUI.snowFreqField.sizeOffset_Y     = 30;
            EditorEnvironmentLightingUI.snowFreqField.state            = LevelLighting.snowFreq;
            EditorEnvironmentLightingUI.snowFreqField.addLabel(local.format("Snow_Freq_Label"), ESleekSide.RIGHT);
            SleekSingleField sleekSingleField3 = EditorEnvironmentLightingUI.snowFreqField;

            if (EditorEnvironmentLightingUI.< > f__mg$cache7 == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cache7 = new TypedSingle(EditorEnvironmentLightingUI.onTypedSnowFreqField);
            }
            sleekSingleField3.onTypedSingle = EditorEnvironmentLightingUI.< > f__mg$cache7;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.snowFreqField);
            EditorEnvironmentLightingUI.snowDurField = new SleekSingleField();
            EditorEnvironmentLightingUI.snowDurField.positionOffset_Y = -250;
            EditorEnvironmentLightingUI.snowDurField.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.snowDurField.sizeOffset_X     = 100;
            EditorEnvironmentLightingUI.snowDurField.sizeOffset_Y     = 30;
            EditorEnvironmentLightingUI.snowDurField.state            = LevelLighting.snowDur;
            EditorEnvironmentLightingUI.snowDurField.addLabel(local.format("Snow_Dur_Label"), ESleekSide.RIGHT);
            SleekSingleField sleekSingleField4 = EditorEnvironmentLightingUI.snowDurField;

            if (EditorEnvironmentLightingUI.< > f__mg$cache8 == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cache8 = new TypedSingle(EditorEnvironmentLightingUI.onTypedSnowDurField);
            }
            sleekSingleField4.onTypedSingle = EditorEnvironmentLightingUI.< > f__mg$cache8;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.snowDurField);
            EditorEnvironmentLightingUI.stormButton = new SleekButton();
            EditorEnvironmentLightingUI.stormButton.positionOffset_Y = -210;
            EditorEnvironmentLightingUI.stormButton.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.stormButton.sizeOffset_X     = 100;
            EditorEnvironmentLightingUI.stormButton.sizeOffset_Y     = 30;
            EditorEnvironmentLightingUI.stormButton.text             = local.format("Storm");
            EditorEnvironmentLightingUI.stormButton.tooltip          = local.format("Storm_Tooltip");
            SleekButton sleekButton = EditorEnvironmentLightingUI.stormButton;

            if (EditorEnvironmentLightingUI.< > f__mg$cache9 == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cache9 = new ClickedButton(EditorEnvironmentLightingUI.onClickedStormButton);
            }
            sleekButton.onClickedButton = EditorEnvironmentLightingUI.< > f__mg$cache9;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.stormButton);
            EditorEnvironmentLightingUI.rainToggle = new SleekToggle();
            EditorEnvironmentLightingUI.rainToggle.positionOffset_X = 110;
            EditorEnvironmentLightingUI.rainToggle.positionOffset_Y = -215;
            EditorEnvironmentLightingUI.rainToggle.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.rainToggle.sizeOffset_X     = 40;
            EditorEnvironmentLightingUI.rainToggle.sizeOffset_Y     = 40;
            EditorEnvironmentLightingUI.rainToggle.state            = LevelLighting.canRain;
            EditorEnvironmentLightingUI.rainToggle.addLabel(local.format("Rain_Toggle_Label"), ESleekSide.RIGHT);
            SleekToggle sleekToggle = EditorEnvironmentLightingUI.rainToggle;

            if (EditorEnvironmentLightingUI.< > f__mg$cacheA == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cacheA = new Toggled(EditorEnvironmentLightingUI.onToggledRainToggle);
            }
            sleekToggle.onToggled = EditorEnvironmentLightingUI.< > f__mg$cacheA;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.rainToggle);
            EditorEnvironmentLightingUI.blizzardButton = new SleekButton();
            EditorEnvironmentLightingUI.blizzardButton.positionOffset_Y = -170;
            EditorEnvironmentLightingUI.blizzardButton.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.blizzardButton.sizeOffset_X     = 100;
            EditorEnvironmentLightingUI.blizzardButton.sizeOffset_Y     = 30;
            EditorEnvironmentLightingUI.blizzardButton.text             = local.format("Blizzard");
            EditorEnvironmentLightingUI.blizzardButton.tooltip          = local.format("Blizzard_Tooltip");
            SleekButton sleekButton2 = EditorEnvironmentLightingUI.blizzardButton;

            if (EditorEnvironmentLightingUI.< > f__mg$cacheB == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cacheB = new ClickedButton(EditorEnvironmentLightingUI.onClickedBlizzardButton);
            }
            sleekButton2.onClickedButton = EditorEnvironmentLightingUI.< > f__mg$cacheB;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.blizzardButton);
            EditorEnvironmentLightingUI.snowToggle = new SleekToggle();
            EditorEnvironmentLightingUI.snowToggle.positionOffset_X = 110;
            EditorEnvironmentLightingUI.snowToggle.positionOffset_Y = -175;
            EditorEnvironmentLightingUI.snowToggle.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.snowToggle.sizeOffset_X     = 40;
            EditorEnvironmentLightingUI.snowToggle.sizeOffset_Y     = 40;
            EditorEnvironmentLightingUI.snowToggle.state            = LevelLighting.canSnow;
            EditorEnvironmentLightingUI.snowToggle.addLabel(local.format("Snow_Toggle_Label"), ESleekSide.RIGHT);
            SleekToggle sleekToggle2 = EditorEnvironmentLightingUI.snowToggle;

            if (EditorEnvironmentLightingUI.< > f__mg$cacheC == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cacheC = new Toggled(EditorEnvironmentLightingUI.onToggledSnowToggle);
            }
            sleekToggle2.onToggled = EditorEnvironmentLightingUI.< > f__mg$cacheC;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.snowToggle);
            EditorEnvironmentLightingUI.moonSlider = new SleekSlider();
            EditorEnvironmentLightingUI.moonSlider.positionOffset_Y = -50;
            EditorEnvironmentLightingUI.moonSlider.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.moonSlider.sizeOffset_X     = 200;
            EditorEnvironmentLightingUI.moonSlider.sizeOffset_Y     = 20;
            EditorEnvironmentLightingUI.moonSlider.state            = (float)LevelLighting.moon / (float)LevelLighting.MOON_CYCLES;
            EditorEnvironmentLightingUI.moonSlider.orientation      = ESleekOrientation.HORIZONTAL;
            EditorEnvironmentLightingUI.moonSlider.addLabel(local.format("MoonSliderLabelText"), ESleekSide.RIGHT);
            SleekSlider sleekSlider4 = EditorEnvironmentLightingUI.moonSlider;

            if (EditorEnvironmentLightingUI.< > f__mg$cacheD == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cacheD = new Dragged(EditorEnvironmentLightingUI.onDraggedMoonSlider);
            }
            sleekSlider4.onDragged = EditorEnvironmentLightingUI.< > f__mg$cacheD;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.moonSlider);
            EditorEnvironmentLightingUI.timeSlider = new SleekSlider();
            EditorEnvironmentLightingUI.timeSlider.positionOffset_Y = -20;
            EditorEnvironmentLightingUI.timeSlider.positionScale_Y  = 1f;
            EditorEnvironmentLightingUI.timeSlider.sizeOffset_X     = 200;
            EditorEnvironmentLightingUI.timeSlider.sizeOffset_Y     = 20;
            EditorEnvironmentLightingUI.timeSlider.state            = LevelLighting.time;
            EditorEnvironmentLightingUI.timeSlider.orientation      = ESleekOrientation.HORIZONTAL;
            EditorEnvironmentLightingUI.timeSlider.addLabel(local.format("TimeSliderLabelText"), ESleekSide.RIGHT);
            SleekSlider sleekSlider5 = EditorEnvironmentLightingUI.timeSlider;

            if (EditorEnvironmentLightingUI.< > f__mg$cacheE == null)
            {
                EditorEnvironmentLightingUI.< > f__mg$cacheE = new Dragged(EditorEnvironmentLightingUI.onDraggedTimeSlider);
            }
            sleekSlider5.onDragged = EditorEnvironmentLightingUI.< > f__mg$cacheE;
            EditorEnvironmentLightingUI.container.add(EditorEnvironmentLightingUI.timeSlider);
            EditorEnvironmentLightingUI.timeButtons = new SleekButton[4];
            for (int i = 0; i < EditorEnvironmentLightingUI.timeButtons.Length; i++)
            {
                SleekButton sleekButton3 = new SleekButton();
                sleekButton3.positionOffset_X = 240;
                sleekButton3.positionOffset_Y = i * 40;
                sleekButton3.sizeOffset_X     = 200;
                sleekButton3.sizeOffset_Y     = 30;
                sleekButton3.text             = local.format("Time_" + i);
                SleekButton sleekButton4    = sleekButton3;
                Delegate    onClickedButton = sleekButton4.onClickedButton;
                if (EditorEnvironmentLightingUI.< > f__mg$cacheF == null)
                {
                    EditorEnvironmentLightingUI.< > f__mg$cacheF = new ClickedButton(EditorEnvironmentLightingUI.onClickedTimeButton);
                }
                sleekButton4.onClickedButton = (ClickedButton)Delegate.Combine(onClickedButton, EditorEnvironmentLightingUI.< > f__mg$cacheF);
                EditorEnvironmentLightingUI.lightingScrollBox.add(sleekButton3);
                EditorEnvironmentLightingUI.timeButtons[i] = sleekButton3;
            }
            EditorEnvironmentLightingUI.infoBoxes     = new SleekBox[12];
            EditorEnvironmentLightingUI.colorPickers  = new SleekColorPicker[EditorEnvironmentLightingUI.infoBoxes.Length];
            EditorEnvironmentLightingUI.singleSliders = new SleekSlider[5];
            for (int j = 0; j < EditorEnvironmentLightingUI.colorPickers.Length; j++)
            {
                SleekBox sleekBox = new SleekBox();
                sleekBox.positionOffset_X = 240;
                sleekBox.positionOffset_Y = EditorEnvironmentLightingUI.timeButtons.Length * 40 + j * 170;
                sleekBox.sizeOffset_X     = 200;
                sleekBox.sizeOffset_Y     = 30;
                sleekBox.text             = local.format("Color_" + j);
                EditorEnvironmentLightingUI.lightingScrollBox.add(sleekBox);
                EditorEnvironmentLightingUI.infoBoxes[j] = sleekBox;
                SleekColorPicker sleekColorPicker = new SleekColorPicker();
                sleekColorPicker.positionOffset_X = 200;
                sleekColorPicker.positionOffset_Y = EditorEnvironmentLightingUI.timeButtons.Length * 40 + j * 170 + 40;
                SleekColorPicker sleekColorPicker2 = sleekColorPicker;
                Delegate         onColorPicked     = sleekColorPicker2.onColorPicked;
                if (EditorEnvironmentLightingUI.< > f__mg$cache10 == null)
                {
                    EditorEnvironmentLightingUI.< > f__mg$cache10 = new ColorPicked(EditorEnvironmentLightingUI.onPickedColorPicker);
                }
                sleekColorPicker2.onColorPicked = (ColorPicked)Delegate.Combine(onColorPicked, EditorEnvironmentLightingUI.< > f__mg$cache10);
                EditorEnvironmentLightingUI.lightingScrollBox.add(sleekColorPicker);
                EditorEnvironmentLightingUI.colorPickers[j] = sleekColorPicker;
            }
            for (int k = 0; k < EditorEnvironmentLightingUI.singleSliders.Length; k++)
            {
                SleekSlider sleekSlider6 = new SleekSlider();
                sleekSlider6.positionOffset_X = 240;
                sleekSlider6.positionOffset_Y = EditorEnvironmentLightingUI.timeButtons.Length * 40 + EditorEnvironmentLightingUI.colorPickers.Length * 170 + k * 30;
                sleekSlider6.sizeOffset_X     = 200;
                sleekSlider6.sizeOffset_Y     = 20;
                sleekSlider6.orientation      = ESleekOrientation.HORIZONTAL;
                sleekSlider6.addLabel(local.format("Single_" + k), ESleekSide.LEFT);
                SleekSlider sleekSlider7 = sleekSlider6;
                Delegate    onDragged    = sleekSlider7.onDragged;
                if (EditorEnvironmentLightingUI.< > f__mg$cache11 == null)
                {
                    EditorEnvironmentLightingUI.< > f__mg$cache11 = new Dragged(EditorEnvironmentLightingUI.onDraggedSingleSlider);
                }
                sleekSlider7.onDragged = (Dragged)Delegate.Combine(onDragged, EditorEnvironmentLightingUI.< > f__mg$cache11);
                EditorEnvironmentLightingUI.lightingScrollBox.add(sleekSlider6);
                EditorEnvironmentLightingUI.singleSliders[k] = sleekSlider6;
            }
            EditorEnvironmentLightingUI.lightingScrollBox.area = new Rect(0f, 0f, 5f, (float)(EditorEnvironmentLightingUI.timeButtons.Length * 40 + EditorEnvironmentLightingUI.colorPickers.Length * 170 + EditorEnvironmentLightingUI.singleSliders.Length * 30 - 10));
            EditorEnvironmentLightingUI.updateSelection();
        }
Example #20
0
 public ItemFoodAsset(Bundle bundle, Data data, Local localization, ushort id) : base(bundle, data, localization, id)
 {
     bundle.unload();
 }
Example #21
0
 // Token: 0x06001A79 RID: 6777 RVA: 0x000944FB File Offset: 0x000928FB
 public ItemCloudAsset(Bundle bundle, Data data, Local localization, ushort id) : base(bundle, data, localization, id)
 {
     this._gravity = data.readSingle("Gravity");
     bundle.unload();
 }
Example #22
0
        public EditorTerrainUI()
        {
            Local  local  = Localization.read("/Editor/EditorTerrain.dat");
            Bundle bundle = Bundles.getBundle("/Bundles/Textures/Edit/Icons/EditorTerrain/EditorTerrain.unity3d");

            EditorTerrainUI.container = new Sleek();
            EditorTerrainUI.container.positionOffset_X = 10;
            EditorTerrainUI.container.positionOffset_Y = 10;
            EditorTerrainUI.container.positionScale_X  = 1f;
            EditorTerrainUI.container.sizeOffset_X     = -20;
            EditorTerrainUI.container.sizeOffset_Y     = -20;
            EditorTerrainUI.container.sizeScale_X      = 1f;
            EditorTerrainUI.container.sizeScale_Y      = 1f;
            EditorUI.window.add(EditorTerrainUI.container);
            EditorTerrainUI.active       = false;
            EditorTerrainUI.heightButton = new SleekButtonIcon((Texture2D)bundle.load("Height"));
            EditorTerrainUI.heightButton.positionOffset_Y = 40;
            EditorTerrainUI.heightButton.sizeOffset_X     = -5;
            EditorTerrainUI.heightButton.sizeOffset_Y     = 30;
            EditorTerrainUI.heightButton.sizeScale_X      = 0.25f;
            EditorTerrainUI.heightButton.text             = local.format("HeightButtonText");
            EditorTerrainUI.heightButton.tooltip          = local.format("HeightButtonTooltip");
            SleekButton sleekButton = EditorTerrainUI.heightButton;

            if (EditorTerrainUI.< > f__mg$cache0 == null)
            {
                EditorTerrainUI.< > f__mg$cache0 = new ClickedButton(EditorTerrainUI.onClickedHeightButton);
            }
            sleekButton.onClickedButton = EditorTerrainUI.< > f__mg$cache0;
            EditorTerrainUI.container.add(EditorTerrainUI.heightButton);
            EditorTerrainUI.materialsButton = new SleekButtonIcon((Texture2D)bundle.load("Materials"));
            EditorTerrainUI.materialsButton.positionOffset_X = 5;
            EditorTerrainUI.materialsButton.positionOffset_Y = 40;
            EditorTerrainUI.materialsButton.positionScale_X  = 0.25f;
            EditorTerrainUI.materialsButton.sizeOffset_X     = -10;
            EditorTerrainUI.materialsButton.sizeOffset_Y     = 30;
            EditorTerrainUI.materialsButton.sizeScale_X      = 0.25f;
            EditorTerrainUI.materialsButton.text             = local.format("MaterialsButtonText");
            EditorTerrainUI.materialsButton.tooltip          = local.format("MaterialsButtonTooltip");
            SleekButton sleekButton2 = EditorTerrainUI.materialsButton;

            if (EditorTerrainUI.< > f__mg$cache1 == null)
            {
                EditorTerrainUI.< > f__mg$cache1 = new ClickedButton(EditorTerrainUI.onClickedMaterialsButton);
            }
            sleekButton2.onClickedButton = EditorTerrainUI.< > f__mg$cache1;
            EditorTerrainUI.container.add(EditorTerrainUI.materialsButton);
            EditorTerrainUI.detailsButton = new SleekButtonIcon((Texture2D)bundle.load("Details"));
            EditorTerrainUI.detailsButton.positionOffset_X = 5;
            EditorTerrainUI.detailsButton.positionOffset_Y = 40;
            EditorTerrainUI.detailsButton.positionScale_X  = 0.5f;
            EditorTerrainUI.detailsButton.sizeOffset_X     = -10;
            EditorTerrainUI.detailsButton.sizeOffset_Y     = 30;
            EditorTerrainUI.detailsButton.sizeScale_X      = 0.25f;
            EditorTerrainUI.detailsButton.text             = local.format("DetailsButtonText");
            EditorTerrainUI.detailsButton.tooltip          = local.format("DetailsButtonTooltip");
            SleekButton sleekButton3 = EditorTerrainUI.detailsButton;

            if (EditorTerrainUI.< > f__mg$cache2 == null)
            {
                EditorTerrainUI.< > f__mg$cache2 = new ClickedButton(EditorTerrainUI.onClickedDetailsButton);
            }
            sleekButton3.onClickedButton = EditorTerrainUI.< > f__mg$cache2;
            EditorTerrainUI.container.add(EditorTerrainUI.detailsButton);
            EditorTerrainUI.resourcesButton = new SleekButtonIcon((Texture2D)bundle.load("Resources"));
            EditorTerrainUI.resourcesButton.positionOffset_X = 5;
            EditorTerrainUI.resourcesButton.positionOffset_Y = 40;
            EditorTerrainUI.resourcesButton.positionScale_X  = 0.75f;
            EditorTerrainUI.resourcesButton.sizeOffset_X     = -5;
            EditorTerrainUI.resourcesButton.sizeOffset_Y     = 30;
            EditorTerrainUI.resourcesButton.sizeScale_X      = 0.25f;
            EditorTerrainUI.resourcesButton.text             = local.format("ResourcesButtonText");
            EditorTerrainUI.resourcesButton.tooltip          = local.format("ResourcesButtonTooltip");
            SleekButton sleekButton4 = EditorTerrainUI.resourcesButton;

            if (EditorTerrainUI.< > f__mg$cache3 == null)
            {
                EditorTerrainUI.< > f__mg$cache3 = new ClickedButton(EditorTerrainUI.onClickedResourcesButton);
            }
            sleekButton4.onClickedButton = EditorTerrainUI.< > f__mg$cache3;
            EditorTerrainUI.container.add(EditorTerrainUI.resourcesButton);
            bundle.unload();
            new EditorTerrainHeightUI();
            new EditorTerrainMaterialsUI();
            new EditorTerrainDetailsUI();
            new EditorTerrainResourcesUI();
        }
Example #23
0
        public ItemGunAsset(Bundle bundle, Data data, Local localization, ushort id) : base(bundle, data, localization, id)
        {
            this._shoot      = (AudioClip)bundle.load("Shoot");
            this._reload     = (AudioClip)bundle.load("Reload");
            this._hammer     = (AudioClip)bundle.load("Hammer");
            this._aim        = (AudioClip)bundle.load("Aim");
            this._minigun    = (AudioClip)bundle.load("Minigun");
            this._projectile = (GameObject)bundle.load("Projectile");
            this.ammoMin     = data.readByte("Ammo_Min");
            this.ammoMax     = data.readByte("Ammo_Max");
            this.sightID     = data.readUInt16("Sight");
            this.tacticalID  = data.readUInt16("Tactical");
            this.gripID      = data.readUInt16("Grip");
            this.barrelID    = data.readUInt16("Barrel");
            this.magazineID  = data.readUInt16("Magazine");
            int num = data.readInt32("Magazine_Replacements");

            this.magazineReplacements = new MagazineReplacement[num];
            for (int i = 0; i < num; i++)
            {
                ushort id2 = data.readUInt16("Magazine_Replacement_" + i + "_ID");
                string map = data.readString("Magazine_Replacement_" + i + "_Map");
                MagazineReplacement magazineReplacement = default(MagazineReplacement);
                magazineReplacement.id       = id2;
                magazineReplacement.map      = map;
                this.magazineReplacements[i] = magazineReplacement;
            }
            this.unplace = data.readSingle("Unplace");
            this.replace = data.readSingle("Replace");
            if ((double)this.replace < 0.01)
            {
                this.replace = 1f;
            }
            this.hasSight    = data.has("Hook_Sight");
            this.hasTactical = data.has("Hook_Tactical");
            this.hasGrip     = data.has("Hook_Grip");
            this.hasBarrel   = data.has("Hook_Barrel");
            int num2 = data.readInt32("Magazine_Calibers");

            if (num2 > 0)
            {
                this.magazineCalibers = new ushort[num2];
                for (int j = 0; j < num2; j++)
                {
                    this.magazineCalibers[j] = data.readUInt16("Magazine_Caliber_" + j);
                }
                int num3 = data.readInt32("Attachment_Calibers");
                if (num3 > 0)
                {
                    this.attachmentCalibers = new ushort[num3];
                    for (int k = 0; k < num3; k++)
                    {
                        this.attachmentCalibers[k] = data.readUInt16("Attachment_Caliber_" + k);
                    }
                }
                else
                {
                    this.attachmentCalibers = this.magazineCalibers;
                }
            }
            else
            {
                this.magazineCalibers    = new ushort[1];
                this.magazineCalibers[0] = data.readUInt16("Caliber");
                this.attachmentCalibers  = this.magazineCalibers;
            }
            this.firerate             = data.readByte("Firerate");
            this.action               = (EAction)Enum.Parse(typeof(EAction), data.readString("Action"), true);
            this.deleteEmptyMagazines = data.has("Delete_Empty_Magazines");
            this.bursts               = data.readInt32("Bursts");
            this.hasSafety            = data.has("Safety");
            this.hasSemi              = data.has("Semi");
            this.hasAuto              = data.has("Auto");
            this.hasBurst             = (this.bursts > 0);
            this.isTurret             = data.has("Turret");
            if (this.hasAuto)
            {
                this.firemode = EFiremode.AUTO;
            }
            else if (this.hasSemi)
            {
                this.firemode = EFiremode.SEMI;
            }
            else if (this.hasBurst)
            {
                this.firemode = EFiremode.BURST;
            }
            else if (this.hasSafety)
            {
                this.firemode = EFiremode.SAFETY;
            }
            this.spreadAim = data.readSingle("Spread_Aim");
            this.spreadHip = data.readSingle("Spread_Hip");
            if (data.has("Recoil_Aim"))
            {
                this.recoilAim    = data.readSingle("Recoil_Aim");
                this.useRecoilAim = true;
            }
            else
            {
                this.recoilAim    = 1f;
                this.useRecoilAim = false;
            }
            this.recoilMin_x     = data.readSingle("Recoil_Min_X");
            this.recoilMin_y     = data.readSingle("Recoil_Min_Y");
            this.recoilMax_x     = data.readSingle("Recoil_Max_X");
            this.recoilMax_y     = data.readSingle("Recoil_Max_Y");
            this.recover_x       = data.readSingle("Recover_X");
            this.recover_y       = data.readSingle("Recover_Y");
            this.shakeMin_x      = data.readSingle("Shake_Min_X");
            this.shakeMin_y      = data.readSingle("Shake_Min_Y");
            this.shakeMin_z      = data.readSingle("Shake_Min_Z");
            this.shakeMax_x      = data.readSingle("Shake_Max_X");
            this.shakeMax_y      = data.readSingle("Shake_Max_Y");
            this.shakeMax_z      = data.readSingle("Shake_Max_Z");
            this.ballisticSteps  = data.readByte("Ballistic_Steps");
            this.ballisticTravel = data.readSingle("Ballistic_Travel");
            if (data.has("Ballistic_Steps"))
            {
                this.ballisticSteps  = data.readByte("Ballistic_Steps");
                this.ballisticTravel = data.readSingle("Ballistic_Travel");
            }
            else
            {
                this.ballisticTravel = 10f;
                this.ballisticSteps  = (byte)Mathf.CeilToInt(this.range / this.ballisticTravel);
            }
            if (data.has("Ballistic_Drop"))
            {
                this.ballisticDrop = data.readSingle("Ballistic_Drop");
            }
            else
            {
                this.ballisticDrop = 0.002f;
            }
            if (data.has("Ballistic_Force"))
            {
                this.ballisticForce = data.readSingle("Ballistic_Force");
            }
            else
            {
                this.ballisticForce = 0.002f;
            }
            this.reloadTime = data.readSingle("Reload_Time");
            this.hammerTime = data.readSingle("Hammer_Time");
            this.muzzle     = data.readUInt16("Muzzle");
            this.explosion  = data.readUInt16("Explosion");
            if (data.has("Shell"))
            {
                this.shell = data.readUInt16("Shell");
            }
            else if (this.action == EAction.Pump || this.action == EAction.Break)
            {
                this.shell = 33;
            }
            else if (this.action != EAction.Rail)
            {
                this.shell = 1;
            }
            else
            {
                this.shell = 0;
            }
            if (data.has("Alert_Radius"))
            {
                this.alertRadius = data.readSingle("Alert_Radius");
            }
            else
            {
                this.alertRadius = 48f;
            }
            bundle.unload();
        }
 public MaterialPaletteAsset(Bundle bundle, Local localization, byte[] hash) : base(bundle, localization, hash)
 {
     this.materials = new InspectableList <ContentReference <Material> >();
 }
Example #25
0
        public AnimalAsset(Bundle bundle, Data data, Local localization, ushort id) : base(bundle, data, localization, id)
        {
            if (id < 50 && !bundle.hasResource && !data.has("Bypass_ID_Limit"))
            {
                throw new NotSupportedException("ID < 50");
            }
            this._animalName = localization.format("Name");
            this._client     = (GameObject)bundle.load("Animal_Client");
            this._server     = (GameObject)bundle.load("Animal_Server");
            this._dedicated  = (GameObject)bundle.load("Animal_Dedicated");
            this._ragdoll    = (GameObject)bundle.load("Ragdoll");
            if (this.client == null)
            {
                Assets.errors.Add(this.animalName + " is missing client data. Highly recommended to fix.");
            }
            if (this.server == null)
            {
                Assets.errors.Add(this.animalName + " is missing server data. Highly recommended to fix.");
            }
            if (this.dedicated == null)
            {
                Assets.errors.Add(this.animalName + " is missing dedicated data. Highly recommended to fix.");
            }
            if (this.ragdoll == null)
            {
                Assets.errors.Add(this.animalName + " is missing ragdoll data. Highly recommended to fix.");
            }
            this._speedRun  = data.readSingle("Speed_Run");
            this._speedWalk = data.readSingle("Speed_Walk");
            this._behaviour = (EAnimalBehaviour)Enum.Parse(typeof(EAnimalBehaviour), data.readString("Behaviour"), true);
            this._health    = data.readUInt16("Health");
            this._regen     = data.readSingle("Regen");
            if (!data.has("Regen"))
            {
                this._regen = 10f;
            }
            this._damage   = data.readByte("Damage");
            this._meat     = data.readUInt16("Meat");
            this._pelt     = data.readUInt16("Pelt");
            this._rewardID = data.readUInt16("Reward_ID");
            if (data.has("Reward_Min"))
            {
                this._rewardMin = data.readByte("Reward_Min");
            }
            else
            {
                this._rewardMin = 3;
            }
            if (data.has("Reward_Max"))
            {
                this._rewardMax = data.readByte("Reward_Max");
            }
            else
            {
                this._rewardMax = 4;
            }
            this._roars = new AudioClip[(int)data.readByte("Roars")];
            byte b = 0;

            while ((int)b < this.roars.Length)
            {
                this.roars[(int)b] = (AudioClip)bundle.load("Roar_" + b);
                b += 1;
            }
            this._panics = new AudioClip[(int)data.readByte("Panics")];
            byte b2 = 0;

            while ((int)b2 < this.panics.Length)
            {
                this.panics[(int)b2] = (AudioClip)bundle.load("Panic_" + b2);
                b2 += 1;
            }
            this._rewardXP = data.readUInt32("Reward_XP");
            bundle.unload();
        }
Example #26
0
        public PlayerDashboardUI()
        {
            Local  local  = Localization.read("/Player/PlayerDashboard.dat");
            Bundle bundle = Bundles.getBundle("/Bundles/Textures/Player/Icons/PlayerDashboard/PlayerDashboard.unity3d");

            PlayerDashboardUI.container = new Sleek();
            PlayerDashboardUI.container.positionScale_Y  = -1f;
            PlayerDashboardUI.container.positionOffset_X = 10;
            PlayerDashboardUI.container.positionOffset_Y = 10;
            PlayerDashboardUI.container.sizeOffset_X     = -20;
            PlayerDashboardUI.container.sizeOffset_Y     = -20;
            PlayerDashboardUI.container.sizeScale_X      = 1f;
            PlayerDashboardUI.container.sizeScale_Y      = 1f;
            PlayerUI.container.add(PlayerDashboardUI.container);
            PlayerDashboardUI.active          = false;
            PlayerDashboardUI.inventoryButton = new SleekButtonIcon((Texture2D)bundle.load("Inventory"));
            PlayerDashboardUI.inventoryButton.sizeOffset_X = -5;
            PlayerDashboardUI.inventoryButton.sizeOffset_Y = 50;
            PlayerDashboardUI.inventoryButton.sizeScale_X  = 0.25f;
            PlayerDashboardUI.inventoryButton.text         = local.format("Inventory", new object[]
            {
                ControlsSettings.inventory
            });
            PlayerDashboardUI.inventoryButton.tooltip = local.format("Inventory_Tooltip");
            SleekButton sleekButton = PlayerDashboardUI.inventoryButton;

            if (PlayerDashboardUI.< > f__mg$cache0 == null)
            {
                PlayerDashboardUI.< > f__mg$cache0 = new ClickedButton(PlayerDashboardUI.onClickedInventoryButton);
            }
            sleekButton.onClickedButton = PlayerDashboardUI.< > f__mg$cache0;
            PlayerDashboardUI.inventoryButton.fontSize = 14;
            PlayerDashboardUI.inventoryButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            PlayerDashboardUI.container.add(PlayerDashboardUI.inventoryButton);
            PlayerDashboardUI.craftingButton = new SleekButtonIcon((Texture2D)bundle.load("Crafting"));
            PlayerDashboardUI.craftingButton.positionOffset_X = 5;
            PlayerDashboardUI.craftingButton.positionScale_X  = 0.25f;
            PlayerDashboardUI.craftingButton.sizeOffset_X     = -10;
            PlayerDashboardUI.craftingButton.sizeOffset_Y     = 50;
            PlayerDashboardUI.craftingButton.sizeScale_X      = 0.25f;
            PlayerDashboardUI.craftingButton.text             = local.format("Crafting", new object[]
            {
                ControlsSettings.crafting
            });
            PlayerDashboardUI.craftingButton.tooltip = local.format("Crafting_Tooltip");
            SleekButton sleekButton2 = PlayerDashboardUI.craftingButton;

            if (PlayerDashboardUI.< > f__mg$cache1 == null)
            {
                PlayerDashboardUI.< > f__mg$cache1 = new ClickedButton(PlayerDashboardUI.onClickedCraftingButton);
            }
            sleekButton2.onClickedButton = PlayerDashboardUI.< > f__mg$cache1;
            PlayerDashboardUI.craftingButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            PlayerDashboardUI.craftingButton.fontSize = 14;
            PlayerDashboardUI.container.add(PlayerDashboardUI.craftingButton);
            PlayerDashboardUI.skillsButton = new SleekButtonIcon((Texture2D)bundle.load("Skills"));
            PlayerDashboardUI.skillsButton.positionOffset_X = 5;
            PlayerDashboardUI.skillsButton.positionScale_X  = 0.5f;
            PlayerDashboardUI.skillsButton.sizeOffset_X     = -10;
            PlayerDashboardUI.skillsButton.sizeOffset_Y     = 50;
            PlayerDashboardUI.skillsButton.sizeScale_X      = 0.25f;
            PlayerDashboardUI.skillsButton.text             = local.format("Skills", new object[]
            {
                ControlsSettings.skills
            });
            PlayerDashboardUI.skillsButton.tooltip = local.format("Skills_Tooltip");
            PlayerDashboardUI.skillsButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            SleekButton sleekButton3 = PlayerDashboardUI.skillsButton;

            if (PlayerDashboardUI.< > f__mg$cache2 == null)
            {
                PlayerDashboardUI.< > f__mg$cache2 = new ClickedButton(PlayerDashboardUI.onClickedSkillsButton);
            }
            sleekButton3.onClickedButton            = PlayerDashboardUI.< > f__mg$cache2;
            PlayerDashboardUI.skillsButton.fontSize = 14;
            PlayerDashboardUI.container.add(PlayerDashboardUI.skillsButton);
            PlayerDashboardUI.informationButton = new SleekButtonIcon((Texture2D)bundle.load("Information"));
            PlayerDashboardUI.informationButton.positionOffset_X = 5;
            PlayerDashboardUI.informationButton.positionScale_X  = 0.75f;
            PlayerDashboardUI.informationButton.sizeOffset_X     = -5;
            PlayerDashboardUI.informationButton.sizeOffset_Y     = 50;
            PlayerDashboardUI.informationButton.sizeScale_X      = 0.25f;
            PlayerDashboardUI.informationButton.text             = local.format("Information", new object[]
            {
                ControlsSettings.map
            });
            PlayerDashboardUI.informationButton.tooltip = local.format("Information_Tooltip");
            PlayerDashboardUI.informationButton.iconImage.backgroundTint = ESleekTint.FOREGROUND;
            SleekButton sleekButton4 = PlayerDashboardUI.informationButton;

            if (PlayerDashboardUI.< > f__mg$cache3 == null)
            {
                PlayerDashboardUI.< > f__mg$cache3 = new ClickedButton(PlayerDashboardUI.onClickedInformationButton);
            }
            sleekButton4.onClickedButton = PlayerDashboardUI.< > f__mg$cache3;
            PlayerDashboardUI.informationButton.fontSize = 14;
            PlayerDashboardUI.container.add(PlayerDashboardUI.informationButton);
            if (Level.info != null && Level.info.type == ELevelType.HORDE)
            {
                PlayerDashboardUI.inventoryButton.sizeScale_X       = 0.5f;
                PlayerDashboardUI.craftingButton.isVisible          = false;
                PlayerDashboardUI.skillsButton.isVisible            = false;
                PlayerDashboardUI.informationButton.positionScale_X = 0.5f;
                PlayerDashboardUI.informationButton.sizeScale_X     = 0.5f;
            }
            bundle.unload();
            new PlayerDashboardInventoryUI();
            new PlayerDashboardCraftingUI();
            new PlayerDashboardSkillsUI();
            new PlayerDashboardInformationUI();
        }
Example #27
0
 public ItemFilterAsset(Bundle bundle, Data data, Local localization, ushort id) : base(bundle, data, localization, id)
 {
     this._use = (AudioClip)bundle.load("Use");
     bundle.unload();
 }
 // Token: 0x06001AAE RID: 6830 RVA: 0x00095050 File Offset: 0x00093450
 public ItemGripAsset(Bundle bundle, Data data, Local localization, ushort id) : base(bundle, data, localization, id)
 {
     this._grip    = (GameObject)bundle.load("Grip");
     this._isBipod = data.has("Bipod");
     bundle.unload();
 }