/// <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);
internal static extern void RegisterCommand(string name, string description, CVarFlags flags);
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 extern void RegisterCVarFloat(string name, ref float val, float 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();
}
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());
}
