Struct InputQueueConfig 

pub struct InputQueueConfig {
    pub queue_length: usize,
}

Configuration for input queue sizing.

These settings control the size of the input queue (circular buffer) that stores player inputs. A larger queue allows for longer input history and higher frame delays, but uses more memory.

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 ..InputQueueConfig::default() pattern when constructing instances.

Memory Usage

Each input queue stores queue_length inputs per player. With 2 players and 128-frame queue (default), this is 256 input slots total.

Constraints

• queue_length must be at least 2 (minimum for circular buffer operation)
• queue_length should be a power of 2 for optimal modulo performance (not enforced)
• frame_delay must be less than queue_length (enforced at session creation)

Example

use fortress_rollback::InputQueueConfig;

// Default configuration (128 frames = ~2.1 seconds at 60 FPS)
let default = InputQueueConfig::default();
assert_eq!(default.queue_length, 128);

// For games needing longer input history
let high_latency = InputQueueConfig::high_latency();
assert_eq!(high_latency.queue_length, 256);

// For memory-constrained environments
let minimal = InputQueueConfig::minimal();
assert_eq!(minimal.queue_length, 32);

Fields

queue_length: usize

The length of the input queue (circular buffer) per player.

This determines:

• How many frames of input history are stored
• The maximum allowed frame delay (queue_length - 1)
• Memory usage per player

At 60 FPS:

• 32 frames = ~0.5 seconds
• 64 frames = ~1.1 seconds
• 128 frames (default) = ~2.1 seconds
• 256 frames = ~4.3 seconds

Formal Specification Alignment

• TLA+: QUEUE_LENGTH in specs/tla/InputQueue.tla (uses 3 for model checking)
• Kani: INPUT_QUEUE_LENGTH in src/input_queue.rs (uses 8 for tractable verification)
• Z3: INPUT_QUEUE_LENGTH in tests/test_z3_verification.rs (uses 128)
• formal-spec.md: INV-4 (queue length bounds), INV-5 (index validity)
• spec-divergences.md: Documents why different values are used

Default: 128

Implementations

impl InputQueueConfig

pub fn new() -> Self

Creates a new InputQueueConfig with default values.

pub fn high_latency() -> Self

Configuration for high-latency networks.

Uses a larger queue (256 frames = ~4.3 seconds at 60 FPS) to allow for higher frame delays and longer rollback windows.

pub fn minimal() -> Self

Configuration for minimal memory usage.

Uses a smaller queue (32 frames = ~0.5 seconds at 60 FPS). Suitable for games with low latency requirements.

pub fn standard() -> Self

Configuration for standard networks.

Uses the default queue size (128 frames = ~2.1 seconds at 60 FPS).

pub fn max_frame_delay(&self) -> usize

Returns the maximum allowed frame delay for this configuration.

This is always queue_length - 1 to ensure the circular buffer doesn’t overflow when advancing the queue head.

pub fn validate_frame_delay( &self, frame_delay: usize, ) -> Result<(), FortressError>

Validates that the given frame delay is valid for this configuration.

Errors

Returns a FortressError if frame_delay >= queue_length.

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

Validates the configuration itself.

Errors

Returns a FortressError if queue_length < 2.

Trait Implementations

impl Clone for InputQueueConfig

fn clone(&self) -> InputQueueConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InputQueueConfig

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

Formats the value using the given formatter.

impl Default for InputQueueConfig

fn default() -> Self

Returns the “default value” for a type.

impl Display for InputQueueConfig

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

Formats the value using the given formatter.

impl Hash for InputQueueConfig

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 InputQueueConfig

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for InputQueueConfig

impl Eq for InputQueueConfig

impl StructuralPartialEq for InputQueueConfig