mirror of
https://github.com/ddnet/ddnet.git
synced 2024-11-18 14:08:19 +00:00
551 lines
24 KiB
Rust
551 lines
24 KiB
Rust
use ddnet_base::ColorRGBA;
|
|
use ddnet_base::UserPtr;
|
|
|
|
pub use self::ffi::CreateConsole;
|
|
pub use self::ffi::IConsole;
|
|
pub use self::ffi::IConsole_IResult;
|
|
|
|
/// Command callback for `IConsole`.
|
|
///
|
|
/// See [`IConsole::Register`] for an example.
|
|
#[allow(non_camel_case_types)]
|
|
#[repr(transparent)]
|
|
pub struct IConsole_FCommandCallback(pub extern "C" fn(result: &IConsole_IResult, user: UserPtr));
|
|
|
|
unsafe impl cxx::ExternType for IConsole_FCommandCallback {
|
|
type Id = cxx::type_id!("IConsole_FCommandCallback");
|
|
type Kind = cxx::kind::Trivial;
|
|
}
|
|
|
|
#[cxx::bridge]
|
|
mod ffi {
|
|
unsafe extern "C++" {
|
|
include!("base/rust.h");
|
|
include!("engine/console.h");
|
|
include!("engine/rust.h");
|
|
|
|
type ColorRGBA = ddnet_base::ColorRGBA;
|
|
type ColorHSLA = ddnet_base::ColorHSLA;
|
|
type StrRef<'a> = ddnet_base::StrRef<'a>;
|
|
type UserPtr = ddnet_base::UserPtr;
|
|
type IConsole_FCommandCallback = super::IConsole_FCommandCallback;
|
|
|
|
/// Represents the arguments to a console command for [`IConsole`].
|
|
///
|
|
/// You can only obtain this type in the command callback
|
|
/// [`IConsole_FCommandCallback`] specified in [`IConsole::Register`].
|
|
type IConsole_IResult;
|
|
|
|
/// Get the n-th parameter of the command as an integer.
|
|
///
|
|
/// If the index is out of range, this returns 0. If the parameter
|
|
/// cannot be parsed as an integer, this also returns 0.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate ddnet_test;
|
|
/// # use ddnet_base::UserPtr;
|
|
/// # use ddnet_base::s;
|
|
/// # use ddnet_engine::CreateConsole;
|
|
/// # use ddnet_engine::IConsole;
|
|
/// # use ddnet_engine::IConsole_FCommandCallback;
|
|
/// # use ddnet_engine::IConsole_IResult;
|
|
/// # use ddnet_engine_shared::CFGFLAG_SERVER;
|
|
/// #
|
|
/// # let mut console = CreateConsole(CFGFLAG_SERVER);
|
|
/// # let mut executed = false;
|
|
/// # console.pin_mut().Register(s!("command"), s!("sss"), CFGFLAG_SERVER, IConsole_FCommandCallback(callback), UserPtr::from(&mut executed), s!(""));
|
|
/// # console.pin_mut().ExecuteLine(s!(r#"command "1337" abc -7331def"#), -1, true);
|
|
/// # extern "C" fn callback(result_param: &IConsole_IResult, mut user: UserPtr) {
|
|
/// # unsafe { *user.cast_mut::<bool>() = true; }
|
|
/// let result: &IConsole_IResult /* = `command "1337" abc -7331def` */;
|
|
/// # result = result_param;
|
|
/// assert_eq!(result.GetInteger(0), 1337);
|
|
/// assert_eq!(result.GetInteger(1), 0); // unparsable
|
|
/// assert_eq!(result.GetInteger(2), -7331); // parsable start
|
|
/// assert_eq!(result.GetInteger(3), 0); // out of range
|
|
/// # }
|
|
/// # assert!(executed);
|
|
/// ```
|
|
pub fn GetInteger(self: &IConsole_IResult, Index: u32) -> i32;
|
|
|
|
/// Get the n-th parameter of the command as a floating point number.
|
|
///
|
|
/// If the index is out of range, this returns 0.0. If the parameter
|
|
/// cannot be parsed as a floating point number, this also returns 0.0.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate ddnet_test;
|
|
/// # use ddnet_base::UserPtr;
|
|
/// # use ddnet_base::s;
|
|
/// # use ddnet_engine::CreateConsole;
|
|
/// # use ddnet_engine::IConsole;
|
|
/// # use ddnet_engine::IConsole_FCommandCallback;
|
|
/// # use ddnet_engine::IConsole_IResult;
|
|
/// # use ddnet_engine_shared::CFGFLAG_SERVER;
|
|
/// #
|
|
/// # let mut console = CreateConsole(CFGFLAG_SERVER);
|
|
/// # let mut executed = false;
|
|
/// # console.pin_mut().Register(s!("command"), s!("sss"), CFGFLAG_SERVER, IConsole_FCommandCallback(callback), UserPtr::from(&mut executed), s!(""));
|
|
/// # console.pin_mut().ExecuteLine(s!(r#"command "13.37" abc -73.31def"#), -1, true);
|
|
/// # extern "C" fn callback(result_param: &IConsole_IResult, mut user: UserPtr) {
|
|
/// # unsafe { *user.cast_mut::<bool>() = true; }
|
|
/// let result: &IConsole_IResult /* = `command "13.37" abc -73.31def` */;
|
|
/// # result = result_param;
|
|
/// assert_eq!(result.GetFloat(0), 13.37);
|
|
/// assert_eq!(result.GetFloat(1), 0.0); // unparsable
|
|
/// assert_eq!(result.GetFloat(2), -73.31); // parsable start
|
|
/// assert_eq!(result.GetFloat(3), 0.0); // out of range
|
|
/// # }
|
|
/// # assert!(executed);
|
|
/// ```
|
|
pub fn GetFloat(self: &IConsole_IResult, Index: u32) -> f32;
|
|
|
|
/// Get the n-th parameter of the command as a string.
|
|
///
|
|
/// If the index is out of range, this returns the empty string `""`.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate ddnet_test;
|
|
/// # use ddnet_base::UserPtr;
|
|
/// # use ddnet_base::s;
|
|
/// # use ddnet_engine::CreateConsole;
|
|
/// # use ddnet_engine::IConsole;
|
|
/// # use ddnet_engine::IConsole_FCommandCallback;
|
|
/// # use ddnet_engine::IConsole_IResult;
|
|
/// # use ddnet_engine_shared::CFGFLAG_SERVER;
|
|
/// #
|
|
/// # let mut console = CreateConsole(CFGFLAG_SERVER);
|
|
/// # let mut executed = false;
|
|
/// # console.pin_mut().Register(s!("command"), s!("sss"), CFGFLAG_SERVER, IConsole_FCommandCallback(callback), UserPtr::from(&mut executed), s!(""));
|
|
/// # console.pin_mut().ExecuteLine(s!(r#"command "I'm in space" '' "\"\\Escapes\?\"\n""#), -1, true);
|
|
/// # extern "C" fn callback(result_param: &IConsole_IResult, mut user: UserPtr) {
|
|
/// # unsafe { *user.cast_mut::<bool>() = true; }
|
|
/// let result: &IConsole_IResult /* = `command "I'm in space" '' "\"\\Escapes\?\"\n"` */;
|
|
/// # result = result_param;
|
|
/// assert_eq!(result.GetString(0), "I'm in space");
|
|
/// assert_eq!(result.GetString(1), "''");
|
|
/// assert_eq!(result.GetString(2), r#""\Escapes\?"\n"#); // only \\ and \" escapes
|
|
/// assert_eq!(result.GetString(3), ""); // out of range
|
|
/// # }
|
|
/// # assert!(executed);
|
|
/// ```
|
|
pub fn GetString(self: &IConsole_IResult, Index: u32) -> StrRef<'_>;
|
|
|
|
/// Get the n-th parameter of the command as a color.
|
|
///
|
|
/// If the index is out of range, this returns black. If the parameter
|
|
/// cannot be parsed as a color, this also returns black.
|
|
///
|
|
/// It supports the following formats:
|
|
/// - `$XXX` (RGB, e.g. `$f00` for red)
|
|
/// - `$XXXX` (RGBA, e.g. `$f00f` for red with maximum opacity)
|
|
/// - `$XXXXXX` (RGB, e.g. `$ffa500` for DDNet's logo color)
|
|
/// - `$XXXXXXXX` (RGBA, e.g. `$ffa500ff` for DDNet's logo color with maximum opacity)
|
|
/// - base 10 integers (24/32 bit HSL in base 10, e.g. `0` for black)
|
|
/// - the following color names: `red`, `yellow`, `green`, `cyan`,
|
|
/// `blue`, `magenta`, `white`, `gray`, `black`.
|
|
///
|
|
/// The `Light` parameter influences the interpretation of base 10
|
|
/// integers, if it is set, the lightness channel is divided by 2 and
|
|
/// 0.5 is added, making 0.5 the darkest and 1.0 the lightest possible
|
|
/// value.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate ddnet_test;
|
|
/// # use ddnet_base::ColorHSLA;
|
|
/// # use ddnet_base::UserPtr;
|
|
/// # use ddnet_base::s;
|
|
/// # use ddnet_engine::CreateConsole;
|
|
/// # use ddnet_engine::IConsole;
|
|
/// # use ddnet_engine::IConsole_FCommandCallback;
|
|
/// # use ddnet_engine::IConsole_IResult;
|
|
/// # use ddnet_engine_shared::CFGFLAG_SERVER;
|
|
/// #
|
|
/// # let mut console = CreateConsole(CFGFLAG_SERVER);
|
|
/// # let mut executed = false;
|
|
/// # console.pin_mut().Register(s!("command"), s!("ssssssss"), CFGFLAG_SERVER, IConsole_FCommandCallback(callback), UserPtr::from(&mut executed), s!(""));
|
|
/// # console.pin_mut().ExecuteLine(s!(r#"command "$f00" $ffa500 $12345 shiny cyan -16777216 $f008 $00ffff80"#), -1, true);
|
|
/// # extern "C" fn callback(result_param: &IConsole_IResult, mut user: UserPtr) {
|
|
/// # unsafe { *user.cast_mut::<bool>() = true; }
|
|
/// let result: &IConsole_IResult /* = `command "$f00" $ffa500 $12345 shiny cyan -16777216 $f008 $00ffff80` */;
|
|
/// # result = result_param;
|
|
/// assert_eq!(result.GetColor(0, false), ColorHSLA { h: 0.0, s: 1.0, l: 0.5, a: 1.0 }); // red
|
|
/// assert_eq!(result.GetColor(1, false), ColorHSLA { h: 0.10784314, s: 1.0, l: 0.5, a: 1.0 }); // DDNet logo color
|
|
/// assert_eq!(result.GetColor(2, false), ColorHSLA { h: 0.0, s: 0.0, l: 0.0, a: 1.0 }); // cannot be parsed => black
|
|
/// assert_eq!(result.GetColor(3, false), ColorHSLA { h: 0.0, s: 0.0, l: 0.0, a: 1.0 }); // unknown color name => black
|
|
/// assert_eq!(result.GetColor(4, false), ColorHSLA { h: 0.5, s: 1.0, l: 0.5, a: 1.0 }); // cyan
|
|
/// assert_eq!(result.GetColor(5, false), ColorHSLA { h: 0.0, s: 0.0, l: 0.0, a: 1.0 }); // black
|
|
/// assert_eq!(result.GetColor(6, false), ColorHSLA { h: 0.0, s: 1.0, l: 0.5, a: 0.53333336 }); // red with alpha specified
|
|
/// assert_eq!(result.GetColor(7, false), ColorHSLA { h: 0.5, s: 1.0, l: 0.5, a: 0.5019608 }); // cyan with alpha specified
|
|
/// assert_eq!(result.GetColor(8, false), ColorHSLA { h: 0.0, s: 0.0, l: 0.0, a: 1.0 }); // out of range => black
|
|
///
|
|
/// assert_eq!(result.GetColor(0, true), result.GetColor(0, false));
|
|
/// assert_eq!(result.GetColor(1, true), result.GetColor(1, false));
|
|
/// assert_eq!(result.GetColor(2, true), result.GetColor(2, false));
|
|
/// assert_eq!(result.GetColor(3, true), result.GetColor(3, false));
|
|
/// assert_eq!(result.GetColor(4, true), result.GetColor(4, false));
|
|
/// assert_eq!(result.GetColor(5, true), ColorHSLA { h: 0.0, s: 0.0, l: 0.5, a: 1.0 }); // black, but has the `Light` parameter set
|
|
/// assert_eq!(result.GetColor(6, true), result.GetColor(6, false));
|
|
/// assert_eq!(result.GetColor(7, true), result.GetColor(7, false));
|
|
/// assert_eq!(result.GetColor(8, true), result.GetColor(8, false));
|
|
/// # }
|
|
/// # assert!(executed);
|
|
/// ```
|
|
pub fn GetColor(self: &IConsole_IResult, Index: u32, Light: bool) -> ColorHSLA;
|
|
|
|
/// Get the number of parameters passed.
|
|
///
|
|
/// This is mostly important for commands that have optional parameters
|
|
/// (`?`) and thus support variable numbers of arguments.
|
|
///
|
|
/// See [`IConsole::Register`] for more details.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate ddnet_test;
|
|
/// # use ddnet_base::ColorHSLA;
|
|
/// # use ddnet_base::UserPtr;
|
|
/// # use ddnet_base::s;
|
|
/// # use ddnet_engine::CreateConsole;
|
|
/// # use ddnet_engine::IConsole;
|
|
/// # use ddnet_engine::IConsole_FCommandCallback;
|
|
/// # use ddnet_engine::IConsole_IResult;
|
|
/// # use ddnet_engine_shared::CFGFLAG_SERVER;
|
|
/// #
|
|
/// # let mut console = CreateConsole(CFGFLAG_SERVER);
|
|
/// # let mut executed: u32 = 0;
|
|
/// # console.pin_mut().Register(s!("command"), s!("s?ss"), CFGFLAG_SERVER, IConsole_FCommandCallback(callback), UserPtr::from(&mut executed), s!(""));
|
|
/// # console.pin_mut().ExecuteLine(s!(r#"command one two three"#), -1, true);
|
|
/// # console.pin_mut().ExecuteLine(s!(r#"command "one two" "three four""#), -1, true);
|
|
/// # extern "C" fn callback(result_param: &IConsole_IResult, mut user: UserPtr) {
|
|
/// # let executed;
|
|
/// # unsafe { executed = *user.cast_mut::<u32>(); *user.cast_mut::<u32>() += 1; }
|
|
/// # if executed == 0 {
|
|
/// let result: &IConsole_IResult /* = `command one two three` */;
|
|
/// # result = result_param;
|
|
/// assert_eq!(result.NumArguments(), 3);
|
|
///
|
|
/// # } else if executed == 1 {
|
|
/// let result: &IConsole_IResult /* = `command "one two" "three four"` */;
|
|
/// # result = result_param;
|
|
/// assert_eq!(result.NumArguments(), 2);
|
|
/// # }
|
|
/// # }
|
|
/// # assert!(executed == 2);
|
|
/// ```
|
|
pub fn NumArguments(self: &IConsole_IResult) -> i32;
|
|
|
|
/// Get the value of the sole victim (`v`) parameter.
|
|
///
|
|
/// This is mostly important for commands that have optional parameters
|
|
/// and thus support variable numbers of arguments.
|
|
///
|
|
/// See [`IConsole::Register`] for more details.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate ddnet_test;
|
|
/// # use ddnet_base::UserPtr;
|
|
/// # use ddnet_base::s;
|
|
/// # use ddnet_engine::CreateConsole;
|
|
/// # use ddnet_engine::IConsole;
|
|
/// # use ddnet_engine::IConsole_FCommandCallback;
|
|
/// # use ddnet_engine::IConsole_IResult;
|
|
/// # use ddnet_engine_shared::CFGFLAG_SERVER;
|
|
/// #
|
|
/// # let mut console = CreateConsole(CFGFLAG_SERVER);
|
|
/// # let mut executed: u32 = 0;
|
|
/// # console.pin_mut().Register(s!("command"), s!("v"), CFGFLAG_SERVER, IConsole_FCommandCallback(callback), UserPtr::from(&mut executed), s!(""));
|
|
/// # console.pin_mut().ExecuteLine(s!(r#"command me"#), 33, true);
|
|
/// # console.pin_mut().ExecuteLine(s!(r#"command string"#), 33, true);
|
|
/// # console.pin_mut().ExecuteLine(s!(r#"command 42"#), 33, true);
|
|
/// # console.pin_mut().ExecuteLine(s!(r#"command all"#), 33, true);
|
|
/// # extern "C" fn callback(result_param: &IConsole_IResult, mut user: UserPtr) {
|
|
/// # let executed;
|
|
/// # unsafe { executed = *user.cast_mut::<u32>(); *user.cast_mut::<u32>() += 1; }
|
|
/// # match executed {
|
|
/// # 0 => {
|
|
/// let result: &IConsole_IResult /* = `command me` */;
|
|
/// # result = result_param;
|
|
/// // Assume the executing client ID is 33.
|
|
/// assert_eq!(result.GetVictim(), 33);
|
|
///
|
|
/// # }
|
|
/// # 1 => {
|
|
/// let result: &IConsole_IResult /* = `command string` */;
|
|
/// # result = result_param;
|
|
/// assert_eq!(result.GetVictim(), 0);
|
|
///
|
|
/// # }
|
|
/// # 2 => {
|
|
/// let result: &IConsole_IResult /* = `command 42` */;
|
|
/// # result = result_param;
|
|
/// assert_eq!(result.GetVictim(), 42);
|
|
///
|
|
/// # }
|
|
/// # 3 => {
|
|
/// let result: &IConsole_IResult /* = `command all` first invocation */;
|
|
/// # result = result_param;
|
|
/// assert_eq!(result.GetVictim(), 0);
|
|
/// # }
|
|
/// # 4 => {
|
|
/// let result: &IConsole_IResult /* = `command all` second invocation */;
|
|
/// # result = result_param;
|
|
/// assert_eq!(result.GetVictim(), 1);
|
|
/// # }
|
|
/// // …
|
|
/// # 66 => {
|
|
/// let result: &IConsole_IResult /* = `command all` last invocation */;
|
|
/// # result = result_param;
|
|
/// assert_eq!(result.GetVictim(), 63);
|
|
/// # }
|
|
/// # _ => {}
|
|
/// # }
|
|
/// # }
|
|
/// # assert!(executed == 67);
|
|
/// ```
|
|
pub fn GetVictim(self: &IConsole_IResult) -> i32;
|
|
|
|
/// Console interface, consists of logging output and command execution.
|
|
///
|
|
/// This is used for the local console in the client and the remote
|
|
/// console of the server. It handles commands, their inputs and
|
|
/// outputs, command completion and also command and log output.
|
|
///
|
|
/// Call [`CreateConsole`] to obtain an instance.
|
|
type IConsole;
|
|
|
|
/// Execute a command in the console.
|
|
///
|
|
/// Commands can be separated by semicolons (`;`), everything after a
|
|
/// hash sign (`#`) is treated as a comment and discarded. Parameters
|
|
/// are separated by spaces (` `). By quoting arguments with double
|
|
/// quotes (`"`), the special meaning of the other characters can be
|
|
/// disabled. Double quotes can be escaped as `\"` and backslashes can
|
|
/// be escaped as `\\` inside double quotes.
|
|
///
|
|
/// When `InterpretSemicolons` is `false`, semicolons are not
|
|
/// interpreted unless the command starts with `mc;`.
|
|
///
|
|
/// The `ClientID` parameter defaults to -1, `InterpretSemicolons` to
|
|
/// `true` in C++.
|
|
pub fn ExecuteLine(
|
|
self: Pin<&mut IConsole>,
|
|
pStr: StrRef<'_>,
|
|
ClientID: i32,
|
|
InterpretSemicolons: bool,
|
|
);
|
|
|
|
/// Log a message.
|
|
///
|
|
/// `Level` is one of
|
|
/// - [`IConsole_OUTPUT_LEVEL_STANDARD`](constant.IConsole_OUTPUT_LEVEL_STANDARD.html)
|
|
/// - [`IConsole_OUTPUT_LEVEL_ADDINFO`](constant.IConsole_OUTPUT_LEVEL_ADDINFO.html)
|
|
/// - [`IConsole_OUTPUT_LEVEL_DEBUG`](constant.IConsole_OUTPUT_LEVEL_DEBUG.html)
|
|
///
|
|
/// `pFrom` is some sort of module name, e.g. for code in the console,
|
|
/// it is usually "console". Other examples include "client",
|
|
/// "client/network", …
|
|
///
|
|
/// `pStr` is the actual log message.
|
|
///
|
|
/// `PrintColor` is the intended log color.
|
|
///
|
|
/// `PrintColor` defaults to [`gs_ConsoleDefaultColor`] in C++.
|
|
pub fn Print(
|
|
self: &IConsole,
|
|
Level: i32,
|
|
pFrom: StrRef<'_>,
|
|
pStr: StrRef<'_>,
|
|
PrintColor: ColorRGBA,
|
|
);
|
|
|
|
/// Register a command.
|
|
///
|
|
/// This function needs a command name, a parameter shortcode, some
|
|
/// flags that specify metadata about the command, a callback function
|
|
/// with associated `UserPtr` and a help string.
|
|
///
|
|
/// `Flags` must be a combination of
|
|
/// - [`CFGFLAG_SAVE`](../ddnet_engine_shared/constant.CFGFLAG_SAVE.html)
|
|
/// - [`CFGFLAG_CLIENT`](../ddnet_engine_shared/constant.CFGFLAG_CLIENT.html)
|
|
/// - [`CFGFLAG_SERVER`](../ddnet_engine_shared/constant.CFGFLAG_SERVER.html)
|
|
/// - [`CFGFLAG_STORE`](../ddnet_engine_shared/constant.CFGFLAG_STORE.html)
|
|
/// - [`CFGFLAG_MASTER`](../ddnet_engine_shared/constant.CFGFLAG_MASTER.html)
|
|
/// - [`CFGFLAG_ECON`](../ddnet_engine_shared/constant.CFGFLAG_ECON.html)
|
|
/// - [`CMDFLAG_TEST`](../ddnet_engine_shared/constant.CMDFLAG_TEST.html)
|
|
/// - [`CFGFLAG_CHAT`](../ddnet_engine_shared/constant.CFGFLAG_CHAT.html)
|
|
/// - [`CFGFLAG_GAME`](../ddnet_engine_shared/constant.CFGFLAG_GAME.html)
|
|
/// - [`CFGFLAG_NONTEEHISTORIC`](../ddnet_engine_shared/constant.CFGFLAG_NONTEEHISTORIC.html)
|
|
/// - [`CFGFLAG_COLLIGHT`](../ddnet_engine_shared/constant.CFGFLAG_COLLIGHT.html)
|
|
/// - [`CFGFLAG_INSENSITIVE`](../ddnet_engine_shared/constant.CFGFLAG_INSENSITIVE.html)
|
|
///
|
|
/// # Parameter shortcode
|
|
///
|
|
/// The following parameter types are supported:
|
|
///
|
|
/// - `i`, `f`, `s`: **I**nteger, **f**loat, and **s**tring parameter,
|
|
/// respectively. Since they're not type-checked, they're all the
|
|
/// same, one word delimited by whitespace or any quoted string.
|
|
/// Examples: `12`, `example`, `"Hello, World!"`.
|
|
/// - `r`: **R**est of the command line, possibly multiple word, until
|
|
/// the next command or the end of line. Alternatively one quoted
|
|
/// parameter. Examples: `multiple words even without quotes`,
|
|
/// `"quotes are fine, too"`.
|
|
/// - `v`: **V**ictim client ID for this command. Supports the special
|
|
/// parameters `me` for the executing client ID, and `all` to target
|
|
/// all players. Examples: `0`, `63`, `words` (gets parsed as `0`),
|
|
/// `me`, `all`.
|
|
///
|
|
/// The parameter shortcode is now a string consisting of any number of
|
|
/// these parameter type characters, a question mark `?` to mark the
|
|
/// beginning of optional parameters and `[<string>]` help strings after
|
|
/// each parameter that can have a short explanation.
|
|
///
|
|
/// Examples:
|
|
///
|
|
/// - `echo` has `r[text]`: Takes the whole command line as the first
|
|
/// parameter. This means we get the following arguments:
|
|
/// ```text
|
|
/// ## "1"
|
|
/// echo 1
|
|
///
|
|
/// ## "multiple words"
|
|
/// echo multiple words
|
|
///
|
|
/// ## error: missing argument
|
|
/// echo
|
|
///
|
|
/// ## "multiple"
|
|
/// echo "multiple" "quoted" "arguments"
|
|
///
|
|
/// ## "comments"
|
|
/// echo comments # work too
|
|
///
|
|
/// ## "multiple"; "commands"
|
|
/// echo multiple; echo commands
|
|
/// ```
|
|
/// - `muteid` has `v[id] i[seconds] ?r[reason]`. Assume the local
|
|
/// player has client ID 33, then we get the following
|
|
/// arguments:
|
|
/// ```text
|
|
/// ## "33" "60"
|
|
/// muteid me 60
|
|
///
|
|
/// ## "12" "120" "You're a wonderful person"
|
|
/// muteid 12 120 You're a wonderful person
|
|
///
|
|
/// ## "0" "180"; "1" "180"; …, "63" "180"
|
|
/// muteid all 180
|
|
/// ```
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate ddnet_test;
|
|
/// use ddnet_base::UserPtr;
|
|
/// use ddnet_base::s;
|
|
/// use ddnet_engine::CreateConsole;
|
|
/// use ddnet_engine::IConsole;
|
|
/// use ddnet_engine::IConsole_FCommandCallback;
|
|
/// use ddnet_engine::IConsole_IResult;
|
|
/// use ddnet_engine::IConsole_OUTPUT_LEVEL_STANDARD;
|
|
/// use ddnet_engine::gs_ConsoleDefaultColor;
|
|
/// use ddnet_engine_shared::CFGFLAG_SERVER;
|
|
///
|
|
/// extern "C" fn print_callback(_: &IConsole_IResult, user: UserPtr) {
|
|
/// let console: &IConsole = unsafe { user.cast() };
|
|
/// console.Print(IConsole_OUTPUT_LEVEL_STANDARD, s!("example"), s!("print callback"), gs_ConsoleDefaultColor);
|
|
/// }
|
|
///
|
|
/// let mut console = CreateConsole(CFGFLAG_SERVER);
|
|
/// let user = (&*console).into();
|
|
/// console.pin_mut().Register(s!("example"), s!(""), CFGFLAG_SERVER, IConsole_FCommandCallback(print_callback), user, s!("Example command outputting a single line into the console"));
|
|
/// console.pin_mut().ExecuteLine(s!("example"), -1, true);
|
|
/// ```
|
|
pub fn Register(
|
|
self: Pin<&mut IConsole>,
|
|
pName: StrRef<'_>,
|
|
pParams: StrRef<'_>,
|
|
Flags: i32,
|
|
pfnFunc: IConsole_FCommandCallback,
|
|
pUser: UserPtr,
|
|
pHelp: StrRef<'_>,
|
|
);
|
|
|
|
/// Create a console instance.
|
|
///
|
|
/// It comes with a few registered commands by default. Only the
|
|
/// commands sharing a bit with the `FlagMask` parameter are considered
|
|
/// when executing commands.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// # extern crate ddnet_test;
|
|
/// use ddnet_base::s;
|
|
/// use ddnet_engine::CreateConsole;
|
|
/// use ddnet_engine_shared::CFGFLAG_SERVER;
|
|
///
|
|
/// let mut console = CreateConsole(CFGFLAG_SERVER);
|
|
/// console.pin_mut().ExecuteLine(s!("cmdlist; echo hi!"), -1, true);
|
|
/// ```
|
|
pub fn CreateConsole(FlagMask: i32) -> UniquePtr<IConsole>;
|
|
}
|
|
}
|
|
|
|
/// Default console output color. White.
|
|
///
|
|
/// Corresponds to the `gs_ConsoleDefaultColor` constant of the same name in
|
|
/// C++.
|
|
///
|
|
/// Used as a last parameter in [`IConsole::Print`].
|
|
///
|
|
/// It is treated as "no color" in the console code, meaning that the default
|
|
/// color of the output medium isn't overridden.
|
|
#[allow(non_upper_case_globals)]
|
|
pub const gs_ConsoleDefaultColor: ColorRGBA = ColorRGBA {
|
|
r: 1.0,
|
|
g: 1.0,
|
|
b: 1.0,
|
|
a: 1.0,
|
|
};
|
|
|
|
/// Default console output level.
|
|
///
|
|
/// Corresponds to the `IConsole::OUTPUT_LEVEL_STANDARD` enum value in C++.
|
|
///
|
|
/// Used as a first parameter in [`IConsole::Print`].
|
|
///
|
|
/// This is the only level that is shown by default.
|
|
#[allow(non_upper_case_globals)]
|
|
pub const IConsole_OUTPUT_LEVEL_STANDARD: i32 = 0;
|
|
/// First more verbose console output level.
|
|
///
|
|
/// Corresponds to the `IConsole::OUTPUT_LEVEL_ADDINFO` enum value in C++.
|
|
///
|
|
/// Used as a first parameter in [`IConsole::Print`].
|
|
///
|
|
/// This output level is not shown by default.
|
|
#[allow(non_upper_case_globals)]
|
|
pub const IConsole_OUTPUT_LEVEL_ADDINFO: i32 = 1;
|
|
/// Most verbose console output level.
|
|
///
|
|
/// Corresponds to the `IConsole::OUTPUT_LEVEL_DEBUG` enum value in C++.
|
|
///
|
|
/// Used as a first parameter in [`IConsole::Print`].
|
|
///
|
|
/// This output level is not shown by default.
|
|
#[allow(non_upper_case_globals)]
|
|
pub const IConsole_OUTPUT_LEVEL_DEBUG: i32 = 2;
|