| public GetSetting ( String sectionName, String settingName ) : String | ||
| sectionName | String | Section name. |
| settingName | String | Key name. |
| Результат | String | |
private void LoadPermissions()
{
if (!File.Exists(Path.Combine(ModuleFolder, "PermissionsData.ini")))
{
UnityEngine.Debug.Log("[Permissions] Creating new PermissionsData file...");
File.Create(Path.Combine(ModuleFolder, "PermissionsData.ini")).Dispose();
permissionsData = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
permissionsData.AddSetting("Groups", "Admin", "server.*, permission.*");
permissionsData.AddSetting("Groups", "Moderator", "server.kick, server.mute, server.unmute, server.chat, server.build");
permissionsData.AddSetting("Groups", "User", "server.chat, server.build");
permissionsData.AddSetting("PlayerGroups", "50FA20E2708B2B2D97A0F092025EBCF3C1AF957D71154425431C00DC99F9A484", "Admin");
permissionsData.Save();
}
permissionsData = new IniParser(Path.Combine(ModuleFolder, "PermissionsData.ini"));
foreach (string group in permissionsData.EnumSection("Groups"))
{
List <string> _groupdata = new List <string>();
foreach (string perm in permissionsData.GetSetting("Groups", group).ToLower().RemoveWhiteSpaces().Split(','))
{
_groupdata.Add(perm);
}
if (!GroupData.ContainsKey(group))
{
GroupData.Add(group, _groupdata);
}
}
foreach (string hwid in permissionsData.EnumSection("PlayerGroups"))
{
PlayerGroup.Add(hwid, permissionsData.GetSetting("PlayerGroups", hwid));
}
UnityEngine.Debug.Log("[Permissions] Permissions loaded");
}
public void On_ServerInit()
{
ServicePointManager.ServerCertificateValidationCallback = (sendersendersendersender, certificatecertificatecertificatecertificate, chainchainchainchain, sslPolicyErrorssslPolicyErrorssslPolicyErrorssslPolicyErrors) =>
true;
Structures = new Dictionary <string, Structure>();
LoadStructures();
DataStore.Flush("NoChatSpamMsgCount");
DataStore.Flush("NoChatSpamTimeStamp");
if (Plugin.IniExists("PlutonEssentials"))
{
IniParser Config = Plugin.GetIni("PlutonEssentials");
float craft = float.Parse(Config.GetSetting("Config", "craftTimescale", "1.0"));
Server.CraftingTimeScale = craft;
float resource = float.Parse(Config.GetSetting("Config", "resourceGatherMultiplier", "1.0"));
World.ResourceGatherMultiplier = resource;
float time = float.Parse(Config.GetSetting("Config", "permanentTime", "-1.0"));
if (time != -1.0f)
{
World.Time = time;
World.FreezeTime();
return;
}
World.Timescale = float.Parse(Config.GetSetting("Config", "timescale", "30"));
}
}
public static string GetValue(string Section, string Setting)
{
Contract.Requires(!string.IsNullOrEmpty(Section));
Contract.Requires(!string.IsNullOrEmpty(Setting));
return(FougeriteConfig.GetSetting(Section, Setting));
}
internal static void LoadPermissions()
{
AllUsers.Clear();
if (!File.Exists(_currentpath + "\\Permissions.ini"))
{
File.Create(_currentpath + "\\Permissions.ini").Dispose();
PermissionsIni = new IniParser(_currentpath + "\\Permissions.ini");
PermissionsIni.AddSetting("dretax", "PasswordHash", "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08");
PermissionsIni.AddSetting("dretax", "Permissions", string.Join(",", GetDefaultPermissions()));
PermissionsIni.Save();
}
PermissionsIni = new IniParser(_currentpath + "\\Permissions.ini");
foreach (IniParser.IniSection x in PermissionsIni.Sections.Values)
{
try
{
string pwhash = PermissionsIni.GetSetting(x.SectionName, "PasswordHash");
string permissions = PermissionsIni.GetSetting(x.SectionName, "Permissions");
User user = new User(x.SectionName, pwhash, ProcessPermissions(permissions));
AllUsers[x.SectionName] = user;
}
catch (Exception ex)
{
Logger.LogError("[Permissions] Failed to read permissions for: " + x + " Fix It, and Reload the Permissions list! " + ex);
}
}
}
public override void Initialize()
{
if (!File.Exists(Path.Combine(ModuleFolder, "Settings.ini")))
{
File.Create(Path.Combine(ModuleFolder, "Settings.ini")).Dispose();
Settings = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
Settings.AddSetting("Settings", "BlockShelterCloseToDoor", "true");
Settings.AddSetting("Settings", "BlockSpikeCloseToDoor", "true");
Settings.AddSetting("Settings", "BlockBarricadeCloseToDoor", "true");
Settings.AddSetting("Settings", "AntiGatewayStag", "true");
Settings.Save();
}
else
{
Settings = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
BlockShelterCloseToDoor = bool.Parse(Settings.GetSetting("Settings", "BlockShelterCloseToDoor"));
BlockSpikeCloseToDoor = bool.Parse(Settings.GetSetting("Settings", "BlockSpikeCloseToDoor"));
BlockBarricadeCloseToDoor = bool.Parse(Settings.GetSetting("Settings", "BlockBarricadeCloseToDoor"));
AntiGatewayStag = bool.Parse(Settings.GetSetting("Settings", "AntiGatewayStag"));
}
ReloadSettings();
Fougerite.Hooks.OnEntityDeployedWithPlacer += OnEntityDeployed;
Fougerite.Hooks.OnCommand += OnCommand;
Logger.Log("Yes I-Antigrief loaded");
}
private void IniRead()
{
if (File.Exists("config.ini"))
{
IniParser parserStart = new IniParser("config.ini");
chkLogin.IsChecked = bool.Parse(parserStart.GetSetting("DADICE", "AUTOLOGIN").ToLower());
if ((bool)chkLogin.IsChecked)
{
txtUsername.Text = parserStart.GetSetting("DADICE", "USERNAME").ToLower();
txtApiKey.Text = parserStart.GetSetting("DADICE", "APIKEY").ToLower();
}
ChangeAppStyle(int.Parse(parserStart.GetSetting("DADICE", "WINDOWTHEME")), int.Parse(parserStart.GetSetting("DADICE", "WINDOWCOLOR")));
}
else
{
using (StreamWriter writer = new StreamWriter("config.ini"))
{
writer.WriteLine("[DADICE]");
writer.WriteLine("AUTOLOGIN=False");
writer.WriteLine("USERNAME="******"APIKEY=");
writer.WriteLine("WINDOWTHEME=0");
writer.WriteLine("WINDOWCOLOR=0");
}
}
}
public override void Initialize()
{
Fougerite.Hooks.OnPlayerSpawned += Spawn;
Fougerite.Hooks.OnPlayerHurt += Hurt;
Fougerite.Hooks.OnPlayerDisconnected += Disconnected;
if (!File.Exists(Path.Combine(ModuleFolder, "Config.ini")))
{
File.Create(Path.Combine(ModuleFolder, "Config.ini")).Dispose();
Settings = new IniParser(Path.Combine(ModuleFolder, "Config.ini"));
Settings.AddSetting("Options", "ShieldTime", ShieldTime.ToString());
Settings.AddSetting("Options", "RustBusterSupport", "false");
Settings.AddSetting("Messages", "ActiveMessage", "Your spawn shield is enabled");
Settings.AddSetting("Messages", "DeactiveMessage", "Your spawn shield was ended");
Settings.Save();
}
else
{
Settings = new IniParser(Path.Combine(ModuleFolder, "Config.ini"));
ShieldTime = int.Parse(Settings.GetSetting("Options", "ShieldTime"));
RustBusterSupport = bool.Parse(Settings.GetSetting("Options", "RustBusterSupport"));
ActiveMessage = Settings.GetSetting("Messages", "ActiveMessage");
DeactiveMessage = Settings.GetSetting("Messages", "DeactiveMessage");
}
}
public static void OnCommand(Fougerite.Player player, string cmd, string[] args)
{
if (cmd == "legitraid")
{
if (player.Admin)
{
Settings = new IniParser(PathC);
RaidTime = int.Parse(Settings.GetSetting("Settings", "RaidTime"));
MaxRaidTime = int.Parse(Settings.GetSetting("Settings", "MaxRaidTime"));
AllowAllModerators = Settings.GetBoolSetting("Settings", "AllowAllModerators");
CanOpenChestIfThereIsNoStructureClose = Settings.GetBoolSetting("Settings", "CanOpenChestIfThereIsNoStructureClose");
AutoWhiteListFriends = Settings.GetBoolSetting("Settings", "AutoWhiteListFriends");
var Collect = Settings.GetSetting("Settings", "WhiteListedIDs");
var splits = Collect.Split(Convert.ToChar(","));
WhiteListedIDs.Clear();
foreach (var x in splits)
{
WhiteListedIDs.Add(x);
}
var Collect2 = Settings.GetSetting("Settings", "DataStoreTables");
var splits2 = Collect2.Split(Convert.ToChar(","));
foreach (var x in splits2)
{
DSNames.Add(x);
}
player.MessageFrom("LegitRaid", "Reloaded!");
}
}
else if (cmd == "flushlegita")
{
if (player.Admin)
{
DataStore.GetInstance().Flush("LegitRaidED");
player.MessageFrom("LegitRaid", "Flushed!");
}
}
else if (cmd == "raida")
{
if (player.Admin || (player.Moderator && AllowAllModerators) || (player.Moderator && WhiteListedIDs.Contains(player.SteamID)))
{
bool contains = DataStore.GetInstance().ContainsKey("LegitRaidA", player.UID);
if (!contains)
{
DataStore.GetInstance().Add("LegitRaidA", player.UID, true);
player.MessageFrom("LegitRaid", "<!> Ahora puedes abrir todos los cofres.");
file = new System.IO.StreamWriter(PathLog, true);
file.WriteLine(DateTime.Now + " " + player.Name + "-" + player.SteamID + " ahora puede abrir todos los cofres.");
file.Close();
}
else
{
DataStore.GetInstance().Remove("LegitRaidA", player.UID);
player.MessageFrom("LegitRaid", "Disabled");
file = new System.IO.StreamWriter(PathLog, true);
file.WriteLine(DateTime.Now + " " + player.Name + "-" + player.SteamID + " quito el modo raid.");
file.Close();
}
}
}
}
private void Form1_Load(object sender, EventArgs e)
{
simpleSound = new SoundPlayer(@"Music/launcher.wav");
simpleSound.PlayLooping();
var pakLanguages = new DirectoryInfo("local").GetFiles("*.pak");
for (int i = 0; i < pakLanguages.Length; i++)
{
language.Items.Add(FirstCharToUpper(pakLanguages[i].Name.Split('.')[0]));
}
IniParser parser = new IniParser(@"Settings.ini");
String languageDefault = (parser.GetSetting("Language", "Default")).ToUpper();
language.SelectedIndex = language.FindStringExact(languageDefault);
language.DropDownStyle = ComboBoxStyle.DropDownList;
String resolutionDefault = (parser.GetSetting("Options", "Resolution"));
listResolution();
loadLanguageLauncher();
loadFolderMods();
resolution.Refresh();
this.Refresh();
}
private void ReloadConfig()
{
if (!File.Exists(ModuleFolder + "\\Settings.ini"))
{
File.Create(ModuleFolder + "\\Settings.ini").Dispose();
Settings = new IniParser(ModuleFolder + "\\Settings.ini");
Settings.AddSetting("Settings", "YouNeedToBeLoggedIn", YouNeedToBeLoggedIn);
Settings.AddSetting("Settings", "CredsReset", CredsReset);
Settings.AddSetting("Settings", "TimeToLogin", TimeToLogin.ToString());
Settings.AddSetting("Settings", "SocialSiteForHelp", SocialSiteForHelp);
Settings.AddSetting("Settings", "RestrictedCommands", "home,tpa,tpaccept,hg");
Settings.Save();
}
try
{
Settings = new IniParser(ModuleFolder + "\\Settings.ini");
YouNeedToBeLoggedIn = Settings.GetSetting("Settings", "YouNeedToBeLoggedIn");
CredsReset = Settings.GetSetting("Settings", "CredsReset");
TimeToLogin = int.Parse(Settings.GetSetting("Settings", "TimeToLogin"));
SocialSiteForHelp = Settings.GetSetting("Settings", "SocialSiteForHelp");
RestrictedCommands.Clear();
string data = Settings.GetSetting("Settings", "RestrictedCommands");
foreach (var x in data.Split(','))
{
RestrictedCommands.Add(x);
}
}
catch (Exception ex)
{
Logger.LogError("[AuthMe] Error Reading the config: " + ex);
}
}
public static string GetModulesFolder()
{
Regex root = new Regex(@"^%RootFolder%", RegexOptions.IgnoreCase);
string path = root.Replace(FougeriteDirectoryConfig.GetSetting("Settings", "ModulesFolder"), Util.GetRootFolder()) + @"\";
return(Util.NormalizePath(path));
}
private void Set()
{
IniParser ini = Plugin.GetIni("ItemDefs");
foreach (ItemDefinition itemDef in ItemManager.GetItemDefinitions())
{
foreach (string key in ini.EnumSection(itemDef.displayName.english))
{
if (ItemManager.FindItemDefinition(key) == null)
{
Util.Log("Failed to set " + itemDef.displayName.english + key);
continue;
}
//stacks
int sizes = int.Parse(ini.GetSetting("stackable", key));
ItemManager.FindItemDefinition(key).stackable = sizes;
//amountType
string type = ini.GetSetting("amountType", key);
ItemManager.FindItemDefinition(key).amountType.ToString() = type;
//max condition
float max = float.Parse(ini.GetSetting("condition.max", key));
ItemManager.FindItemDefinition(key)
}
}
}
public void Load(IniParser ini, string section)
{
Enabled = ini.GetSettingBool(section, "Enabled");
ID = ini.GetSettingUInt16(section, "ID");
Alias = ini.GetSettingUInt16(section, "Alias");
Multihex = ini.GetSettingByte(section, "Multihex");
Aim = ini.GetSettingBool(section, "Aim");
Armor = ini.GetSettingBool(section, "Armor");
Rotate = ini.GetSettingBool(section, "Rotate");
Walk = ini.GetSettingUInt16(section, "Walk");
Run = ini.GetSettingUInt16(section, "Run");
Step1 = ini.GetSettingUInt16(section, "Step1");;
Step2 = ini.GetSettingUInt16(section, "Step2");;
Step3 = ini.GetSettingUInt16(section, "Step3");;
Step4 = ini.GetSettingUInt16(section, "Step4");;
Sound = ini.GetSetting(section, "Sound");
Comment = ini.GetSetting(section, "Comment");
if (Sound == IniParser.EmptySetting)
{
Sound = "";
}
if (Comment == IniParser.EmptySetting)
{
Comment = "";
}
}
public override void Initialize()
{
Fougerite.Hooks.OnItemRemoved += ItemRemoved;
ppath = Path.Combine(ModuleFolder, "Detections.log");
if (!File.Exists(Path.Combine(ModuleFolder, "Config")))
{
File.Create(Path.Combine(ModuleFolder, "Config.ini")).Dispose();
ini = new IniParser(Path.Combine(ModuleFolder, "Config.ini"));
ini.AddSetting("Options", "BroadcastAdmins", "true");
ini.AddSetting("Messages", "Broadcast", Broadcast.ToString());
ini.AddSetting("Messages", "WarningMessage", WarningMessage.ToString());
ini.Save();
Logger.Log("[AntiAutoloot] Config not found and created");
}
else
{
Logger.Log("[AntiAutoloot] Config file loaded");
ini = new IniParser(Path.Combine(ModuleFolder, "Config.ini"));
BroadcastAdmins = bool.Parse(ini.GetSetting("Options", "BroadcastAdmins"));
Broadcast = ini.GetSetting("Messages", "Broadcast");
WarningMessage = ini.GetSetting("Messages", "WarningMessage");
}
}
public override void Initialize()
{
try
{
RestrictedCommands = new List <string>();
Hooks.OnCommand += Command;
Hooks.OnPlayerSpawned += Spawned;
Hooks.OnPlayerHurt += PlayerHurt;
Hooks.OnEntityDeployedWithPlacer += Deploy;
Hooks.OnEntityHurt += EntityHurt;
Resendinmates();
CheckConfig();
if (ini.ContainsSetting("JailRadius", "radius"))
{
int rad = Convert.ToInt32(ini.GetSetting("JailRadius", "radius"));
if (radius.ContainsKey("radius"))
{
radius.Remove("radius");
radius.Add("radius", rad);
}
else
{
radius.Add("radius", rad);
}
}
}
catch (Exception ex)
{
Logger.Log("Error happend at Initialize " + ex);
}
}
private void Form1_Load(object sender, EventArgs e)
{
var pakLanguages = new DirectoryInfo("local").GetFiles("*.pak");
for (int i = 0; i < pakLanguages.Length; i++)
{
language.Items.Add(FirstCharToUpper(pakLanguages[i].Name.Split('.')[0]));
}
IniParser parser = new IniParser(@"Settings.ini");
String languageDefault = (parser.GetSetting("Language", "Default")).ToUpper();
language.SelectedIndex = language.FindStringExact(languageDefault);
String resolutionDefault = (parser.GetSetting("Options", "Resolution"));
/*resolution.Items.Add("1024 x 768");
* resolution.Items.Add("1152 x 864");
* resolution.Items.Add("1280 x 1024");
* resolution.Items.Add("1280 x 720");
* resolution.Items.Add("1366 x 768");
* resolution.Items.Add("1920 x 1080");*/
//resolution.SelectedIndex = int.Parse(resolutionDefault);
loadLanguageLauncher();
loadFolderMods();
}
private bool ReloadConfig()
{
if (!File.Exists(Path.Combine(ModuleFolder, "Settings.ini")))
{
File.Create(Path.Combine(ModuleFolder, "Settings.ini")).Dispose();
Settings = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
Settings.AddSetting("Settings", "Time", "20");
Settings.AddSetting("Settings", "Announce", "false");
Settings.AddSetting("Settings", "Distance", "2.5");
Settings.Save();
}
Settings = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
try
{
Time = int.Parse(Settings.GetSetting("Settings", "Time"));
Announce = Settings.GetBoolSetting("Settings", "Announce");
AnnounceMSG = Settings.GetSetting("Settings", "AnnounceMSG");
Distance = float.Parse(Settings.GetSetting("Settings", "Distance"));
}
catch (Exception ex)
{
Fougerite.Logger.LogError("[LootSpawner] Failed to read config, possible wrong value somewhere! Ex: " + ex);
return(false);
}
return(true);
}
public override void Initialize()
{
if (!File.Exists(Path.Combine(ModuleFolder, "Zones.ini")))
{
File.Create(Path.Combine(ModuleFolder, "Zones.ini"));
}
if (!File.Exists(Path.Combine(ModuleFolder, "Settings.ini")))
{
File.Create(Path.Combine(ModuleFolder, "Settings.ini")).Dispose();
SettingsFile = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
SettingsFile.AddSetting("Settings", "EnableRads", "true");
SettingsFile.AddSetting("Settings", "RadLevelLow", RadLevelLow.ToString());
SettingsFile.AddSetting("Settings", "RadLevelHight", RadLevelHight.ToString());
SettingsFile.AddSetting("Settings", "TimeRad", TimeRad.ToString());
SettingsFile.Save();
}
else
{
SettingsFile = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
EnableRads = bool.Parse(SettingsFile.GetSetting("Settings", "EnableRads"));
RadLevelLow = int.Parse(SettingsFile.GetSetting("Settings", "RadLevelLow"));
RadLevelHight = int.Parse(SettingsFile.GetSetting("Settings", "RadLevelHight"));
TimeRad = int.Parse(SettingsFile.GetSetting("Settings", "TimeRad"));
}
Fougerite.Hooks.OnCommand += OnCommand;
Fougerite.Hooks.OnServerLoaded += OnServerLoaded;
}
public string[] getListNameInConfigFile(string configFilePath)
{
IniParser newIni = new IniParser(configFilePath);
string[] listSection = newIni.EnumSection("FormerFolder");
int count = 0;
string url;
foreach (string ls in listSection)
{
url = newIni.GetSetting("FormerFolder", ls);
count = count + Directory.GetFiles(url).Count();
}
string[] listNameInConfigFile = new string[count];
int countFile = 0;
foreach (string ls in listSection)
{
url = newIni.GetSetting("FormerFolder", ls);
string[] allFIleInFolder = Directory.GetFiles(url);
foreach (string fd in allFIleInFolder)
{
listNameInConfigFile[countFile] = fd;
countFile++;
}
}
return(listNameInConfigFile);
}
public override void Initialize()
{
if (!File.Exists(Path.Combine(ModuleFolder, "Settings.ini")))
{
File.Create(Path.Combine(ModuleFolder, "Settings.ini")).Dispose();
Settings = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
Settings.AddSetting("Settings", "AllowBarricade", "true");
Settings.AddSetting("Settings", "AllowBoxes", "true");
Settings.AddSetting("Settings", "AllowSleepingBags", "true");
Settings.AddSetting("Settings", "AllowBeds", "true");
Settings.AddSetting("Settings", "AllowRamps", "true");
Settings.AddSetting("Radius", "Radius", RadiusCheck.ToString());
Settings.Save();
}
else
{
Settings = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
AllowBarricade = bool.Parse(Settings.GetSetting("Settings", "AllowBarricade"));
AllowBoxes = bool.Parse(Settings.GetSetting("Settings", "AllowBoxes"));
AllowSleepingBags = bool.Parse(Settings.GetSetting("Settings", "AllowSleepingBags"));
AllowBeds = bool.Parse(Settings.GetSetting("Settings", "AllowBeds"));
AllowRamps = bool.Parse(Settings.GetSetting("Settings", "AllowRamps"));
}
Fougerite.Hooks.OnEntityDeployedWithPlacer += OnEntityDeployed;
Fougerite.Hooks.OnServerInit += OnServerInit;
Fougerite.Hooks.OnModulesLoaded += OnModulesLoaded;
}
Settings()
{
var path = System.Windows.Forms.Application.StartupPath;
if (Directory.Exists(path))
{
this.Ini = new IniParser(Path.Combine(path, fileName), Encoding.UTF8, false);
this.TemporaryFilesDirectory = Ini.GetSetting(mainSection, tfd);
if (this.TemporaryFilesDirectory == null || !Directory.Exists(this.TemporaryFilesDirectory))
{
this.TemporaryFilesDirectory = System.IO.Path.GetTempPath();
Ini.AddSetting(mainSection, tfd, this.TemporaryFilesDirectory);
Ini.SaveSettings();
}
var days = Ini.GetSetting(mainSection, dtfad);
var ok = int.TryParse(days, out this.DeleteTemporaryFilesAfterXDays);
if (!ok || this.DeleteTemporaryFilesAfterXDays <= 0)
{
this.DeleteTemporaryFilesAfterXDays = DefaultDeleteTemporaryFilesAfterXDays; // by default, deletes after 10 days.
Ini.AddSetting(mainSection, dtfad, this.DeleteTemporaryFilesAfterXDays.ToString());
Ini.SaveSettings();
}
}
}
public bool UnbanByName(string name, string UnBanner = "Console")
{
var id = ReturnACNByName2(name);
var ip = ReturnACNByName(name);
if (id == null)
{
return(false);
}
string red = "[color #FF0000]";
string green = "[color #009900]";
string white = "[color #FFFFFF]";
foreach (Fougerite.Player pl in Server.GetServer().Players)
{
if (pl.Admin || pl.Moderator)
{
pl.Message(red + name + white + " was unbanned by: "
+ green + UnBanner);
}
}
IniParser ini = GlobalBanList;
name = id;
var iprq = ini.GetSetting("NameIps", ip);
var idrq = ini.GetSetting("NameIds", id);
ini.DeleteSetting("Ips", iprq);
ini.DeleteSetting("Ids", idrq);
ini.DeleteSetting("NameIps", name);
ini.DeleteSetting("NameIds", name);
ini.Save();
return(true);
}
private void ReloadSettings()
{
Settings = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
{
BlockShelterCloseToDoor = bool.Parse(Settings.GetSetting("Settings", "BlockShelterCloseToDoor"));
BlockSpikeCloseToDoor = bool.Parse(Settings.GetSetting("Settings", "BlockSpikeCloseToDoor"));
BlockBarricadeCloseToDoor = bool.Parse(Settings.GetSetting("Settings", "BlockBarricadeCloseToDoor"));
}
}
public void Load()
{
IniParser parser = new IniParser(IniPath());
BaseAddress = parser.GetSetting("Credentials", "BaseAddress");
Version = parser.GetSetting("Credentials", "Version");
Key = parser.GetSetting("Credentials", "Key");
Secret = parser.GetSetting("Credentials", "Secret");
}
public void GiveLoadout(RoyaleUser pl)
{
string[] en = ini.EnumSection("Items");
foreach (var item in en)
{
int hi = Convert.ToInt32(ini.GetSetting("Items", item));
int amount = hi;
pl.Inventory.AddItem(item, amount);
}
}
private void OnConsoleReceived(ref ConsoleSystem.Arg arg, bool external)
{
if (arg.Class == "authme" && arg.Function == "resetuser")
{
if ((arg.argUser != null && arg.argUser.admin) || arg.argUser == null)
{
Fougerite.Player adminplr = null;
if (arg.argUser != null)
{
adminplr = Fougerite.Server.GetServer().FindPlayer(arg.argUser.userID);
}
string name = string.Join(" ", arg.Args);
if (string.IsNullOrEmpty(name))
{
arg.ReplyWith(green + "Specify a name!");
return;
}
Fougerite.Player plr = Fougerite.Server.GetServer().FindPlayer(name);
if (plr != null)
{
if (Auths.GetSetting("Login", plr.SteamID) != null)
{
Auths.DeleteSetting("Login", plr.SteamID);
Auths.Save();
}
if (Credentials.ContainsKey(plr.UID))
{
Credentials.Remove(plr.UID);
}
arg.ReplyWith(green + "User: "******" reset! He can now register a new account for that steamid.");
plr.MessageFrom("AuthMe", green + CredsReset);
if (adminplr != null)
{
AuthLogger.Log("[USER RESET] " + adminplr.Name + " - " + adminplr.SteamID
+ " - " + adminplr.IP + " reset credetials for: " + plr.Name + " - " +
plr.SteamID + " - " + plr.IP);
}
else
{
AuthLogger.Log("[USER RESET] Console reset credetials for: " + plr.Name + " - " +
plr.SteamID + " - " + plr.IP);
}
}
else
{
arg.ReplyWith(green + "No player found!");
}
}
}
}
private int GetIntSetting(string Section, string Name)
{
string Value = INIConfig.GetSetting(Section, Name);
int INT = 0;
if (int.TryParse(Value, out INT))
{
return(INT);
}
return(int.MinValue);
}
private void ReloadConfig()
{
if (!File.Exists(Path.Combine(ModuleFolder, "Settings.ini")))
{
File.Create(Path.Combine(ModuleFolder, "Settings.ini")).Dispose();
Settings = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
Settings.AddSetting("Shelter", "DecayShelter", "true");
Settings.AddSetting("CampFire", "DecayCampFire", "true");
Settings.AddSetting("CampFire", "DeleteOnlyCampFireOnGround", "true");
Settings.AddSetting("Barricade", "DecayBarricade", "true");
Settings.AddSetting("Barricade", "DeleteOnlyBarricadeOnGround", "true");
Settings.AddSetting("WorkBench", "DecayWorkBench", "true");
Settings.AddSetting("WorkBench", "DeleteOnlyWorkBenchOnGround", "true");
Settings.AddSetting("Shelter", "MinutesForDecayShelter", "60");
Settings.AddSetting("CampFire", "MinutesForDecayCampFire", "60");
Settings.AddSetting("Barricade", "MinutesForDecayBarricade", "60");
Settings.AddSetting("WorkBench", "MinutesForDecayWorkBench", "60");
Logger.Log("Decay Plugin: New Settings File Created!");
Settings.Save();
ReloadConfig();
}
else
{
Settings = new IniParser(Path.Combine(ModuleFolder, "Settings.ini"));
try
{
DecayShelter = Settings.GetBoolSetting("Shelter", "DecayShelter");
DecayCampFire = Settings.GetBoolSetting("CampFire", "DecayCampFire");
DeleteOnlyCampFireOnGround = Settings.GetBoolSetting("CampFire", "DeleteOnlyCampFireOnGround");
DecayBarricade = Settings.GetBoolSetting("Barricade", "DecayBarricade");
DeleteOnlyCampFireOnGround = Settings.GetBoolSetting("Barricade", "DeleteOnlyBarricadeOnGround");
DecayWorkBench = Settings.GetBoolSetting("WorkBench", "DecayWorkBench");
DeleteOnlyWorkBenchOnGround = Settings.GetBoolSetting("WorkBench", "DeleteOnlyWorkBenchOnGround");
TimeDecayShelter = int.Parse(Settings.GetSetting("Shelter", "MinutesForDecayShelter"));
TimeDecayCampFire = int.Parse(Settings.GetSetting("CampFire", "MinutesForDecayCampFire"));
TimeDecayBarricade = int.Parse(Settings.GetSetting("Barricade", "MinutesForDecayBarricade"));
TimeDecayWorkBench = int.Parse(Settings.GetSetting("WorkBench", "MinutesForDecayWorkBench"));
Logger.Log("Decay Plugin: Settings file Loaded!");
}
catch (Exception ex)
{
Logger.LogError("Decay Plugin: Detected a problem in the configuration");
Logger.Log("ERROR -->" + ex.Message);
File.Delete(Path.Combine(ModuleFolder, "Settings.ini"));
Logger.LogError("Decay Plugin: Deleted the old configuration file");
ReloadConfig();
}
return;
}
}
public static void initComponent()
{
if (!File.Exists(Path.Combine(RustPPModule.ConfigsFolder, "Logs.log")))
{
File.Create(Path.Combine(RustPPModule.ConfigsFolder, "Logs.log")).Dispose();
}
PathLog = Path.Combine(RustPPModule.ConfigsFolder, "Logs.log");
PathC = Path.Combine(RustPPModule.ConfigsFolder, "LegitRaid.ini");
RaiderTime = new Dictionary <ulong, int>();
OwnerTimeData = new Dictionary <ulong, double>();
if (!File.Exists(PathC))
{
File.Create(PathC).Dispose();
Settings = new IniParser(PathC);
Settings.AddSetting("Settings", "RaidTime", "20");
Settings.AddSetting("Settings", "MaxRaidTime", "60");
Settings.AddSetting("Settings", "AllowAllModerators", "false");
Settings.AddSetting("Settings", "CanOpenChestIfThereIsNoStructureClose", "true");
Settings.AddSetting("Settings", "DataStoreTables", "RaidComponent");
Settings.AddSetting("Settings", "WhiteListedIDs", "76561197961872487");
Settings.AddSetting("Settings", "AutoWhiteListFriends", "True");
Settings.Save();
}
else
{
Settings = new IniParser(PathC);
RaidTime = int.Parse(Settings.GetSetting("Settings", "RaidTime"));
MaxRaidTime = int.Parse(Settings.GetSetting("Settings", "MaxRaidTime"));
AllowAllModerators = Settings.GetBoolSetting("Settings", "AllowAllModerators");
CanOpenChestIfThereIsNoStructureClose = Settings.GetBoolSetting("Settings", "CanOpenChestIfThereIsNoStructureClose");
AutoWhiteListFriends = Settings.GetBoolSetting("Settings", "AutoWhiteListFriends");
var Collect = Settings.GetSetting("Settings", "WhiteListedIDs");
var splits = Collect.Split(Convert.ToChar(","));
foreach (var x in splits)
{
WhiteListedIDs.Add(x);
}
var Collect2 = Settings.GetSetting("Settings", "DataStoreTables");
var splits2 = Collect2.Split(Convert.ToChar(","));
foreach (var x in splits2)
{
DSNames.Add(x);
}
}
Fougerite.Hooks.OnLootUse += OnLootUse;
Fougerite.Hooks.OnEntityDestroyed += OnEntityDestroyed;
Fougerite.Hooks.OnEntityHurt += OnEntityHurt;
Fougerite.Hooks.OnModulesLoaded += OnModulesLoaded;
Fougerite.Hooks.OnCommand += OnCommand;
Fougerite.Hooks.OnServerSaved += OnServerSaved;
Fougerite.Hooks.OnEntityDeployedWithPlacer += OnEntityDeployedWithPlacer;
}
public void Init(IApi api, string dllpath)
{
_api = api;
_dllpath = dllpath;
try
{
_ini = new IniParser(_configPath);
}
catch (Exception ex)
{
throw new WebRconException(String.Format("Error loading config: {0}", ex.Message));
}
_enabled = _ini.GetBoolSetting(Name, "Enabled");
if (!_enabled)
{
throw new WebRconException(String.Format("{0} has been disabled", Name));
}
var port = _ini.GetSetting(Name, "Port");
try
{
_port = Convert.ToInt32(port);
}
catch (Exception ex)
{
throw new WebRconException(String.Format("Invalid port: {0}", ex.Message));
}
_password = _ini.GetSetting(Name, "Password");
if (_password == "")
{
_password = Utils.GetRandomString();
}
#if DEBUG
_serverurl = String.Format("http://localhost:{0}/", _port);
#else
_serverurl = String.Format("http://*:{0}/", _port);
#endif
_webServer = new WebServer(HttpRequest, _serverurl);
_webServer.Run();
AppConsole.Log(String.Format("Started HTTP server at {0}. Password: {1}", _serverurl, _password), ConsoleColor.Cyan);
_port++;
_socketServer = new WebSocketServer(_port);
_socketServer.AddWebSocketService("/rcon", () => new SocketBehavior(_api, _password));
_socketServer.Start();
LoadHtdocsFiles();
}
private void frmMain_Load(object sender, EventArgs e)
{
dataGridView1.DataSource = null;
DataSet ds = YAMS.Database.ReturnLogRows();
dataGridView1.DataSource = ds.Tables[0];
this.checkBox1.Checked = YAMS.Util.HasJRE();
this.checkBox2.Checked = YAMS.Util.HasJDK();
this.textBox1.Text = YAMS.Util.JavaPath();
this.textBox2.Text = YAMS.Util.JavaPath("jdk");
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = new System.IO.FileInfo(System.Reflection.Assembly.GetExecutingAssembly().Location).DirectoryName;
watcher.Filter = "*.sdf";
//watcher.NotifyFilter = NotifyFilters.LastWrite;
watcher.Changed += new FileSystemEventHandler(OnChanged);
watcher.EnableRaisingEvents = true;
IniParser parser = new IniParser(@"server.properties");
txtIniCheck.Text = parser.GetSetting("ROOT", "level-name");
parser.AddSetting("ROOT", "level-name", "world");
parser.SaveSettings();
}
public LoadOut(string name)
{
path = Path.Combine(Singleton<Rust.Util>.Instance.GetLoadoutFolder(), name + ".ini");
bool nu = false;
if (!File.Exists(path)) {
File.AppendAllText(path, "");
nu = true;
}
IniParser ini = new IniParser(path);
Name = ini.Name;
if (!nu) {
itemCount = Int32.Parse(ini.GetSetting("Def", "itemCount"));
OwnerUse = ini.GetBoolSetting("Def", "ownerCanUse");
ModeratorUse = ini.GetBoolSetting("Def", "modCanUse");
NormalUse = ini.GetBoolSetting("Def", "normalCanUse");
} else {
itemCount = 0;
OwnerUse = true;
NormalUse = true;
ModeratorUse = true;
}
items = new Dictionary<int, LoadOutItem>(30);
if (itemCount != 0) {
for (int i = 0; i < itemCount; i++) {
string namee = ini.GetSetting(i.ToString(), "Name");
int amount;
if (!Int32.TryParse(ini.GetSetting(i.ToString(), "Amount"), out amount))
amount = Int32.MaxValue;
LoadOutItem current = new LoadOutItem(namee, amount);
items.Add(i, current);
}
}
if (Server.GetInstance().LoadOuts.ContainsKey(Name))
Server.GetInstance().LoadOuts.Remove(Name);
Server.GetInstance().LoadOuts.Add(Name, this);
}
public void ReceiveLeatherConfiguration(LeatherConfig config)
{
string cfgPath = Path.Combine (config.ConfigDirectoryPath, "LimitedSleepers.cfg");
if (File.Exists (cfgPath)) {
IniParser parser = new IniParser (cfgPath);
String lifeStr = parser.GetSetting ("General", "SleeperLifeInMinutes");
int.TryParse (lifeStr, out this.sleeperLifeInMinutes);
ConsoleSystem.Log ("Config parsed- sleeper life is "+this.sleeperLifeInMinutes+" minutes.");
} else {
ConsoleSystem.Log ("Could not locate LimitedSleepers.cfg");
}
}
public void LoadFromFile(String file)
{
IniParser parser = new IniParser(file);
String res = parser.GetSetting("Video", "Water").ToLower();
switch (res)
{
case "verylow": Water = VideoQuality.LOW;
break;
case "low": Water = VideoQuality.LOW;
break;
case "medium": Water = VideoQuality.MEDIUM;
break;
case "high": Water = VideoQuality.HIGH;
break;
case "ultra": Water = VideoQuality.ULTRA;
break;
}
}
private void loadPrefs()
{
if (!File.Exists("CP1252Fixer.ini"))
{
System.IO.FileStream fs = System.IO.File.Create("CP1252Fixer.ini");
fs.Close();
return; // just make the file for saving to later, and keep defaults
}
IniParser parser = new IniParser(@"CP1252Fixer.ini");
for (int i = 0; i < CMOptions.Length; ++i)
{
String on = parser.GetSetting("options", CMOptions[i].text.ToUpper());
setOption(ref CMOptions[i], on == "TRUE");
}
}
IEnumerator Start_Net()
{
#if UNITY_ANDROID && !UNITY_EDITOR
string key = Application.streamingAssetsPath + "/DebugConfig.txt";
#else
string key = ProjectSystem.PrefixPlatform + Application.streamingAssetsPath + "/DebugConfig.txt";
#endif
WWW www = new WWW(key);
yield return www;
Debuger.Log("www" + www.error);
if (string.IsNullOrEmpty(www.error))
{
Debuger.Log("/DebugConfig.txt = " + www.text);
IniParser mIni = new IniParser(www.text, true);
if (mIni != null)
{
UPDATE_DEFAULT_RESNAME = PlayerProfile.GetResName();
if (string.IsNullOrEmpty(UPDATE_DEFAULT_RESNAME))
UPDATE_DEFAULT_RESNAME = mIni.GetSetting("UPDATE_DEFAULT_RESNAME");
UPDATE_NETWORK = mIni.GetSetting("UPDATE_NETWORK");
UPDATE_REMOTE_ROOT_URL = mIni.GetSetting("UPDATE_REMOTE_ROOT_URL");
UPDATE_REMOTE_ROOT_URL_2 = mIni.GetSetting("UPDATE_REMOTE_ROOT_URL_2");
MF_YHT_URL = mIni.GetSetting("MF_YHT_URL");
VOICE_URL = mIni.GetSetting("VOICE_URL");
PROXY_URL = mIni.GetSetting("PROXY_URL");
}
}
else
{
Debuger.LogError(key + "[/versionConfig.txt =]" + www.error);
}
www.Dispose();
www = null;
}
private void LoadFromSettingsFile()
{
if(File.Exists(m_settingsPath) == false)
CreateDefaultSettingsFile();
//HotKey settings
IniParser parser = new IniParser(m_settingsPath);
StaticData.Settings.NewTaskHotkey.Alt = Convert.ToBoolean(parser.GetSetting("NewTaskHotkey", "alt"));
StaticData.Settings.NewTaskHotkey.Ctrl = Convert.ToBoolean(parser.GetSetting("NewTaskHotkey", "ctrl"));
StaticData.Settings.NewTaskHotkey.Shift = Convert.ToBoolean(parser.GetSetting("NewTaskHotkey", "shift"));
StaticData.Settings.NewTaskHotkey.Win = Convert.ToBoolean(parser.GetSetting("NewTaskHotkey", "win"));
StaticData.Settings.NewTaskHotkey.Key = parser.GetSetting("NewTaskHotkey", "key");
//General
StaticData.Settings.StartWithWindows = Convert.ToBoolean(parser.GetSetting("General", "startwithwindows"));
StaticData.Settings.CheckUpdates = Convert.ToBoolean(parser.GetSetting("General", "autoupdate"));
StaticData.Settings.PlaySound = Convert.ToBoolean(parser.GetSetting("General", "playsound"));
string cultureInfoName = parser.GetSetting("CultureInfo", "Name");
if (string.IsNullOrEmpty(cultureInfoName))
cultureInfoName = "en-uk";
switch (cultureInfoName.ToLower()) {
case "lt-lt":
StaticData.Settings.CultureData = new CultureDataLT();
break;
case "en-uk":
case "en-gb":
StaticData.Settings.CultureData = new CultureDataUK();
break;
case "en-us":
StaticData.Settings.CultureData = new CultureDataUS();
break;
default:
StaticData.Settings.CultureData = new CultureDataLT();
break;
}
decimal remindLaterDefaultValue = 10.0m/60.0m;
decimal.TryParse(parser.GetSetting("RemindMeLater", "Default"), out remindLaterDefaultValue);
StaticData.Settings.RemindMeLaterDecimalValue = RemindLaterValue.Round(remindLaterDefaultValue);
//Skins
StaticData.Settings.SkinsUniqueCodes.SelectedSkin = parser.GetSetting("skin", "code");
if (string.IsNullOrEmpty(StaticData.Settings.SkinsUniqueCodes.SelectedSkin))
StaticData.Settings.SkinsUniqueCodes.SelectedSkin = DefaultSkinForm.SKIN_UNIQUE_CODE;
// Theme's name
StaticData.Settings.ThemeUniqueCode = parser.GetSetting("skin", "themename");
if (string.IsNullOrEmpty(StaticData.Settings.ThemeUniqueCode))
StaticData.Settings.ThemeUniqueCode = _defaultThemeName;
Application.Current.ApplyTheme(StaticData.Settings.ThemeUniqueCode);
//Sync
StaticData.Settings.Sync.Id = parser.GetSetting("sync", "id");
StaticData.Settings.Sync.Enable = Convert.ToBoolean(parser.GetSetting("sync", "enable"));
StaticData.Settings.Sync.Interval = Convert.ToInt32(parser.GetSetting("sync", "interval"));
m_log.Info("Settings were loaded successfully");
}
public string GetProperty(string strPropertyName)
{
//File.WriteAllText(Core.RootFolder + @"\log.err", "Try to get property: " + strPropertyName + " from file: " + this.ServerDirectory + @"\server.properties");
IniParser parser = new IniParser(this.ServerDirectory + @"\server.properties");
return parser.GetSetting("ROOT", strPropertyName);
}
private static bool SetHandlers(ref ILoaderConfigHandler configStore, ref IStatusHandler statusHandler)
{
string reportStoreType = "";
string reportStoreConnectionString = "";
string configStoreName = "";
string configStoreConnectionString = "";
try
{
IniParser ini = new IniParser("conf.ini");
reportStoreType = ini.GetSetting("STATUS_REPORT", "REPORT_TO");
reportStoreConnectionString = ini.GetSetting("STATUS_REPORT", "REPORT_CONNECTION");
configStoreName = ini.GetSetting("CONFIG_STORE", "TYPE");
configStoreConnectionString = ini.GetSetting("CONFIG_STORE", "CONNECTION");
}
catch (System.IO.FileNotFoundException ex)
{
Console.WriteLine(ex.Message);
return false;
}
//Setup property store
//Currently we hardcode this to SQL Server, the infrastructure to reflect on it is in place
configStore = new Aih.DataLoader.ConfigHandlers.SQLServerLoaderConfigHandler(configStoreConnectionString);
//Setup where to report status to
//Currently we hardcode this to SQL Server, the infrastructure to reflect on it is in place
statusHandler = new Aih.DataLoader.StatusHandlers.SQLServerStatusHandler(reportStoreConnectionString);
return true;
}
/// <summary>
/// Loads a random set file from the folder defined in settings and parses it into the global variable "currentSet".
/// </summary>
public void setRandomSet()
{
currentSet = new Set();
string[] files = Directory.GetFiles(settings.setDirectory,"*.ini");
string selectedSet = files[rnd.Next(0, files.Length)];
parser = new IniParser(selectedSet);
currentSet.basePath = parser.GetSetting("Set", "BasePath");
currentSet.compileSong = parser.GetSetting("Set", "CompileSong").Split(';');
currentSet.successSong = parser.GetSetting("Set", "SuccessSong").Split(';');
currentSet.failSong = parser.GetSetting("Set", "FailSong").Split(';');
}
/// <summary>
/// Parses CompilingMusicSettings.ini into the global variable "settings".
/// </summary>
private void loadSettings()
{
FileInfo settingInfo = new FileInfo(userDir + "\\Visual Studio 2010\\Addins\\CompilingMusicSettings.ini");
if (settingLastModified == settingInfo.LastWriteTime)
return;
parser = new IniParser(userDir + "\\Visual Studio 2010\\Addins\\CompilingMusicSettings.ini");
settings.bassUser = parser.GetSetting("bass", "email");
settings.bassCode = parser.GetSetting("bass", "code");
settings.setMode = Boolean.Parse(parser.GetSetting("options", "setMode"));
settings.setDirectory = parser.GetSetting("options", "setDirectory");
settings.randomCompileDirectory = parser.GetSetting("options", "randomCompileDirectory");
settings.randomFailDirectory = parser.GetSetting("options", "randomFailDirectory");
settings.randomSuccessDirectory = parser.GetSetting("options", "randomSuccessDirectory");
settings.STFU = Boolean.Parse(parser.GetSetting("options", "STFU"));
settingLastModified = settingInfo.LastWriteTime;
}
private void LoadEditorSettings()
{
//scintillaEditor.Snippets.List.Add(new Snippet("if", "IF THEN END"));
//scintillaEditor.Snippets.IsEnabled = true;
// Editor font
var fontFiles = Directory.GetFiles(".", "*.ttf", SearchOption.AllDirectories);
if (fontFiles.Any())
{
try
{
_fontCollection = new PrivateFontCollection();
_fontCollection.AddFontFile(fontFiles.FirstOrDefault(f => f == Settings.Default.EditorPreferedFontFile) ?? fontFiles[0]);
editor.Font = new Font(_fontCollection.Families[0], (int) Settings.Default.EditorFontSize);
//foreach (StylesCommon s in Enum.GetValues(typeof (StylesCommon)))
foreach (var s in editor.Lexing.StyleNameMap.Keys)
{
editor.Styles[s].Font = new Font(_fontCollection.Families[0],
(int) Settings.Default.EditorFontSize, editor.Styles[s].Font.Style);
}
}
catch
{
}
}
// Editor font colors
if (!Settings.Default.EditorSkipLoadingPrimePadIni && File.Exists("PrimePad.ini"))
{
var config = new IniParser("PrimePad.ini");
editor.Lexing.Lexer = Lexer.CppNoCase;
for (var i = 0; i < 2; i++)
{
var tmp = config.GetSetting("lexing", "keywords"+i);
if (tmp != null)
editor.Lexing.Keywords[i] = tmp;
}
foreach (var s in editor.Lexing.StyleNameMap.Keys)
{
var c = config.GetSetting("styles", s + "_ForeColor", Color.Empty);
if (c != Color.Empty)
editor.Styles[s].ForeColor = c;
c = config.GetSetting<Color>("styles", s + "_BackColor", Color.Empty);
if (c != Color.Empty)
editor.Styles[s].BackColor = c;
}
}
// Other options
editor.Indentation.IndentWidth = (int) Settings.Default.EditorIndentationSize;
editor.Indentation.TabWidth = (int) Settings.Default.EditorIndentationTabWidth;
editor.Indentation.UseTabs = !Settings.Default.EditorIndentationUseSpacesAsDefault;
editor.Margins.Margin0.Width = (int) Settings.Default.EditorMargin0;
// Word wrap
editor.LineWrapping.Mode = Settings.Default.EditorWordWrap ? LineWrappingMode.Word : LineWrappingMode.None;
}
public string GetProperty(string strPropertyName)
{
IniParser parser = new IniParser(this.ServerDirectory + @"\server.properties");
return parser.GetSetting("ROOT", strPropertyName);
}
public string GetProperty(string strPropertyName)
{
try
{
IniParser parser = new IniParser(this.ServerDirectory + @"\server.properties");
return parser.GetSetting("ROOT", strPropertyName);
}
catch (Exception e)
{
Database.AddLog("Cannot get property \"" + strPropertyName + "\" for server " + this.ServerTitle, "server", "error", false, this.ServerID);
return null;
}
}
