Struct SpectatorConfig 

pub struct SpectatorConfig {
    pub buffer_size: usize,
    pub catchup_speed: usize,
    pub max_frames_behind: usize,
    pub stream_delay: usize,
    pub enable_rewind: bool,
}

Configuration for spectator sessions.

These settings control spectator behavior including buffer sizes, catch-up speed, and frame lag tolerance.

Forward Compatibility

New fields may be added to this struct in future versions. To ensure your code continues to compile, always use the ..Default::default() or ..SpectatorConfig::default() pattern when constructing instances.

Example

use fortress_rollback::SpectatorConfig;

// For watching a fast-paced game, use larger buffer and faster catchup
let fast_game_config = SpectatorConfig {
    buffer_size: 90,
    catchup_speed: 2,
    max_frames_behind: 15,
    ..SpectatorConfig::default()
};

// For spectators on slower connections
let slow_connection_config = SpectatorConfig {
    buffer_size: 120,
    max_frames_behind: 20,
    ..SpectatorConfig::default()
};

// Hold playback a few frames behind the live edge to deter stream-sniping,
// and enable rewind so the spectator can seek backwards.
let broadcast_config = SpectatorConfig {
    stream_delay: 8,
    enable_rewind: true,
    ..SpectatorConfig::default()
};

Fields

buffer_size: usize

The number of frames of input that the spectator can buffer. This defines how many frames of inputs from the host the spectator can store before older inputs are overwritten.

A larger buffer allows the spectator to tolerate more latency or jitter, but uses more memory. Must be at least 1. Startup uses fallible allocation, so very large values return an error if the required buffers cannot be reserved.

Default: 60 (1 second at 60 FPS)

catchup_speed: usize

How many frames to advance per step when the spectator is behind. When the spectator falls more than max_frames_behind frames behind the currently viewable edge, it will advance this many frames per step to catch up.

Higher values catch up faster but may cause visual stuttering. A value of 0 is allowed for compatibility: when catch-up mode is triggered, the spectator advances no frames and advance_frame returns Ok(<empty>).

Default: 1

max_frames_behind: usize

The maximum number of frames the spectator can fall behind before triggering catch-up mode. When the spectator is more than this many frames behind the host’s current frame, it will use catchup_speed to advance faster.

Default: 10

stream_delay: usize

The number of frames to hold playback back from the live edge.

When non-zero, the spectator will not advance past last_received_frame - stream_delay. This deliberately delays the spectator’s view of the match, which is useful for broadcast scenarios to deter stream-sniping (a competitor watching the stream to react to hidden information). The held-back frames are still buffered and become viewable as the host sends newer inputs.

Default: 0 (follow the live edge)

Must be less than buffer_size. A delay greater than or equal to the buffer size would make every buffered frame unviewable.

enable_rewind: bool

Whether the spectator records game state every frame to support rewinding and seeking within the buffered window.

When true, the spectator emits a SaveGameState request before each advance and supports seek_to_frame, allowing the application to jump to any previously simulated frame still within the buffer. When false (the default), no state is saved and seek_to_frame returns a “not supported” error.

Default: false

Implementations

impl SpectatorConfig

pub fn new() -> Self

Creates a new SpectatorConfig with default values.

pub fn validate(&self) -> Result<(), FortressError>

Validates this spectator configuration.

Errors

Returns a FortressError if:

• buffer_size is 0.
• stream_delay is greater than or equal to buffer_size.

catchup_speed may be 0 to preserve the historical “no catch-up advance is attempted” behavior.

pub fn fast_paced() -> Self

Configuration preset for fast-paced games.

Uses a larger buffer and faster catch-up for games where falling behind is more noticeable.

pub fn slow_connection() -> Self

Configuration preset for spectators on slower connections.

Uses a larger buffer and more tolerance for falling behind.

pub fn local() -> Self

Configuration preset for local viewing with minimal latency.

Uses smaller buffer and stricter catch-up for responsive viewing.

pub fn broadcast() -> Self

Configuration preset for streaming/broadcast scenarios.

Optimized for live event streaming, tournament broadcasts, and replay viewers. Uses a very large buffer and conservative catch-up to avoid visual stuttering on stream.

Characteristics:

• Large buffer (3 seconds at 60 FPS)
• Slow, smooth catch-up to avoid jarring speed changes
• High tolerance for falling behind

pub fn mobile() -> Self

Configuration preset for mobile/cellular spectators.

Uses larger buffers and tolerant catch-up for variable mobile network conditions.

Trait Implementations

impl Clone for SpectatorConfig

fn clone(&self) -> SpectatorConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for SpectatorConfig

impl Debug for SpectatorConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SpectatorConfig

fn default() -> Self

Returns the “default value” for a type.

impl Display for SpectatorConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for SpectatorConfig

impl Hash for SpectatorConfig

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SpectatorConfig

fn eq(&self, other: &SpectatorConfig) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for SpectatorConfig