Struct Package

pub struct Package {
    pub meta: PackageMeta,
    pub rules: Rules,
    pub stages: KeyedContextVec<Stage>,
    pub fighters: KeyedContextVec<Fighter>,
    /* private fields */
}

Stores data that makes up a single game Is also responsible for loading and saving itself

Fields

meta: PackageMeta

rules: Rules

stages: KeyedContextVec<Stage>

fighters: KeyedContextVec<Fighter>

Implementations

impl Package

pub fn has_updates(&self) -> bool

pub fn blank(name: &str) -> Package

Creates a new blank package with the specified name. DANGER: If a package with the same name does exist, saving the returned package will overwrite the existing package.

pub fn open(name: &str) -> Option<Package>

Loads and returns the package with the specified name. Returns None if the package doesnt exist or is broken.

pub fn file_name(&self) -> String

pub fn open_or_generate(name: &str) -> Option<Package>

Opens a package if it exists Creates and opens it if it doesn’t However if it does exist but is broken in some way it returns None

pub fn publish(&mut self) -> String

Produces a zip of the package in the PF_Sandbox/publish directory The actual package has its published_version incremented and is then saved The exported package has its published flag set to true

pub fn save(&mut self) -> String

pub fn load(&mut self) -> Result<(), String>

Clears the current package data, then loads the package from disk The upgraded json is loaded into this package the user can then save the package to make the upgrade permanent Advantages over saving upgraded json immediately:

• the package cannot be saved if it wont load
• the user can choose to not save, if they find issues with the upgrade

pub fn compute_hash(&self) -> String

pub fn verify(&self) -> Verify

pub fn new_fighter_frame(&mut self, fighter: &str, action: usize, frame: usize)

pub fn insert_fighter_frame( &mut self, fighter: &str, action: usize, frame: usize, action_frame: ActionFrame, )

pub fn delete_fighter_frame( &mut self, fighter: &str, action: usize, frame: usize, ) -> bool

pub fn append_fighter_colbox( &mut self, fighter: &str, action: usize, frame: usize, new_colbox: CollisionBox, link_to: &HashSet<usize>, link_type: LinkType, ) -> usize

add the passed collisionbox to the specified fighter frame the added collisionbox is linked to the specified collisionboxes returns the index the collisionbox was added to.

pub fn delete_fighter_colboxes( &mut self, fighter: &str, action: usize, frame: usize, colboxes_to_delete: &HashSet<usize>, )

pub fn move_fighter_colboxes( &mut self, fighter: &str, action: usize, frame: usize, moved_colboxes: &HashSet<usize>, distance: (f32, f32), )

pub fn point_hitbox_angles_to( &mut self, fighter: &str, action: usize, frame: usize, set_hitboxes: &HashSet<usize>, x: f32, y: f32, )

pub fn resize_fighter_colboxes( &mut self, fighter: &str, action: usize, frame: usize, resized_colboxes: &HashSet<usize>, size_diff: f32, )

pub fn fighter_colboxes_send_to_back( &mut self, fighter: &str, action: usize, frame: usize, reordered_colboxes: &HashSet<usize>, )

All colboxes or links containing colboxes from reordered_colboxes are sent to the back

pub fn fighter_colboxes_send_to_front( &mut self, fighter: &str, action: usize, frame: usize, reordered_colboxes: &HashSet<usize>, )

All colboxes or links containing colboxes from reordered_colboxes are sent to the front

pub fn force_update_entire_package(&mut self)

pub fn updates(&mut self) -> Vec<PackageUpdate>

Trait Implementations

impl Clone for Package

fn clone(&self) -> Package

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Package

fn default() -> Package

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Package

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Node for Package

fn node_step(&mut self, runner: NodeRunner) -> String

impl Serialize for Package

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

where __S: Serializer,

Serialize this value into the given Serde serializer.