Struct Replay

pub struct Replay {
    start_time: SystemTime,
    standard_grid: StandardGrid,
    pub label: String,
    frames: Vec<ReplayFrame>,
    current_frame: usize,
    pacman_state_frame: usize,
    location_frame: usize,
}

A collection of frames representing a full replay, along with associated metadata

Fields

start_time: SystemTime

The time when recording started

standard_grid: StandardGrid

The StandardGrid the recording uses

label: String

The name/label given to this replay (usually matches the file name)

frames: Vec<ReplayFrame>

The data of the replay

current_frame: usize

Index of the most recently recorded or played frame

pacman_state_frame: usize

Index of the most recently recorded or played pacman state frame

location_frame: usize

Index of the most recently recorded or played pacman location frame

Implementations

impl Replay

pub fn new( label: String, standard_grid: StandardGrid, _pacman_state: GameState, pacbot_location: Isometry2<f32>, ) -> Self

Start a new Replay

Note: pacman_state is copied once

Examples

use pacbot_rs::game_engine::GameEngine;
use rapier2d::math::Isometry;
use rapier2d::na::Vector2;
use mdrc_pacbot_util::replay::Replay;
use mdrc_pacbot_util::grid::standard_grids::StandardGrid;

let mut replay = Replay::new(
    "My First Replay".to_string(),
    StandardGrid::Pacman,
    GameEngine::default(),
    StandardGrid::Pacman.get_default_pacbot_isometry()
);

assert_eq!(replay.frame_count(), 2);
assert_eq!(replay.current_frame(), 1);

pub fn starting_at(other: &Replay) -> Self

Create a new Replay starting at the current frame in the given Replay

All frames are updated so that the most recent one matches the current time

May return Err if the given replay frame is in the future

Examples

use pacbot_rs::game_engine::GameEngine;
use rand::rngs::ThreadRng;
use rapier2d::math::Isometry;
use rapier2d::na::Vector2;
use mdrc_pacbot_util::replay::Replay;
use mdrc_pacbot_util::grid::standard_grids::StandardGrid;

let mut pacman_state = GameEngine::default();
let mut rng = ThreadRng::default();

let mut replay = Replay::new(
    "My First Replay".to_string(),
    StandardGrid::Pacman,
    pacman_state.to_owned(),
    StandardGrid::Pacman.get_default_pacbot_isometry()
);

assert_eq!(replay.frame_count(), 2);
assert_eq!(replay.current_frame(), 1);

for i in 0..3 {
    pacman_state.step();
    replay.record_pacman_state(pacman_state.to_owned()).unwrap();
}

replay.step_back();
replay.step_back();

assert!(!replay.is_at_end());
assert_eq!(replay.frame_count(), 5);
assert_eq!(replay.current_frame(), 2);

let replay = Replay::starting_at(&replay);

assert!(replay.is_at_end());
assert_eq!(replay.frame_count(), 3);
assert_eq!(replay.current_frame(), 2);

pub fn from_bytes(bytes: &[u8]) -> Result<(Replay, usize), DecodeError>

Create a new Replay using bytes from a file

Examples

use mdrc_pacbot_util::replay::Replay;

let replay = Replay::default();
let replay_bytes = replay.to_bytes().expect("Failed to serialize replay!");
let replay2 = Replay::from_bytes(&replay_bytes).expect("Failed to deserialize replay!");

pub fn to_bytes(&self) -> Result<Vec<u8>, EncodeError>

Get the bytes associated with the Replay

Examples

use mdrc_pacbot_util::replay::Replay;

let replay = Replay::default();
let replay_bytes = replay.to_bytes().expect("Failed to serialize replay!");
let replay2 = Replay::from_bytes(&replay_bytes).expect("Failed to deserialize replay!");

pub fn is_at_end(&self) -> bool

Returns whether the replay has played its last frame

Examples

use pacbot_rs::game_engine::GameEngine;
use mdrc_pacbot_util::replay::Replay;

let mut replay = Replay::default();
assert!(replay.is_at_end());
replay.record_pacman_state(GameEngine::default()).unwrap();
assert!(replay.is_at_end());
replay.step_back();
assert!(!replay.is_at_end());
replay.step_forwards();
assert!(replay.is_at_end());

pub fn is_at_beginning(&self) -> bool

Returns whether the replay is at the beginning

Examples

use pacbot_rs::game_engine::GameEngine;
use mdrc_pacbot_util::replay::Replay;

let mut replay = Replay::default();
assert!(replay.is_at_beginning());
replay.record_pacman_state(GameEngine::default()).unwrap();
assert!(!replay.is_at_beginning());
replay.step_back();
assert!(replay.is_at_beginning());
replay.step_forwards();
assert!(!replay.is_at_beginning());

pub fn get_pacbot_location(&self) -> Isometry2<f32>

Returns the most recent PacbotLocation

Examples

use rapier2d::na::{Isometry2, Vector2};
use mdrc_pacbot_util::replay::Replay;

let mut replay = Replay::default();

let isometry_1 = Isometry2::new(Vector2::new(1.0, 1.0), 1.0);
replay.record_pacman_location(isometry_1.to_owned()).unwrap();
let isometry_2 = Isometry2::new(Vector2::new(2.0, 2.0), 2.0);
replay.record_pacman_location(isometry_2.to_owned()).unwrap();

assert_eq!(isometry_2, replay.get_pacbot_location());
replay.step_back();
assert_eq!(isometry_1, replay.get_pacbot_location());

fn update_current_frames(&mut self)

pub fn step_forwards(&mut self)

Moves to the next frame, if it exists

pub fn step_back(&mut self)

Moves to the previous frame, if it exists

pub fn go_to_beginning(&mut self)

Go back to the beginning of the recording

pub fn go_to_end(&mut self)

Go to the end of the recording

pub fn step_forwards_until_pacman_state(&mut self)

Step forwards until a PacmanState frame is reached

Examples

use pacbot_rs::game_engine::GameEngine;
use rapier2d::na::{Isometry2, Vector2};
use mdrc_pacbot_util::replay::Replay;

let mut replay = Replay::default();

replay.record_pacman_state(GameEngine::default()).unwrap();
replay.record_pacman_location(Isometry2::new(Vector2::new(1.0, 1.0), 1.0)).unwrap();
replay.record_pacman_location(Isometry2::new(Vector2::new(2.0, 2.0), 2.0)).unwrap();
replay.record_pacman_location(Isometry2::new(Vector2::new(3.0, 3.0), 3.0)).unwrap();
replay.record_pacman_state(GameEngine::default()).unwrap();
replay.record_pacman_location(Isometry2::new(Vector2::new(4.0, 4.0), 4.0)).unwrap();
replay.record_pacman_location(Isometry2::new(Vector2::new(5.0, 5.0), 5.0)).unwrap();
replay.record_pacman_location(Isometry2::new(Vector2::new(6.0, 6.0), 6.0)).unwrap();
replay.record_pacman_state(GameEngine::default()).unwrap();

assert_eq!(replay.get_pacbot_location(), Isometry2::new(Vector2::new(6.0, 6.0), 6.0));
replay.step_backwards_until_pacman_state();
assert_eq!(replay.get_pacbot_location(), Isometry2::new(Vector2::new(4.0, 4.0), 4.0));
replay.step_backwards_until_pacman_state();
assert_eq!(replay.get_pacbot_location(), Isometry2::new(Vector2::new(1.0, 1.0), 1.0));
replay.step_forwards_until_pacman_state();
assert_eq!(replay.get_pacbot_location(), Isometry2::new(Vector2::new(3.0, 3.0), 3.0));
replay.step_forwards_until_pacman_state();
assert_eq!(replay.get_pacbot_location(), Isometry2::new(Vector2::new(6.0, 6.0), 6.0));

pub fn step_backwards_until_pacman_state(&mut self)

Step backwards until a PacmanState frame is reached

See Replay::step_forwards_until_pacman_state for example

pub fn record_pacman_location( &mut self, location: Isometry2<f32>, ) -> Result<(), Error>

Add a pacman location to the end of the replay

Returns err if the current frame is not the last frame

Examples

use pacbot_rs::game_engine::GameEngine;
use mdrc_pacbot_util::replay::Replay;

let mut replay = Replay::default();

assert!(replay.record_pacman_state(GameEngine::default()).is_ok());
replay.step_back();
// Don't add frames to a replay that isn't at the end
assert!(replay.record_pacman_state(GameEngine::default()).is_err());

pub fn current_frame(&self) -> usize

Get the index of the current frame

While this can be a good estimation of the progress through a replay, there is no guarantee that step_forwards() or step_back(), or any other methods, will hit any specific frame

pub fn frame_count(&self) -> usize

Get the number of frames

While this can be used to get a good estimation of the progress through a replay, there is no guarantee that step_forwards() or step_back(), or any other methods, will hit any specific frame

pub fn time_to_next(&self) -> Duration

Get the amount of time until the next frame

If at the end, returns Duration::MAX

pub fn time_to_previous(&self) -> Duration

Get the amount of time between the current and previous frame

If at the end, returns Duration::MAX

Trait Implementations

impl Clone for Replay

fn clone(&self) -> Replay

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Replay

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Replay

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Replay

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.