/// <summary> /// Initializes a new instance of the <see cref="DynamicCVar"/> class. Used by /// CryConsole.RegisterCVar to construct the CVar. /// </summary> /// <param name="name"> </param> /// <param name="value"></param> /// <param name="flags"></param> /// <param name="help"> </param> internal DynamicCVar(string name, object value, CVarFlags flags, string help) { this.Flags = flags; this.Help = help; this.Name = name; if (value is int) { this.intValue = (int)value; Native.ConsoleInterop.RegisterCVarInt(this.Name, ref this.intValue, this.intValue, this.Flags, this.Help); } else if (value is float || value is double) { this.floatValue = (float)value; Native.ConsoleInterop.RegisterCVarFloat(this.Name, ref this.floatValue, this.floatValue, this.Flags, this.Help); } else if (value is string) { this.stringValue = value as string; // String CVars are not supported yet. Native.ConsoleInterop.RegisterCVarString(this.Name, this.stringValue, this.stringValue, this.Flags, this.Help); } else throw new ConsoleVariableException(string.Format("Invalid data type ({0}) used in CVar {1}.", value.GetType(), this.Name)); }
/// <summary> /// Initializes a new instance of the <see cref="DynamicCVar"/> class. Used by /// CryConsole.RegisterCVar to construct the CVar. /// </summary> /// <param name="name"> </param> /// <param name="value"></param> /// <param name="flags"></param> /// <param name="help"> </param> internal DynamicCVar(string name, object value, CVarFlags flags, string help) { this.Flags = flags; this.Help = help; this.Name = name; if (value is int) { this.intValue = (int)value; Native.ConsoleInterop.RegisterCVarInt(this.Name, ref this.intValue, this.intValue, this.Flags, this.Help); } else if (value is float || value is double) { this.floatValue = (float)value; Native.ConsoleInterop.RegisterCVarFloat(this.Name, ref this.floatValue, this.floatValue, this.Flags, this.Help); } else if (value is string) { this.stringValue = value as string; // String CVars are not supported yet. Native.ConsoleInterop.RegisterCVarString(this.Name, this.stringValue, this.stringValue, this.Flags, this.Help); } else { throw new ConsoleVariableException(string.Format("Invalid data type ({0}) used in CVar {1}.", value.GetType(), this.Name)); } }
public CVar(string name, CVarFlags flags) { Name = name; Flags = flags; GConsole.RegisterCVar(this); }
/// <summary> /// Initializes a new instance of the <see cref="DynamicCVar"/> class. /// Used by CryConsole.RegisterCVar to construct the CVar. /// </summary> /// <param name="name"></param> /// <param name="value"></param> /// <param name="flags"></param> /// <param name="help"></param> internal DynamicCVar(string name, object value, CVarFlags flags, string help) { Flags = flags; Help = help; Name = name; if (value is int) { intValue = (int)value; NativeCVarMethods.RegisterCVarInt(Name, ref intValue, intValue, Flags, Help); } else if (value is float || value is double) { floatValue = (float)value; NativeCVarMethods.RegisterCVarFloat(Name, ref floatValue, floatValue, Flags, Help); } else if (value is string) { stringValue = value as string; // String CVars are not supported yet. NativeCVarMethods.RegisterCVarString(Name, stringValue, stringValue, Flags, Help); } else throw new CVarException(string.Format("Invalid data type ({0}) used in CVar {1}.", value.GetType(), Name)); }
/// <summary> /// Initializes a new instance of the <see cref="DynamicCVar"/> class. /// Used by CryConsole.RegisterCVar to construct the CVar. /// </summary> /// <param name="name"></param> /// <param name="value"></param> /// <param name="flags"></param> /// <param name="help"></param> internal DynamicCVar(string name, object value, CVarFlags flags, string help) { Flags = flags; Help = help; Name = name; if (value is int) { intValue = (int)value; NativeCVarMethods.RegisterCVarInt(Name, ref intValue, intValue, Flags, Help); } else if (value is float || value is double) { floatValue = (float)value; NativeCVarMethods.RegisterCVarFloat(Name, ref floatValue, floatValue, Flags, Help); } else if (value is string) { stringValue = value as string; // String CVars are not supported yet. NativeCVarMethods.RegisterCVarString(Name, stringValue, stringValue, Flags, Help); } else { throw new CVarException(string.Format("Invalid data type ({0}) used in CVar {1}.", value.GetType(), Name)); } }
/// <summary> /// Registers a new console variable that will update the user defined integer. /// </summary> /// <param name="name">console variable name</param> /// <param name="value">reference to the memory that will be updated</param> /// <param name="help">help text that is shown when you use <paramref name="name"/> ? in the console</param> /// <param name="flags"></param> /// <returns>Newly null if failed, new CVar instance if successful</returns> public static CVar RegisterInt(string name, ref int value, string help = "", CVarFlags flags = CVarFlags.None) { NativeCVarMethods.RegisterCVarInt(name, ref value, value, flags, help); CVars.Add(new ByRefCVar(name)); return(CVars.Last()); }
/// <summary> /// Register a new console command. /// </summary> /// <param name="name">Command name.</param> /// <param name="func">Delegate to the console command function to be called when command is invoked.</param> /// <param name="comment">Help string, will be displayed when typing in console "command ?".</param> /// <param name="flags">Bitfield consist of VF_ flags (e.g. VF_CHEAT)</param> public static void Register(string name, ConsoleCommandDelegate func, string comment = "", CVarFlags flags = CVarFlags.None) { if (!commands.ContainsKey(name)) { NativeCVarMethods.RegisterCommand(name, comment, flags); commands.Add(name, func); } }
/// <summary> /// Register a new console command. /// </summary> /// <param name="name">Command name.</param> /// <param name="func">Delegate to the console command function to be called when command is invoked.</param> /// <param name="comment">Help string, will be displayed when typing in console "command ?".</param> /// <param name="flags">Bitfield consist of VF_ flags (e.g. VF_CHEAT)</param> public static void Register(string name, ConsoleCommandDelegate func, string comment = "", CVarFlags flags = CVarFlags.None, bool overwrite = false) { bool containsKey = Commands.ContainsKey(name); if (containsKey && overwrite) { Unregister(name); containsKey = false; } if (!containsKey) { NativeCVarMethods.RegisterCommand(name, comment, flags); Commands.Add(name, func); } else throw new DuplicateConsoleCommandException(string.Format("The console command {0} was already registered", name)); }
/// <inheritdoc /> public void RegisterCVar(string name, object defaultValue, CVarFlags flags = CVarFlags.NONE) { if (_configVars.TryGetValue(name, out ConfigVar cVar)) { if (cVar.Registered) { Logger.Error($"[CVar] The variable '{name}' has already been registered."); } cVar.DefaultValue = defaultValue; cVar.Flags = flags; cVar.Registered = true; return; } _configVars.Add(name, new ConfigVar(name, defaultValue, flags) { Registered = true, Value = defaultValue }); }
/// <summary> /// Create an engine cvar to register /// </summary> /// <param name="name"></param> /// <param name="value"></param> /// <param name="flags"></param> internal EngineCVar(string name, string value, CVarFlags flags) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException(nameof(name)); } if (value == null) { throw new ArgumentNullException(nameof(value)); } Data = (Native *)Marshal.AllocHGlobal(Marshal.SizeOf <Native>()).ToPointer(); Data->name = InterfaceUtils.AllocateUnmanagedString(name); Data->stringValue = InterfaceUtils.AllocateUnmanagedString(value); Data->flags = flags; IsOwned = true; }
/* ============ Cvar_Set_f Allows setting and defining of arbitrary cvars from console, even if they weren't declared in C code. ============ */ void Set_f(string[] tokens) { string cmd = tokens[0]; if (tokens.Length < 2) { Common.Instance.WriteLine("usage: {0} <variable> <value>", cmd); return; } if (tokens.Length == 2) { Print_f(tokens); return; } CVar v = Set2(tokens[1], Commands.ArgsFrom(tokens, 2), false); if (v == null) return; if (cmd.Length < 4) return; switch (cmd[3]) { case 'a': if ((v.Flags & CVarFlags.ARCHIVE) != CVarFlags.ARCHIVE) { v.Flags |= CVarFlags.ARCHIVE; modifiedFlags |= CVarFlags.ARCHIVE; } break; case 'u': if ((v.Flags & CVarFlags.USER_INFO) != CVarFlags.USER_INFO) { v.Flags |= CVarFlags.USER_INFO; modifiedFlags |= CVarFlags.USER_INFO; } break; case 's': if ((v.Flags & CVarFlags.SERVER_INFO) != CVarFlags.SERVER_INFO) { v.Flags |= CVarFlags.SERVER_INFO; modifiedFlags |= CVarFlags.SERVER_INFO; } break; } }
// Sets value of a cvar private CVar Set2(string name, string value, bool force) { if (!ValidateString(name)) { System.Console.WriteLine("WARNING: invalid cvar name string {0}", name); name = "BADNAME"; } CVar nvar = FindVar(name); if (nvar == null) { if (value == null) return null; // create it if (!force) return Get(name, value, CVarFlags.USER_CREATED); else return Get(name, value, CVarFlags.NONE); } CVar var = nvar; if (value == null || value.Equals("")) value = var.ResetString; value = Validate(var, value, true); if ((var.Flags & CVarFlags.LATCH) == CVarFlags.LATCH && var.LatchedString != null) { if (value.Equals(var.String)) { var.LatchedString = null; return var; } if (value.Equals(var.LatchedString)) return var; } else if (value.Equals(var.String)) return var; // note what types of cvars have been modified (userinfo, archive, serverinfo, systeminfo) modifiedFlags |= var.Flags; if (!force) { if ((var.Flags & CVarFlags.ROM) == CVarFlags.ROM) { System.Console.WriteLine("{0} is read only.", name); return var; } if ((var.Flags & CVarFlags.INIT) == CVarFlags.INIT) { System.Console.WriteLine("{0} is write protected.", name); return var; } if ((var.Flags & CVarFlags.LATCH) == CVarFlags.LATCH) { if (var.LatchedString != null) { if (value.Equals(var.LatchedString)) return var; var.LatchedString = null; } else { if (value.Equals(var.String)) return var; } System.Console.WriteLine("{0} will be changed upon restarting", name); var.LatchedString = value; var.Modified = true; var.ModificationCount++; return var; } } else { if (var.LatchedString != null) var.LatchedString = null; } if (value.Equals(var.String)) return var; // not changed var.Modified = true; var.ModificationCount++; var.String = value; float val; int val2; if (float.TryParse(value, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out val)) var.Value = val; if (int.TryParse(value, out val2)) { var.Integer = val2; var.Integral = true; } else var.Integral = false; return var; }
// Create an infostring with cvars the fulfill the cVarFlags attribute public string InfoString(CVarFlags cVarFlags) { StringBuilder str = new StringBuilder(); foreach (CVar var in vars.Values) { if (var.Name != null && var.Name.Length > 0 && (var.Flags & cVarFlags) == cVarFlags) { str.Append(string.Format("\\{0}\\{1}", var.Name, var.String)); } } return str.ToString(); }
// Gets a cvar. If it doesn't exist, it will be created public CVar Get(string name, string value, CVarFlags flags) { if (name == null || value == null || name.Equals("")) { System.Console.WriteLine("FATAL: CVar Get w/ null arguments"); return null; } if (!ValidateString(name)) { System.Console.WriteLine("Invalid cvar name string: {0}", name); name = "BADNAME"; } CVar nvar = FindVar(name); if (nvar != null) { CVar var = nvar; value = Validate(var, value, false); // if the C code is now specifying a variable that the user already // set a value for, take the new value as the reset value if((var.Flags & CVarFlags.USER_CREATED) == CVarFlags.USER_CREATED) { var.Flags &= ~CVarFlags.USER_CREATED; var.ResetString = value; if ((flags & CVarFlags.ROM) == CVarFlags.ROM) { // this variable was set by the user, // so force it to value given by the engine. var.LatchedString = value; } } var.Flags = flags; // only allow one non-empty reset string without a warning if (var.ResetString == null || var.ResetString.Equals("")) var.ResetString = value; else if (!value.Equals("") && value.Equals(var.ResetString)) { } // if we have a latched string, take that value now if (var.LatchedString != null) { string s = var.LatchedString; var.LatchedString = null; Set(name, s); } // ZOID--needs to be set so that cvars the game sets as // SERVERINFO get sent to clients modifiedFlags |= flags; return var; } // // allocate a new cvar // CVar cvar = new CVar(); cvar.Name = name; cvar.String = value; cvar.Modified = true; cvar.ModificationCount = 1; float val; int val2; if(float.TryParse(value, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out val)) cvar.Value = val; if (int.TryParse(value, out val2)) { cvar.Integer = val2; cvar.Integral = true; } cvar.ResetString = value; cvar.Validate = false; cvar.Flags = flags; // note what types of cvars have been modified (userinfo, archive, serverinfo, systeminfo) modifiedFlags |= cvar.Flags; vars.Add(name, cvar); return cvar; }
public ColorCVar(string name, CVarFlags flags = 0) : base(name, flags) { }
/// <summary> /// Registers a new console variable with the specified default value. /// </summary> /// <param name="name">console variable name</param> /// <param name="value">default value of the console variable</param> /// <param name="help">help text that is shown when you use <paramref name="name"/> ? in the console</param> /// <param name="flags"></param> /// <returns>Newly null if failed, new CVar instance if successful</returns> public static CVar Register(string name, string value, string help = "", CVarFlags flags = CVarFlags.None) { return(RegisterInternal(name, value, help, flags)); }
public ConsoleVariableAttribute(string name, string description, CVarFlags flags = CVarFlags.None) { }
protected static extern void _RegisterCommand(string name, string description, CVarFlags flags);
internal static extern void _RegisterCVarInt(string name, ref int val, int defaultVal, CVarFlags flags, string description);
public FixedCVar(string name, CVarFlags flags = 0) : base(name, flags) { }
internal static extern void RegisterCVarFloat(string name, ref float val, float defaultVal, CVarFlags flags, string description);
internal static extern void RegisterCommand(string name, string description, CVarFlags flags);
/// <summary> /// Registers a new console variable that will update the user defined integer. /// </summary> /// <param name="name">console variable name</param> /// <param name="value">reference to the memory that will be updated</param> /// <param name="help">help text that is shown when you use <paramref name="name"/> ? in the console</param> /// <param name="flags"></param> /// <returns>Newly null if failed, new CVar instance if successful</returns> public static CVar RegisterInt(string name, ref int value, string help = "", CVarFlags flags = CVarFlags.None) { NativeCVarMethods.RegisterCVarInt(name, ref value, value, flags, help); CVars.Add(new ExternalCVar(name)); return CVars.Last(); }
public IntCVar(string name, CVarFlags flags = 0, int init = 0) : base(name, flags) { val = init; }
/// <summary> /// Register a new console command. /// </summary> /// <param name="name">Command name.</param> /// <param name="func"> /// Delegate to the console command function to be called when command is invoked. /// </param> /// <param name="comment"> /// Help string, will be displayed when typing in console "command ?". /// </param> /// <param name="flags">Bitfield consist of VF_ flags (e.g. VF_CHEAT)</param> public static void Register(string name, ConsoleCommandDelegate func, string comment = "", CVarFlags flags = CVarFlags.None, bool overwrite = false) { bool containsKey = Commands.ContainsKey(name); if (containsKey && overwrite) { Unregister(name); containsKey = false; } if (!containsKey) { Native.ConsoleInterop.RegisterCommand(name, comment, flags); Commands.Add(name, func); } else { throw new DuplicateConsoleCommandException(string.Format("The console command {0} was already registered", name)); } }
public BoolCVar(string name, CVarFlags flags = 0, bool init = false) : base(name, flags) { val = init; }
/// <summary> /// Register a new console command. /// </summary> /// <param name="name">Command name.</param> /// <param name="func">Delegate to the console command function to be called when command is invoked.</param> /// <param name="comment">Help string, will be displayed when typing in console "command ?".</param> /// <param name="flags">Bitfield consist of VF_ flags (e.g. VF_CHEAT)</param> public static void Register(string name, ConsoleCommandDelegate func, string comment = "", CVarFlags flags = CVarFlags.None) { if (!commands.ContainsKey(name)) { NativeCVarMethods.RegisterCommand(name, comment, flags); commands.Add(name, func); } else { throw new DuplicateConsoleCommandException(string.Format("The console command {0} was already registered", name)); } }
internal static extern void _RegisterCVarString(string name, [MarshalAs(UnmanagedType.LPStr)] string val, string defaultVal, CVarFlags flags, string description);
public StringCVar(string name, CVarFlags flags = 0, string init = "") : base(name, flags) { val = init; }
internal static extern void RegisterCVarInt(string name, ref int val, int defaultVal, CVarFlags flags, string description);
internal static CVar RegisterInternal(string name, object value, string help, CVarFlags flags) { CVars.Add(new DynamicCVar(name, value, flags, help)); return(CVars.Last()); }
/// <summary> /// Registers a new console variable that will update the user defined float. /// </summary> /// <param name="name">console variable name</param> /// <param name="value">reference to the memory that will be updated</param> /// <param name="help">help text that is shown when you use <paramref name="name"/> ? in the console</param> /// <param name="flags"></param> /// <returns>Newly null if failed, new CVar instance if successful</returns> public static CVar RegisterFloat(string name, ref float value, string help = "", CVarFlags flags = CVarFlags.None) { NativeCVarMethods.RegisterCVarFloat(name, ref value, value, flags, help); CVars.Add(new ByRefCVar(name)); return CVars.Last(); }
/// <summary> /// Registers a new console variable with the specified default value. /// </summary> /// <param name="name">The name of the console variable.</param> /// <param name="value">Default value of the console variable</param> /// <param name="help"> /// Help text that is shown when you use <paramref name="name" />? in the console. /// </param> /// <param name="flags">A set of flags to assign to the variable.</param> /// <returns>Null if failed, new <see cref="CVar"/> instance if successful.</returns> public static CVar Register(string name, string value, string help = "", CVarFlags flags = CVarFlags.None) { return RegisterInternal(name, value, help, flags); }
public DummyCVar(string name, CVarFlags flags = 0, CVar init = null) : base(name, flags) { val = init; }
/// <summary> /// Constructs a CVar. /// </summary> /// <param name="name">The name of the CVar. This needs to contain only printable characters. /// Underscores '_' are reserved. Everything before the last underscore is a table identifier, /// everything after is the CVar name in the TOML document.</param> /// <param name="defaultValue">The default value of this CVar.</param> /// <param name="flags">Optional flags to modify the behavior of this CVar.</param> public ConfigVar(string name, object defaultValue, CVarFlags flags) { Name = name; DefaultValue = defaultValue; Flags = flags; }
/// <summary> /// Registers a new console variable that references a value. /// </summary> /// <param name="name">The name of the console variable.</param> /// <param name="value">Reference to the memory that will be updated.</param> /// <param name="help"> /// Help text that is shown when you use <paramref name="name" />? in the console. /// </param> /// <param name="flags">A set of flags to assign to the variable.</param> /// <returns>Null if failed, new <see cref="CVar"/> instance if successful.</returns> public static CVar RegisterInt(string name, ref int value, string help = "", CVarFlags flags = CVarFlags.None) { Native.ConsoleInterop.RegisterCVarInt(name, ref value, value, flags, help); CVars.Add(new ByRefCVar(name)); return CVars.Last(); }
internal static CVar RegisterInternal(string name, object value, string help, CVarFlags flags) { CVars.Add(new DynamicCVar(name, value, flags, help)); return CVars.Last(); }
internal static extern void RegisterCVarString(string name, [MarshalAs(UnmanagedType.LPStr)] string val, string defaultVal, CVarFlags flags, string description);
/// <summary> /// Registers a new console variable that references a value. /// </summary> /// <param name="name">The name of the console variable.</param> /// <param name="value">Reference to the memory that will be updated.</param> /// <param name="help"> /// Help text that is shown when you use <paramref name="name" />? in the console. /// </param> /// <param name="flags">A set of flags to assign to the variable.</param> /// <returns>Null if failed, new <see cref="CVar"/> instance if successful.</returns> public static CVar RegisterFloat(string name, ref float value, string help = "", CVarFlags flags = CVarFlags.None) { Native.ConsoleInterop.RegisterCVarFloat(name, ref value, value, flags, help); CVars.Add(new ByRefCVar(name)); return(CVars.Last()); }