Lightyear

https://docs.rs/lightyear/0.26.4/lightyear/
Admin
Lightyear is a networking library for Bevy that provides plugins for creating multiplayer games with...
Tokens:1,555,904
Snippets:23,860
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Run Example Client

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/rustls/crypto/struct.CryptoProvider.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Execute the example client to verify the current ciphersuite and connection status.

```bash
$ cargo run --example client | head -3
Current ciphersuite: TLS13_CHACHA20_POLY1305_SHA256
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 19899
```

--------------------------------

### Gauge Usage Examples

Source: https://docs.rs/lightyear/0.26.4/lightyear/metrics/metrics/macro.gauge.html?search=u32+-%3E+bool

Examples demonstrating how to initialize gauges with labels, constants, dynamic values, and owned strings.

```rust
// A basic gauge:
let gauge = gauge!("some_metric_name");
gauge.increment(1.0);

// Specifying labels inline, including using constants for either the key or value:
let gauge = gauge!("some_metric_name", "service" => "http");
gauge.decrement(42.0);

const SERVICE_LABEL: &'static str = "service";
const SERVICE_HTTP: &'static str = "http";
let gauge = gauge!("some_metric_name", SERVICE_LABEL => SERVICE_HTTP);
gauge.increment(3.14);

// We can also pass labels by giving a vector or slice of key/value pairs.  In this scenario,
// a unit or description can still be passed in their respective positions:
let dynamic_val = "woo";
let labels = [("dynamic_key", format!("{}!", dynamic_val))];
let gauge = gauge!("some_metric_name", &labels);
gauge.set(1337.0);

// As mentioned in the documentation, metric names also can be owned strings, including ones
// generated at the callsite via things like `format!`:
let name = String::from("some_owned_metric_name");
let gauge = gauge!(name);

let gauge = gauge!(format!("{}_via_format", "name"));
```

--------------------------------

### Histogram Usage Examples

Source: https://docs.rs/lightyear/0.26.4/lightyear/metrics/metrics/macro.histogram.html

Examples demonstrating basic registration, inline labels, dynamic labels, and dynamic metric names.

```rust
// A basic histogram:
let histogram = histogram!("some_metric_name");
histogram.record(1.0);

// Specifying labels inline, including using constants for either the key or value:
let histogram = histogram!("some_metric_name", "service" => "http");

const SERVICE_LABEL: &'static str = "service";
const SERVICE_HTTP: &'static str = "http";
let histogram = histogram!("some_metric_name", SERVICE_LABEL => SERVICE_HTTP);

// We can also pass labels by giving a vector or slice of key/value pairs.  In this scenario,
// a unit or description can still be passed in their respective positions:
let dynamic_val = "woo";
let labels = [("dynamic_key", format!("{}!", dynamic_val))];
let histogram = histogram!("some_metric_name", &labels);

// As mentioned in the documentation, metric names also can be owned strings, including ones
// generated at the callsite via things like `format!`:
let name = String::from("some_owned_metric_name");
let histogram = histogram!(name);

let histogram = histogram!(format!("{}_via_format", "name"));
```

--------------------------------

### Retrieve match indices in strings

Source: https://docs.rs/lightyear/0.26.4/lightyear/websocket/prelude/tokio_tungstenite/tungstenite/struct.Utf8Bytes.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to get the start index of matches using match_indices and rmatch_indices.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);

let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);

let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

```rust
let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);

let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
assert_eq!(v, [(4, "abc"), (1, "abc")]);

let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
assert_eq!(v, [(2, "aba")]); // only the last `aba`
```

--------------------------------

### WebSocketServer::open

Source: https://docs.rs/lightyear/0.26.4/lightyear/websocket/server/struct.WebSocketServer.html

Creates an EntityCommand to initialize and start a WebSocket server with the provided configuration.

```APIDOC
## pub fn open(config: impl Into<ServerConfig>) -> impl EntityCommand

### Description
Creates an `EntityCommand` to set up a server and have it start listening for connections. This is the primary entry point for initializing the WebSocket server.

### Parameters
- **config** (impl Into<ServerConfig>) - Required - The configuration object defining server settings such as port and identity.

### Usage Example
```rust
let config = ServerConfig::builder()
    .with_bind_default(12345)
    .with_identity(identity);

commands.spawn_empty().queue(WebSocketServer::open(config));
```
```

--------------------------------

### ServerConfig::builder

Source: https://docs.rs/lightyear/0.26.4/lightyear/websocket/prelude/server/struct.ServerConfig.html?search=std%3A%3Avec

Starts the configuration process for a WebSocketServer.

```APIDOC
## pub const fn builder() -> ServerConfigBuilder<WantsBindAddress>

### Description
Starts creating a configuration for a WebSocketServer.

### Returns
- **ServerConfigBuilder<WantsBindAddress>** - A builder instance to continue the configuration.
```

--------------------------------

### app_install_dir

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/steamworks/struct.Apps.html

Gets the installation directory for an app.

```APIDOC
## pub fn app_install_dir(&self, app_id: AppId) -> String

### Description
Returns the installation folder path for the app with the given ID. This returns the default location even if the app is not currently installed.
```

--------------------------------

### Configure and initialize a client

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/client/struct.ClientConfig.html

Demonstrates how to instantiate a ClientConfig with a custom context and initialize a client instance.

```rust
let cfg = ClientConfig::with_context(MyContext {})
    .num_disconnect_packets(10)
    .packet_send_rate(0.1)
    .on_state_change(|from, to, _ctx| {
    if let (ClientState::SendingChallengeResponse, ClientState::Connected) = (from, to) {
       println!("client connected to server");
    }
});
let mut client = Client::with_config(&token_bytes, cfg).unwrap();
client.connect();
```

--------------------------------

### Handle Start event with an observer

Source: https://docs.rs/lightyear/0.26.4/lightyear/input/bei/prelude/struct.Start.html

Example of registering an observer to handle the Start event for a Throw action, triggered on the first frame of a button press.

```rust
app.add_observer(throw);

app.world_mut().spawn((
    Player,
    actions!(Player[Action::<Throw>::new(), bindings![KeyCode::KeyF]]),
));

/// Triggered only once on the first press, similar to `just_pressed` in `bevy_input`.
///
/// It will not trigger again until the key is released and pressed again.
fn throw(throw: On<Start<Throw>>, players: Query<(&Transform, &mut Health)>) {
    // ...
}
```

--------------------------------

### Server::new

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/struct.Server.html?search=

Creates a new server instance with default configuration.

```APIDOC
## pub fn new(protocol_id: u64, private_key: [u8; 32]) -> Result<Server, Error>

### Description
Creates a new server with a default configuration.

### Parameters
- **protocol_id** (u64) - Required - The protocol ID for the server.
- **private_key** ([u8; 32]) - Required - The private key used for encryption.
```

--------------------------------

### Check Extensions state

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/tokio_tungstenite/tungstenite/http/struct.Extensions.html

Examples for checking if the map is empty or getting its length.

```rust
let mut ext = Extensions::new();
assert!(ext.is_empty());
ext.insert(5i32);
assert!(!ext.is_empty());
```

```rust
let mut ext = Extensions::new();
assert_eq!(ext.len(), 0);
ext.insert(5i32);
assert_eq!(ext.len(), 1);
```

--------------------------------

### Client::new

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/client/struct.Client.html?search=

Creates a new client instance with default configuration.

```APIDOC
### pub fn new(token_bytes: &[u8]) -> Result<Client, Error>

Creates a new client with a default configuration using the provided connection token bytes.
```

--------------------------------

### Trim Start Matches

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/steamworks/struct.LobbyKey.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of removing prefixes that match a pattern repeatedly.

```rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### try_get_i64_le

Source: https://docs.rs/lightyear/0.26.4/lightyear/websocket/prelude/tokio_tungstenite/tungstenite/struct.Bytes.html?search=std%3A%3Avec

Gets a signed 64 bit integer from the buffer in little-endian byte order.

```APIDOC
## fn try_get_i64_le(&mut self) -> Result<i64, TryGetError>

### Description
Gets a signed 64 bit integer from `self` in little-endian byte order.
```

--------------------------------

### Get or insert values

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/tokio_tungstenite/tungstenite/http/struct.Extensions.html

Examples of retrieving a value or inserting a default/provided one if missing.

```rust
let mut ext = Extensions::new();
*ext.get_or_insert(1i32) += 2;

assert_eq!(*ext.get::<i32>().unwrap(), 3);
```

```rust
let mut ext = Extensions::new();
*ext.get_or_insert_with(|| 1i32) += 2;

assert_eq!(*ext.get::<i32>().unwrap(), 3);
```

```rust
let mut ext = Extensions::new();
*ext.get_or_insert_default::<i32>() += 2;

assert_eq!(*ext.get::<i32>().unwrap(), 2);
```

--------------------------------

### Initialize Server with Custom Configuration

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/struct.Server.html

Create a server instance using a custom ServerConfig, allowing for context-specific callbacks.

```rust

let private_key = generate_key();
let protocol_id = 0x123456789ABCDEF0;
let cfg = ServerConfig::with_context(42).on_connect(|idx, _, _user_data, ctx| {
    assert_eq!(ctx, &42);
});
let server = Server::with_config(protocol_id, private_key, cfg).unwrap();
```

--------------------------------

### Get current stream position

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/trait.Seek.html

Retrieves the current offset from the start of the stream using stream_position.

```rust
use std::{
    io::{self, BufRead, BufReader, Seek},
    fs::File,
};

fn main() -> io::Result<()> {
    let mut f = BufReader::new(File::open("foo.txt")?);

    let before = f.stream_position()?;
    f.read_line(&mut String::new())?;
    let after = f.stream_position()?;

    println!("The first line was {} bytes long", after - before);
    Ok(())
}
```

--------------------------------

### Create a Client with a Connection Token

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/client/struct.Client.html

Demonstrates generating a connection token and initializing the client with it.

```rust
// Generate a connection token for the client
let private_key = generate_key();
let token_bytes = ConnectToken::build("127.0.0.1:0", 0, 0, private_key)
    .generate()
    .unwrap()
    .try_into_bytes()
    .unwrap();

let mut client = Client::new(&token_bytes).unwrap();
```

--------------------------------

### Trim start examples

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/tokio_tungstenite/tungstenite/protocol/frame/struct.Utf8Bytes.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates trimming leading whitespace from strings, including handling of right-to-left languages.

```rust
let s = "  עברית  ";
assert!(Some('ע') == s.trim_start().chars().next());
```

--------------------------------

### Initializing PreSpawned

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/struct.PreSpawned.html

Examples of creating a PreSpawned instance using default settings, salt, or a custom hash.

```rust
// Default hashing implementation: (tick + components)
PreSpawned::default();

// Default hashing implementation with additional user-provided salt:
let client_id: u64 = 12345;
PreSpawned::default_with_salt(client_id);

// User-provided custom hash
let custom_hash: u64 = 1;
PreSpawned::new(1);
```

--------------------------------

### try_get_u8

Source: https://docs.rs/lightyear/0.26.4/lightyear/websocket/prelude/tokio_tungstenite/tungstenite/struct.Bytes.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets an unsigned 8 bit integer from self.

```APIDOC
## fn try_get_u8(&mut self) -> Result<u8, TryGetError>

### Description
Gets an unsigned 8 bit integer from self. Returns a Result containing the value or a TryGetError.
```

--------------------------------

### Create a Client with Custom Configuration

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/client/struct.Client.html

Initializes a client with a custom configuration and state change callbacks.

```rust
struct MyContext {}
let cfg = ClientConfig::with_context(MyContext {}).on_state_change(|from, to, _ctx| {
   assert_eq!(from, ClientState::Disconnected);
   assert_eq!(to, ClientState::SendingConnectionRequest);
});

let mut client = NetcodeClient::with_config(&token_bytes, cfg).unwrap();
```

--------------------------------

### Initialize ServerConfig builder

Source: https://docs.rs/lightyear/0.26.4/lightyear/websocket/prelude/server/struct.ServerConfig.html?search=

Starts the configuration process for a WebSocket server.

```rust
pub const fn builder() -> ServerConfigBuilder<WantsBindAddress>
```

--------------------------------

### Trim Start Matches Example

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/tokio_tungstenite/tungstenite/protocol/frame/struct.Utf8Bytes.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates removing leading characters from a string slice using a slice of characters.

```rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### Seek with File

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/trait.Seek.html

Example demonstrating how to use the seek method on a File object to move the cursor 42 bytes from the start.

```rust
use std::io;
use std::io::prelude::*;
use std::fs::File;
use std::io::SeekFrom;

fn main() -> io::Result<()> {
    let mut f = File::open("foo.txt")?;

    // move the cursor 42 bytes from the start of the file
    f.seek(SeekFrom::Start(42))?;
    Ok(())
}
```

--------------------------------

### Server::new

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/struct.Server.html

Creates a new netcode server instance with default configuration.

```APIDOC
## pub fn new(protocol_id: u64, private_key: [u8; 32]) -> Result<Server, Error>

### Description
Creates a new server with a default configuration.

### Parameters
- **protocol_id** (u64) - The protocol ID for the server.
- **private_key** ([u8; 32]) - The private key used for encryption.
```

--------------------------------

### Starting struct definition

Source: https://docs.rs/lightyear/0.26.4/lightyear/connection/prelude/server/struct.Starting.html

The definition of the Starting struct.

```rust
pub struct Starting;
```

--------------------------------

### Define Started struct

Source: https://docs.rs/lightyear/0.26.4/lightyear/connection/prelude/server/struct.Started.html

The definition of the Started struct as a unit struct.

```rust
pub struct Started;
```

--------------------------------

### Initialize and Connect a Client

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/client/struct.Client.html

Basic usage for creating a new client instance and initiating a connection.

```rust
let mut client = Client::new(&token_bytes).unwrap();
client.connect();
```

--------------------------------

### Initialize ClientConfig builder

Source: https://docs.rs/lightyear/0.26.4/lightyear/websocket/prelude/client/struct.ClientConfig.html

Starts the configuration process for a new ClientConfig instance.

```rust
pub const fn builder() -> ClientConfigBuilder<WantsConnector>
```

--------------------------------

### Installing the Stack

Source: https://docs.rs/lightyear/0.26.4/lightyear/metrics/metrics_util/layers/struct.Stack.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Method to install the configured stack as the global recorder.

```rust
pub fn install(self) -> Result<(), SetRecorderError<Stack<R>>>
```

--------------------------------

### Creating a ServerName

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/rustls/pki_types/enum.ServerName.html?search=std%3A%3Avec

How to instantiate a ServerName from a string or string reference using TryFrom or TryInto.

```APIDOC
## Creating a ServerName

### Description
Users can create a ServerName instance from a DNS name string using the `TryFrom` or `TryInto` traits.

### Usage
```rust
// From &str
let name = ServerName::try_from("example.com").expect("invalid DNS name");

// From String
let name_str = "example.com".to_string();
let name = ServerName::try_from(name_str).expect("invalid DNS name");

// Using try_into
let x: ServerName = "example.com".try_into().expect("invalid DNS name");
```
```

--------------------------------

### send_p2p_packet

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/steamworks/struct.Networking.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sends a packet to the user, starting the connection if it isn't started already.

```APIDOC
### pub fn send_p2p_packet(&self, remote: SteamId, send_type: SendType, data: &[u8]) -> bool

Sends data to a remote Steam user.
```

--------------------------------

### Start Struct Definition

Source: https://docs.rs/lightyear/0.26.4/lightyear/connection/prelude/server/struct.Start.html

The definition of the Start struct, which contains an entity field.

```rust
pub struct Start {
    pub entity: Entity,
}
```

--------------------------------

### Install FIPS CryptoProvider

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/rustls/manual/_06_fips/index.html

Install the default FIPS provider as the process-wide default.

```rust
rustls::crypto::default_fips_provider()
    .install_default()
    .expect("default provider already set elsewhere");
```

--------------------------------

### Configure Server with Context

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/struct.ServerConfig.html

Demonstrates initializing a ServerConfig with a thread-safe context and defining a connection callback.

```rust
use std::sync::{Arc, Mutex};
use lightyear_netcode::{Server, ServerConfig};

let thread_safe_counter = Arc::new(Mutex::new(0));
let cfg = ServerConfig::with_context(thread_safe_counter).on_connect(|idx, _, _, ctx| {
    let mut counter = ctx.lock().unwrap();
    *counter += 1;
    println!("client {} connected, counter: {idx}", counter);
});
let server = Server::with_config(protocol_id, private_key, cfg).unwrap();
```

--------------------------------

### get()

Source: https://docs.rs/lightyear/0.26.4/lightyear/steam/prelude/steamworks/stats/struct.AchievementHelper.html?search=

Gets the current unlock status of the achievement from the local in-memory state.

```APIDOC
## pub fn get(&self) -> Result<bool, ()>

### Description
Gets the unlock status of the Achievement. This call only modifies Steam’s in-memory state so it is quite cheap. To send the unlock status to the server and to trigger the Steam overlay notification you must call `store_stats()`.

### Returns
- **Result<bool, ()>** - Returns true if the achievement is unlocked, false otherwise. Fails if the achievement’s API name is unknown or if `UserStatsReceived` was unsuccessful.
```

--------------------------------

### get()

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/steamworks/stats/struct.AchievementHelper.html

Gets the unlock status of the achievement from Steam's in-memory state.

```APIDOC
## pub fn get(&self) -> Result<bool, ()>

### Description
Gets the unlock status of the Achievement. This call only modifies Steam’s in-memory state so it is quite cheap. To send the unlock status to the server and to trigger the Steam overlay notification you must call `store_stats()`.

### Returns
- **Result<bool, ()>** - Returns true if achieved, false otherwise. Fails if the achievement’s API Name is unknown or if UserStatsReceived was unsuccessful.
```

--------------------------------

### Client::new

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/client/struct.Client.html

Creates a new client instance with default configuration using the provided connection token.

```APIDOC
## Client::new(token_bytes: &[u8])

### Description
Creates a new client with a default configuration.

### Parameters
- **token_bytes** (&[u8]) - Required - The connection token bytes obtained from a web backend.
```

--------------------------------

### Split Off Last Element Examples

Source: https://docs.rs/lightyear/0.26.4/lightyear/input/bei/prelude/struct.Actions.html?search=

Examples for removing and returning the last element of a slice.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.split_off_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let last = slice.split_off_last_mut().unwrap();
*last = 'd';
```

--------------------------------

### Client::connect

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/client/struct.Client.html

Prepares the client to connect to the server.

```APIDOC
## Client::connect()

### Description
Prepares the client to connect to the server. This function does not perform any IO, it only readies the client to send/receive packets on the next call to update.
```

--------------------------------

### Open a WebSocket Server

Source: https://docs.rs/lightyear/0.26.4/lightyear/websocket/server/struct.WebSocketServer.html

Demonstrates how to initialize and spawn a WebSocketServer using a ServerConfig with a self-signed identity.

```rust
use {
    aeronet_websocket::server::{Identity, ServerConfig, WebSocketServer},
    bevy_ecs::prelude::*,
};

// set up a self-signed certificate to identify this server
let identity = Identity::self_signed(["localhost", "127.0.0.1", "::1"]).unwrap();

let config = ServerConfig::builder()
    .with_bind_default(12345) // server port
    .with_identity(identity);

// using `Commands`
commands.spawn_empty().queue(WebSocketServer::open(config));

// using mutable `World` access
let server = world.spawn_empty().id();
WebSocketServer::open(config).apply(world.entity_mut(server));
```

--------------------------------

### Split Off First Element Examples

Source: https://docs.rs/lightyear/0.26.4/lightyear/input/bei/prelude/struct.Actions.html?search=

Examples for removing and returning the first element of a slice.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let first = slice.split_off_first_mut().unwrap();
*first = 'd';

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'d');
```

--------------------------------

### Configure ClientConfig with root certificates

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/rustls/struct.ConfigBuilder.html

Example of setting up a client configuration with root certificates and disabling client authentication.

```rust
ClientConfig::builder()
    .with_root_certificates(root_certs)
    .with_no_client_auth();
```

--------------------------------

### Configure ServerConfig with certificate

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/rustls/struct.ConfigBuilder.html

Example of setting up a server configuration without client authentication and providing a single certificate.

```rust
ServerConfig::builder()
    .with_no_client_auth()
    .with_single_cert(certs, private_key)
    .expect("bad certificate/key");
```

--------------------------------

### Split Off Slice Examples

Source: https://docs.rs/lightyear/0.26.4/lightyear/input/bei/prelude/struct.Actions.html?search=

Examples for splitting a slice by a one-sided range, returning the removed subslice.

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut first_three = slice.split_off(..3).unwrap();

assert_eq!(slice, &['d']);
assert_eq!(first_three, &['a', 'b', 'c']);
```

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.split_off(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);
```

```rust
let mut slice: &[_] = &['a', 'b', 'c', 'd'];

assert_eq!(None, slice.split_off(5..));
assert_eq!(None, slice.split_off(..5));
assert_eq!(None, slice.split_off(..=4));
let expected: &[char] = &['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.split_off(..4));
```

--------------------------------

### HandshakeMachine::start_write

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/tokio_tungstenite/tungstenite/handshake/machine/struct.HandshakeMachine.html

Initializes a new HandshakeMachine instance configured to start writing data to the provided stream.

```APIDOC
### pub fn start_write<Stream, D>(stream: Stream, data: D) -> HandshakeMachine<Stream> where D: Into<Vec<u8>>

Starts writing the provided data to the peer.
```

--------------------------------

### Split Off Mutable Slice Examples

Source: https://docs.rs/lightyear/0.26.4/lightyear/input/bei/prelude/struct.Actions.html?search=

Examples for splitting a mutable slice by a one-sided range, returning a mutable subslice.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut first_three = slice.split_off_mut(..3).unwrap();

assert_eq!(slice, &mut ['d']);
assert_eq!(first_three, &mut ['a', 'b', 'c']);
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);
```

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];

assert_eq!(None, slice.split_off_mut(5..));
assert_eq!(None, slice.split_off_mut(..5));
assert_eq!(None, slice.split_off_mut(..=4));
let expected: &mut [_] = &mut ['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.split_off_mut(..4));
```

--------------------------------

### Load root certificates

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/rustls/index.html

Initialize a RootCertStore using the Mozilla root certificates provided by the webpki_roots crate.

```rust
let root_store = rustls::RootCertStore::from_iter(
    webpki_roots::TLS_SERVER_ROOTS
        .iter()
        .cloned(),
);
```

--------------------------------

### Start Struct Auto Trait Implementations

Source: https://docs.rs/lightyear/0.26.4/lightyear/input/bei/prelude/struct.Start.html?search=

Auto trait implementations for the Start struct, conditional on the InputAction output type.

```rust
impl<A> Freeze for Start<A>
where <A as InputAction>::Output: Freeze,
```

```rust
impl<A> RefUnwindSafe for Start<A>
where <A as InputAction>::Output: RefUnwindSafe,
```

```rust
impl<A> Send for Start<A>
```

```rust
impl<A> Sync for Start<A>
```

```rust
impl<A> Unpin for Start<A>
where <A as InputAction>::Output: Unpin,
```

```rust
impl<A> UnwindSafe for Start<A>
where <A as InputAction>::Output: UnwindSafe,
```

--------------------------------

### Response Creation

Source: https://docs.rs/lightyear/0.26.4/lightyear/websocket/prelude/tokio_tungstenite/tungstenite/handshake/server/type.ErrorResponse.html?search=

Examples for creating new Response instances.

```rust
let response = Response::new("hello world");

assert_eq!(response.status(), StatusCode::OK);
assert_eq!(*response.body(), "hello world");
```

```rust
let response = Response::new("hello world");
let (mut parts, body) = response.into_parts();

parts.status = StatusCode::BAD_REQUEST;
let response = Response::from_parts(parts, body);

assert_eq!(response.status(), StatusCode::BAD_REQUEST);
assert_eq!(*response.body(), "hello world");
```

--------------------------------

### get()

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/steamworks/stats/struct.AchievementHelper.html?search=u32+-%3E+bool

Gets the unlock status of the Achievement. This modifies Steam's in-memory state and requires a successful UserStatsReceived callback.

```APIDOC
## pub fn get(&self) -> Result<bool, ()>

### Description
Gets the unlock status of the Achievement. This call only modifies Steam’s in-memory state so it is quite cheap. To send the unlock status to the server and to trigger the Steam overlay notification you must call `store_stats()`.

### Returns
- **Result<bool, ()>** - Returns true if the achievement is unlocked, false otherwise. Fails if the achievement’s API Name is unknown or if the UserStatsReceived callback was unsuccessful.
```

--------------------------------

### Client::with_config

Source: https://docs.rs/lightyear/0.26.4/lightyear/netcode/client/struct.Client.html?search=

Creates a new client instance with a custom configuration and optional context.

```APIDOC
### pub fn with_config(token_bytes: &[u8], cfg: ClientConfig<Ctx>) -> Result<Client<Ctx>, Error>

Creates a new client with a custom configuration. Callbacks with context can be registered to be notified when the client changes states.
```

--------------------------------

### ClientConfig Builder and Configuration Methods

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/client/struct.ClientConfig.html?search=

Methods for initializing and configuring the ClientConfig instance.

```rust
pub const fn builder() -> ClientConfigBuilder<WantsConnector>
```

```rust
pub fn with_socket_config(self, socket: WebSocketConfig) -> ClientConfig
```

```rust
pub fn with_nagle(self, nagle: bool) -> ClientConfig
```

```rust
pub fn disable_nagle(self) -> ClientConfig
```

--------------------------------

### get()

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/steamworks/stats/struct.AchievementHelper.html?search=std%3A%3Avec

Gets the unlock status of the Achievement. This modifies Steam's in-memory state and requires a successful UserStatsReceived callback.

```APIDOC
### pub fn get(&self) -> Result<bool, ()>

Gets the unlock status of the Achievement. This call only modifies Steam’s in-memory state. Fails if the achievement’s API Name is unknown or if the UserStatsReceived callback was unsuccessful.
```

--------------------------------

### get()

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/steamworks/stats/struct.AchievementHelper.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the unlock status of the Achievement. This modifies Steam's in-memory state and requires store_stats() to persist changes.

```APIDOC
### pub fn get(&self) -> Result<bool, ()>

Gets the unlock status of the Achievement. Fails if the achievement's API name is unknown or if UserStatsReceived was unsuccessful.
```

--------------------------------

### Using Acceptor for dynamic ServerConfig selection

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/rustls/server/struct.Acceptor.html

Demonstrates how to use Acceptor to read a ClientHello and choose a ServerConfig before establishing the final connection.

```rust
use rustls::server::{Acceptor, ServerConfig};
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
for stream in listener.incoming() {
    let mut stream = stream.unwrap();
    let mut acceptor = Acceptor::default();
    let accepted = loop {
        acceptor.read_tls(&mut stream).unwrap();
        if let Some(accepted) = acceptor.accept().unwrap() {
            break accepted;
        }
    };

    // For some user-defined choose_server_config:
    let config = choose_server_config(accepted.client_hello());
    let conn = accepted
        .into_connection(config)
        .unwrap();

    // Proceed with handling the ServerConnection.
}
```

--------------------------------

### InputPlugin::new

Source: https://docs.rs/lightyear/0.26.4/lightyear/input/bei/prelude/struct.InputPlugin.html

Creates a new instance of the InputPlugin with the provided configuration.

```APIDOC
## pub fn new(config: InputConfig<C>) -> InputPlugin<C>

### Description
Creates a new instance of the InputPlugin using the specified InputConfig.

### Parameters
- **config** (InputConfig<C>) - Required - The configuration object for the input plugin.
```

--------------------------------

### PEM Certificate Format Example

Source: https://docs.rs/lightyear/0.26.4/lightyear/prelude/rustls_native_certs/fn.load_native_certs.html

Example of the expected PEM format for certificates, which may contain multiple certificates in a single file.

```text
-----BEGIN CERTIFICATE-----
MIICGzCCAaGgAwIBAgIQQdKd0XLq7qeAwSxs6S+HUjAKBggqhkjOPQQDAzBPMQsw
CQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJuZXQgU2VjdXJpdHkgUmVzZWFyY2gg
R3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBYMjAeFw0yMDA5MDQwMDAwMDBaFw00
MDA5MTcxNjAwMDBaME8xCzAJBgNVBAYTAlVTMSkwJwYDVQQKEyBJbnRlcm5ldCBT
ZWN1cml0eSBSZXNlYXJjaCBHcm91cDEVMBMGA1UEAxMMSVNSRyBSb290IFgyMHYw
EAYHKoZIzj0CAQYFK4EEACIDYgAEzZvVn4CDCuwJSvMWSj5cz3es3mcFDR0HttwW
+1qLFNvicWDEukWVEYmO6gbf9yoWHKS5xcUy4APgHoIYOIvXRdgKam7mAHf7AlF9
ItgKbppbd9/w+kHsOdx1ymgHDB/qo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDRV0T
AQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEKWrt5LSDv6kviejM9ti6lyN5UwCgYIKoZI
zj0EAwMDaAAwZQIwe3lORlCEwkSHRhtFcP9Ymd70/aTSVaYgLXTWNLxBo1BfASdW
tL4ndQavEi51mI38AjEAi/V3bNTIZargCyzuFJ0nN6T5U6VR5CmD1/iQMVtCnwr1
/q4AaOeMSQ+2b1tbFfLn
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
MIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5
MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g
Um9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG
A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg
Q0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl
ui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j
QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr
ttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr
BqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM
YyRIHN8wfdVoOw==
-----END CERTIFICATE-----
```
Tokens:
Raw