コード例 #1
0
 private new bool LoadConfig()
 {
     try
     {
         Config.Settings = new JsonSerializerSettings
         {
             Converters =
             {
                 new UnityVector3Converter(),
                 new UnityGameObjectConverter(),
                 new StringEnumConverter()
             }
         };
         if (!Config.Exists())
         {
             return(CreateDefaultConfig());
         }
         _config = Config.ReadObject <ConfigData>();
     }
     catch (Exception e)
     {
         Puts("Config load failed: {0}{1}{2}", e.Message, Environment.NewLine, e.StackTrace);
         return(false);
     }
     return(true);
 }
コード例 #2
0
 private new bool LoadConfig()
 {
     try
     {
         if (!Config.Exists())
         {
             return(CreateDefaultConfig());
         }
         Config.Load(_configpath);
     }
     catch (Exception e)
     {
         Puts("Config load failed: {0}{1}{2}", e.Message, Environment.NewLine, e.StackTrace);
         return(false);
     }
     return(true);
 }
コード例 #3
0
 private new bool LoadConfig()
 {
     try
     {
         Config.Settings = Settings;
         if (!Config.Exists())
         {
             return(CreateDefaultConfig());
         }
         _config = Config.ReadObject <ConfigData>();
     }
     catch (Exception e)
     {
         Puts("Config load failed: {0}{1}{2}", e.Message, Environment.NewLine, e.StackTrace);
         return(false);
     }
     return(true);
 }
コード例 #4
0
        private void OnServerInitialized()
        {
            LoadConfig();
            var configFileName = Manager.ConfigPath + "/server_info_text.json";

            _settings = null;
            try
            {
                var settingsDict = Config.Get("settings") as Dictionary <string, object>;
                _settings = JsonConvert.DeserializeObject <Settings>(JsonConvert.SerializeObject(settingsDict));
            }
            catch (Exception)
            {
                Puts("ServerInfo: Failed to load config");
                return;
            }

            _settings = _settings ?? Settings.CreateDefault();

            if (!_settings.UpgradedConfig && Config.Exists(configFileName))
            {
                try
                {
                    Puts("ServerInfo: Upgrading settings from server_info_text.json");
                    _settings = Config.ReadObject <Settings>(configFileName);
                    _settings.UpgradedConfig = true;
                    Puts("ServerInfo: Successfully upgraded config");
                }
                catch (Exception)
                {
                    Puts("ServerInfo: Failed to upgrade config. Manual editing is required.");
                    Puts("ServerInfo: Copy your settings by parts to new config in ServerInfo.json");
                }
            }

            foreach (var player in BasePlayer.activePlayerList)
            {
                AddHelpButton(player);
            }

            Config.Set("settings", _settings);
            SaveConfig();
        }
コード例 #5
0
ファイル: Unwound.cs プロジェクト: rustmy/oxideplugins-1
        void ConfigLoader()
        {
            base.LoadConfig();

            if (Config.Exists() &&
                Config["Version"].ToString() != this.Version.ToString())
            {
                ConfigUpdater();
            }

            #region localization
            localization = new ListDictionary <string, string>();

            localization.Add("PermissionMissing", Config["Localization", "PermissionMissing"].ToString());

            localization.Add("TheMedicIsComing", Config["Localization", "TheMedicIsComing"].ToString());

            localization.Add("NotWounded", Config["Localization", "NotWounded"].ToString());

            localization.Add("Survived", Config["Localization", "Survived"].ToString());

            localization.Add("DontTrollTheMedic", Config["Localization", "DontTrollTheMedic"].ToString());

            localization.Add("AboutToDie", Config["Localization", "AboutToDie"].ToString());

            localization.Add("MedicToLate", Config["Localization", "MedicToLate"].ToString());

            localization.Add("MedicIncompetent", Config["Localization", "MedicIncompetent"].ToString());

            localization.Add("MedicAlreadyCalled", Config["Localization", "MedicAlreadyCalled"].ToString());

            localization.Add("NotEnoughMoney", Config["Localization", "NotEnoughMoney"].ToString());

            localization.Add("NotEnoughMoney_ForcedEco", Config["Localization", "NotEnoughMoney_ForcedEco"].ToString());
            #endregion
            #region settings
            waitTillMedic = Convert.ToUInt32(Config["Settings", "WaitTillMedic"]);

            chanceTheMedicSavesYou = Convert.ToUInt32(Config["Settings", "ChanceTheMedicSavesYou"]) > 100 ? 100 : Convert.ToUInt32(Config["Settings", "ChanceTheMedicSavesYou"]);

            if (chanceTheMedicSavesYou == 0)
            {
                PrintError("The ChanceTheMedicSavesYou can't be 0, Plugin will run it with 1."); //still almost 0 but not 0

                chanceTheMedicSavesYou = 1;
            }

            canCallMedicOncePerWounded = Convert.ToBoolean(Config["Settings", "CanCallMedicOncePerWounded"]);

            //if (PopupNotifications == null &&
            //    Convert.ToBoolean(Config["Settings", "EnablePopups"]))
            //    PrintError("PopupNotifications-Plugin missing, can't enable pop-ups. Get the plugin first: http://oxidemod.org/plugins/popup-notifications.1252/");
            //else if (PopupNotifications != null &&
            //         Convert.ToBoolean(Config["Settings", "EnablePopups"]))
            //    popupsEnabled = true;

            if (Convert.ToBoolean(Config["Settings", "EnableEconomics"]) &&
                Economics != null)
            {
                economicsEnabled = true;

                forceEconomics = Convert.ToBoolean(Config["Settings", "ForceEconomics"]);

                ecoSettings = new ListDictionary <uint, uint>();

                Dictionary <string, string> temp = Config.Get <Dictionary <string, string> >("EcoSettings");

                foreach (KeyValuePair <string, string> s in temp)
                {
                    if (Convert.ToUInt32(s.Value) >= 0)
                    {
                        ecoSettings.Add(Convert.ToUInt32(s.Key), Convert.ToUInt32(s.Value));
                    }
                }

                ecoSettings.Keys.Reverse();
            }
            else if (Convert.ToBoolean(Config["Settings", "EnableEconomics"]))
            {
                PrintError("Economics-Plugin missing, can't enable economics. Get the plugin first: http://oxidemod.org/plugins/economics.717/");
            }
            #endregion

            //Puts("Unwound loaded config.");
        }
コード例 #6
0
        void ConfigLoader()
        {
            base.LoadConfig();

            #region updater
            if (Config.Exists() &&
                Config["Version"] == null)
            {
                Config.Save(Config.Filename + ".pre103.bak"); //will always call this pre103 as the change for this came with 1.0.3

                LoadDefaultConfig();
            }
            else if (Config.Exists() &&
                     Config["Version"].ToString() != this.Version.ToString())
            {
                ConfigUpdater();
            }
            #endregion
            #region paper
            paperNeeded = new ListDictionary <Rust.Rarity, int>();

            paperNeeded.Add(Rust.Rarity.Common, Convert.ToInt32(Config["Paper", "Common"]));

            paperNeeded.Add(Rust.Rarity.Uncommon, Convert.ToInt32(Config["Paper", "Uncommon"]));

            paperNeeded.Add(Rust.Rarity.Rare, Convert.ToInt32(Config["Paper", "Rare"]));

            paperNeeded.Add(Rust.Rarity.VeryRare, Convert.ToInt32(Config["Paper", "VeryRare"]));

            paperNeeded.Add(Rust.Rarity.None, Convert.ToInt32(Config["Paper", "None"]));
            #endregion
            #region blueprintpartsneeded
            blueprintPartsNeeded = new ListDictionary <Rust.Rarity, int>();

            blueprintPartsNeeded.Add(Rust.Rarity.Common, Convert.ToInt32(Config["BlueprintParts", "Common"]));

            blueprintPartsNeeded.Add(Rust.Rarity.Uncommon, Convert.ToInt32(Config["BlueprintParts", "Uncommon"]));

            blueprintPartsNeeded.Add(Rust.Rarity.Rare, Convert.ToInt32(Config["BlueprintParts", "Rare"]));

            blueprintPartsNeeded.Add(Rust.Rarity.VeryRare, Convert.ToInt32(Config["BlueprintParts", "VeryRare"]));

            blueprintPartsNeeded.Add(Rust.Rarity.None, Convert.ToInt32(Config["BlueprintParts", "None"]));
            #endregion
            #region blueprintpartstype
            //blueprintPartsTypeNeeded = new ListDictionary<Rust.Rarity, string>();
            //
            //blueprintPartsTypeNeeded.Add(Rust.Rarity.Common, Config["BlueprintParts", "CommonType"].ToString());
            //
            //blueprintPartsTypeNeeded.Add(Rust.Rarity.Uncommon, Config["BlueprintParts", "UncommonType"].ToString());
            //
            //blueprintPartsTypeNeeded.Add(Rust.Rarity.Rare, Config["BlueprintParts", "RareType"].ToString());
            //
            //blueprintPartsTypeNeeded.Add(Rust.Rarity.VeryRare, Config["BlueprintParts", "VeryRareType"].ToString());
            //
            //blueprintPartsTypeNeeded.Add(Rust.Rarity.None, Config["BlueprintParts", "NoneType"].ToString());
            #endregion
            #region localization
            localization = new ListDictionary <string, string>();

            localization.Add("NotEnoughPaper", Config["Localization", "NotEnoughPaper"].ToString());

            localization.Add("NotEnoughBluePrintParts", Config["Localization", "NotEnoughBluePrintParts"].ToString());

            localization.Add("BPNotLearned", Config["Localization", "BPNotLearned"].ToString());

            localization.Add("BPIsDrawing", Config["Localization", "BPIsDrawing"].ToString());

            localization.Add("BPDelivery", Config["Localization", "BPDelivery"].ToString());

            localization.Add("AlreadyDrawing", Config["Localization", "AlreadyDrawing"].ToString());

            localization.Add("ItemNotFound", Config["Localization", "ItemNotFound"].ToString());

            localization.Add("NoBP", Config["Localization", "NoBP"].ToString());

            localization.Add("Help", Config["Localization", "Help"].ToString());

            localization.Add("NoPermission", Config["Localization", "NoPermission"].ToString());
            #endregion
            #region itemalias & newitems
            itemAlias = new ListDictionary <string, string>();

            bool newItems = false;

            foreach (ItemDefinition itemDef in ItemManager.itemList)
            {
                if (ItemManager.FindBlueprint(itemDef) != null)
                {
                    if (Config["ZItemAlias", itemDef.shortname] != null)
                    {
                        itemAlias.Add(itemDef.shortname, Config["ZItemAlias", itemDef.shortname].ToString());
                    }
                    else
                    {
                        Config["ZItemAlias", itemDef.shortname] = itemDef.displayName.english;

                        newItems = true;
                    }
                }
            }

            //itemAlias.Add("blueprint_fragment", Config["ZItemAlias", "blueprint_fragment"].ToString().ToLower());
            //
            //itemAlias.Add("blueprint_page", Config["ZItemAlias", "blueprint_page"].ToString().ToLower());
            //
            //itemAlias.Add("blueprint_book", Config["ZItemAlias", "blueprint_book"].ToString().ToLower());
            //
            //itemAlias.Add("blueprint_library", Config["ZItemAlias", "blueprint_library"].ToString().ToLower());

            itemAlias.Add("researchpaper", Config["ZItemAlias", "researchpaper"].ToString().ToLower());

            if (newItems)
            {
                PrintWarning("Config-loader added new items to config.");

                SaveConfig();
            }
            #endregion
            #region drawtimes
            drawTimes = new ListDictionary <Rust.Rarity, int>();

            drawTimes.Add(Rust.Rarity.Common, Convert.ToInt32(Config["DrawTime", "Common"]));

            drawTimes.Add(Rust.Rarity.Uncommon, Convert.ToInt32(Config["DrawTime", "Uncommon"]));

            drawTimes.Add(Rust.Rarity.Rare, Convert.ToInt32(Config["DrawTime", "Rare"]));

            drawTimes.Add(Rust.Rarity.VeryRare, Convert.ToInt32(Config["DrawTime", "VeryRare"]));

            drawTimes.Add(Rust.Rarity.None, Convert.ToInt32(Config["DrawTime", "None"]));
            #endregion
            #region drawusages
            drawTimeModifier = new ListDictionary <Rust.Rarity, int>();

            drawTimeModifier.Add(Rust.Rarity.Common, Convert.ToInt32(Config["DrawTimeModifierMultiuse", "Common"]));

            drawTimeModifier.Add(Rust.Rarity.Uncommon, Convert.ToInt32(Config["DrawTimeModifierMultiuse", "Uncommon"]));

            drawTimeModifier.Add(Rust.Rarity.Rare, Convert.ToInt32(Config["DrawTimeModifierMultiuse", "Rare"]));

            drawTimeModifier.Add(Rust.Rarity.VeryRare, Convert.ToInt32(Config["DrawTimeModifierMultiuse", "VeryRare"]));

            drawTimeModifier.Add(Rust.Rarity.None, Convert.ToInt32(Config["DrawTimeModifierMultiuse", "None"]));
            #endregion
            #region settings
            cancelBPWhenDead = Convert.ToBoolean(Config["Settings", "CancelBPWhenDead"]);

            paperUsageAllowed = Convert.ToBoolean(Config["Settings", "PaperUsageAllowed"]);

            blueprintPartsUsageAllowed = Convert.ToBoolean(Config["Settings", "BlueprintPartsUsageAllowed"]);

            drawTimeModifierEnabled = Convert.ToBoolean(Config["Settings", "EnableDrawTimeModifier"]);

            mulitUseBPsAllowed = Convert.ToBoolean(Config["Settings", "AllowMultiUseBPs"]);

            if (!paperUsageAllowed &&
                !blueprintPartsUsageAllowed)
            {
                paperUsageAllowed = true;

                PrintError("Config-Loader reports that neither paperUsage nor blueprintPartsUsage is allowed. PaperUsage will be allowed by default then.");
            }

            if (PopupNotifications == null &&
                Convert.ToBoolean(Config["Settings", "EnablePopups"]))
            {
                PrintError("PopupNotifications-Plugin missing, can't enable pop-ups. Get the plugin first: http://oxidemod.org/plugins/popup-notifications.1252/");
            }
            else if (PopupNotifications != null &&
                     Convert.ToBoolean(Config["Settings", "EnablePopups"]))
            {
                popupsEnabled = true;
            }
            #endregion

            //Puts("Blueprinter loaded config.");
        }
コード例 #7
0
        protected override void LoadDefaultConfig()
        {
            if (Config.Exists())
            {
                Config.Clear();
            }

            Config["Version"] = this.Version.ToString();

            #region paper
            // just took required blueprint.fragment * 1.5 / 10 for standard, because we are all bad blueprint-drawers and it will already take a lot of wood with this
            // (1)paper = 100 wood (if not changed by other plugin) ; Common = 300 wood ; Uncommon = 4.5k wood ; Rare = 9k wood ; VeryRare = 18k wood

            Config["Paper", "Common"] = 3;

            Config["Paper", "Uncommon"] = 45;

            Config["Paper", "Rare"] = 90;

            Config["Paper", "VeryRare"] = 180;

            Config["Paper", "None"] = 1;
            #endregion
            #region blueprintparts
            Config["BlueprintParts", "Common"] = 2;

            //Config["BlueprintParts", "CommonType"] = "blueprint_fragment";

            Config["BlueprintParts", "Uncommon"] = 4;

            //Config["BlueprintParts", "UncommonType"] = "blueprint_page";

            Config["BlueprintParts", "Rare"] = 8;

            //Config["BlueprintParts", "RareType"] = "blueprint_book";

            Config["BlueprintParts", "VeryRare"] = 16;

            // Config["BlueprintParts", "VeryRareType"] = "blueprint_library";

            Config["BlueprintParts", "None"] = 1;

            //Config["BlueprintParts", "NoneType"] = "blueprint_fragment";
            #endregion
            #region drawtime
            Config["DrawTime", "Common"] = 10;

            Config["DrawTime", "Uncommon"] = 30;

            Config["DrawTime", "Rare"] = 60;

            Config["DrawTime", "VeryRare"] = 120;

            Config["DrawTime", "None"] = 0;
            #endregion
            #region drawtimemodifier
            Config["DrawTimeModifierMultiuse", "Common"] = 5;

            Config["DrawTimeModifierMultiuse", "Uncommon"] = 15;

            Config["DrawTimeModifierMultiuse", "Rare"] = 30;

            Config["DrawTimeModifierMultiuse", "VeryRare"] = 60;

            Config["DrawTimeModifierMultiuse", "None"] = 0;
            #endregion
            #region settings
            Config["Settings", "CancelBPWhenDead"] = true;

            Config["Settings", "PaperUsageAllowed"] = true;

            Config["Settings", "BlueprintPartsUsageAllowed"] = false;

            Config["Settings", "EnablePopups"] = false;

            Config["Settings", "EnableDrawTimeModifier"] = false;

            Config["Settings", "AllowMultiUseBPs"] = true;
            #endregion
            #region localization
            Config["Localization", "NotEnoughPaper"] = "The required ammount of paper to create this blueprint is {0} and you only have {1}.";

            Config["Localization", "NotEnoughBluePrintParts"] = "The required ammount of research paper to create this blueprint is {0} and you only have {1}.";

            Config["Localization", "BPNotLearned"] = "You don't know the blueprint for this item, learn it yourself first.";

            Config["Localization", "BPIsDrawing"] = "Blueprint is drawing now, please wait {0} seconds.";

            Config["Localization", "BPDelivery"] = "You finished drawing a blueprint for {0}.";

            Config["Localization", "BPRemovedFromQueue"] = "You are dead and can't finish drawing the blueprint for {0}.";

            Config["Localization", "AlreadyDrawing"] = "You are already drawing a blueprint, please wait until this is finished.";

            Config["Localization", "ItemNotFound"] = "An item with the name \"{0}\" was not found.";

            Config["Localization", "NoBP"] = "No blueprint for this item possible.";

            Config["Localization", "Help"] = "Use /blueprinter [ITEM] to create a blueprint from your known items.";

            Config["Localization", "NoPermission"] = "You have no permission to use this command.";
            #endregion
            #region itemalias
            foreach (ItemDefinition itemDef in ItemManager.itemList)
            {
                if (ItemManager.FindBlueprint(itemDef) != null &&
                    !ItemManager.FindBlueprint(itemDef).defaultBlueprint)
                {
                    Config["ZItemAlias", itemDef.shortname] = itemDef.displayName.english; // only putting the Z here so it won't show before the other things in the config
                }
            }
            //Config["ZItemAlias", "blueprint_fragment"] = "Blueprint Fragment";
            //
            //Config["ZItemAlias", "blueprint_page"] = "Blueprint Page";
            //
            //Config["ZItemAlias", "blueprint_book"] = "Blueprint Book";
            //
            //Config["ZItemAlias", "blueprint_library"] = "Blueprint Library";

            Config["ZItemAlias", "researchpaper"] = "Research Paper";
            #endregion
            #region permission
            if (!permission.PermissionExists("blueprinter.canuse"))
            {
                permission.RegisterPermission("blueprinter.canuse", this);
            }

            if (!permission.GroupHasPermission("player", "blueprinter.canuse"))
            {
                permission.GrantGroupPermission("player", "blueprinter.canuse", this);
            }

            if (!permission.GroupHasPermission("moderator", "blueprinter.canuse"))
            {
                permission.GrantGroupPermission("moderator", "blueprinter.canuse", this);
            }

            if (!permission.GroupHasPermission("admin", "blueprinter.canuse"))
            {
                permission.GrantGroupPermission("admin", "blueprinter.canuse", this);
            }
            #endregion

            SaveConfig();

            PrintWarning("Blueprinter created new config.");
        }