Struct Game 

pub struct Game {

    pub name: String,
    pub version: Option<Version>,
    pub room_format: Option<RoomFormat>,
    pub font: Font,
    pub custom_font: Option<String>,
    pub text_direction: TextDirection,
    pub palettes: Vec<Palette>,
    pub rooms: Vec<Room>,
    pub tiles: Vec<Tile>,
    pub sprites: Vec<Sprite>,
    pub items: Vec<Item>,
    pub dialogues: Vec<Dialogue>,
    pub endings: Vec<Ending>,
    pub variables: Vec<Variable>,
    pub font_data: Option<String>,
    /* private fields */
}

Fields

name: String

version: Option<Version>

room_format: Option<RoomFormat>

font: Font

custom_font: Option<String>

text_direction: TextDirection

palettes: Vec<Palette>

rooms: Vec<Room>

tiles: Vec<Tile>

sprites: Vec<Sprite>

items: Vec<Item>

dialogues: Vec<Dialogue>

endings: Vec<Ending>

variables: Vec<Variable>

font_data: Option<String>

Implementations

impl Game

pub fn from(string: String) -> Result<(Game, Vec<Error>), NotFound>

pub fn get_sprite_by_id(&self, id: String) -> Result<&Sprite, NotFound>

todo refactor this into “get T by ID”, taking a Vec and an ID name?

pub fn get_tile_by_id(&self, id: String) -> Result<&Tile, NotFound>

pub fn get_room_by_id(&self, id: String) -> Result<&Room, NotFound>

pub fn get_avatar(&self) -> Result<&Sprite, NotFound>

pub fn get_tiles_by_ids(&self, ids: Vec<String>) -> Vec<&Tile>

pub fn get_tiles_for_room(&self, id: String) -> Result<Vec<&Tile>, NotFound>

pub fn merge(&mut self, game: &Game)

impl Game

pub fn palette_ids(&self) -> Vec<String>

pub fn tile_ids(&self) -> Vec<String>

pub fn sprite_ids(&self) -> Vec<String>

pub fn room_ids(&self) -> Vec<String>

pub fn item_ids(&self) -> Vec<String>

pub fn dialogue_ids(&self) -> Vec<String>

pub fn ending_ids(&self) -> Vec<String>

pub fn variable_ids(&self) -> Vec<String>

pub fn new_palette_id(&self) -> String

pub fn new_tile_id(&self) -> String

first available tile ID. e.g. if current tile IDs are [0, 2, 3] the result will be 1 if current tile IDs are [0, 1, 2] the result will be 3

pub fn new_sprite_id(&self) -> String

pub fn new_room_id(&self) -> String

pub fn new_item_id(&self) -> String

pub fn new_dialogue_id(&self) -> String

pub fn new_ending_id(&self) -> String

pub fn new_variable_id(&self) -> String

pub fn get_palette(&self, id: &str) -> Option<&Palette>

pub fn get_tile_id(&self, matching_tile: &Tile) -> Option<String>

todo refactor?

pub fn find_tile_with_animation(&self, animation: &[Image]) -> Option<&Tile>

pub fn add_palette(&mut self, palette: Palette) -> String

adds a palette safely and returns the ID

pub fn add_tile(&mut self, tile: Tile) -> String

adds a tile safely and returns the ID

pub fn add_sprite(&mut self, sprite: Sprite) -> String

adds a sprite safely and returns the ID

pub fn add_item(&mut self, item: Item) -> String

adds an item safely and returns the ID

pub fn add_dialogue(&mut self, dialogue: Dialogue) -> String

adds a dialogue safely and returns the ID

pub fn add_ending(&mut self, ending: Ending) -> String

adds an ending safely and returns the ID

pub fn add_room(&mut self, room: Room) -> String

Safely adds a room and returns the room ID (a new ID will be generated if clashing) You will need to be mindful that the room’s palette, tile, exit and ending IDs will be valid after adding.

pub fn add_variable(&mut self, variable: Variable) -> String

pub fn dedupe_tiles(&mut self)

todo I think I need a generic dedupe(&mut self, Vec<T>) function it would have to take a closure for comparing a given T (see the background_tile below) and a closure for what to do with the changed IDs

pub fn version(&self) -> Version

older bitsy games do not specify a version, but we can infer 1.0

pub fn room_format(&self) -> RoomFormat

older bitsy games do not specify a room format, but we can infer 0

Trait Implementations

impl Clone for Game

fn clone(&self) -> Game

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Game

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

Formats the value using the given formatter.

impl PartialEq for Game

fn eq(&self, other: &Game) -> 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 ToString for Game

fn to_string(&self) -> String

Converts the given value to a String.

impl StructuralPartialEq for Game