Struct LvdFile

pub struct LvdFile {

    pub collisions: Section<Collision>,
    pub spawns: Section<Spawn>,
    pub respawns: Section<Spawn>,
    pub camera_boundary: Section<Bounds>,
    pub blast_zone: Section<Bounds>,
    pub enemy_generators: UnsupportedSection,
    pub unk1: UnsupportedSection,
    pub unk2: UnsupportedSection,
    pub unk3: UnsupportedSection,
    pub fs_area_cam: UnsupportedSection,
    pub fs_cam_limit: UnsupportedSection,
    pub damage_shapes: Section<DamageShape>,
    pub item_spawners: Section<ItemSpawner>,
    pub ptrainer_ranges: Section<PokemonTrainerRange>,
    pub ptrainer_platforms: Section<PokemonTrainerPlatform>,
    pub general_shapes: Section<GeneralShape>,
    pub general_points: Section<Point>,
    pub unk4: UnsupportedSection,
    pub unk5: UnsupportedSection,
    pub unk6: UnsupportedSection,
    pub unk7: UnsupportedSection,
    pub shrunken_camera_boundary: Section<Bounds>,
    pub shrunken_blast_zone: Section<Bounds>,
}

The top-level structure representing the LVD file containing all the sections included within it.

let file = lvd::open("./pickel_world_00.lvd").unwrap();

println!("{:?}", &file.collisions[0].vertices[0]);

file.save("./pickel_world_00_edited.lvd").unwrap();

Fields

collisions: Section<Collision>

Collisions for the various platforms of the stage.

These can have arbitrary 2d shapes with ledges, various types of collisions, different properties, etc. See Collision for more info.

spawns: Section<Spawn>

The initial spawnpoints of characters when starting the match

respawns: Section<Spawn>

The points in space where respawn platforms arrive

camera_boundary: Section<Bounds>

The furthest edges of the stage that the camera can pan to

blast_zone: Section<Bounds>

The bounds of how far fighters can go before they die from the blast zones

enemy_generators: UnsupportedSection

Locations where enemies can be spawned

unk1: UnsupportedSection

unk2: UnsupportedSection

unk3: UnsupportedSection

fs_area_cam: UnsupportedSection

Points where the final smash area camera is placed

fs_cam_limit: UnsupportedSection

Limit to panning of the final smash camera

damage_shapes: Section<DamageShape>

Places in the stage with hurtboxes attackable by players

item_spawners: Section<ItemSpawner>

Areas of the stage in which items can spawn

ptrainer_ranges: Section<PokemonTrainerRange>

Areas within the stage that pokemon trainers can move around on

ptrainer_platforms: Section<PokemonTrainerPlatform>

Platforms where pokemon trainers hover

general_shapes: Section<GeneralShape>

Generic shapes describing features of the stage

general_points: Section<Point>

Generic points describing locations on the stage (used for final smash locations like Ike’s, for example)

unk4: UnsupportedSection

unk5: UnsupportedSection

unk6: UnsupportedSection

unk7: UnsupportedSection

shrunken_camera_boundary: Section<Bounds>

Camera boundary but after it has shrunken for sudden death

shrunken_blast_zone: Section<Bounds>

Blast zone boundary but after it has shrunken for sudden death

Implementations

impl LvdFile

pub fn save<P: AsRef<Path>>(&self, path: P) -> Result<(), Error>

pub fn write<W: Write + Seek>(&self, writer: &mut W) -> Result<(), Error>

impl LvdFile

pub fn open<P: AsRef<Path>>(path: P) -> BinResult<Self>

Read and parse an LVD from a file at a given path

use lvd::LvdFile;

let file = LvdFile::open("path/to/file.lvd").unwrap();

Trait Implementations

impl BinRead for LvdFile

type Args = ()

The type used for the args parameter of read_args() and read_options().

fn read_options<R: Read + Seek>( __binrw_generated_var_reader: &mut R, __binrw_generated_var_options: &ReadOptions, __binrw_generated_var_arguments: Self::Args, ) -> BinResult<Self>

Read Self from the reader using the given ReadOptions and arguments.

fn read<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek, Self::Args: Default,

Read Self from the reader using default arguments.

fn read_args<R>(reader: &mut R, args: Self::Args) -> Result<Self, Error>

where R: Read + Seek,

Read Self from the reader using the given arguments.

fn after_parse<R>( &mut self, _: &mut R, _: &ReadOptions, _: Self::Args, ) -> Result<(), Error>

where R: Read + Seek,

Runs any post-processing steps required to finalize construction of the object.

impl Debug for LvdFile

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

Formats the value using the given formatter.

impl HasMagic for LvdFile

const MAGIC: Self::MagicType

type MagicType = [u8; 10]