bitsy-parser/src/game.rs

use crate::{Avatar, Dialogue, Ending, Item, Palette, Room, Sprite, Tile, Variable, mock};

#[derive(Debug, PartialEq)]
pub struct Game {
    pub name: String,
    pub version: f64,
    pub room_format: u8, // this is "0 = non-comma separated, 1 = comma separated" apparently
    pub palettes: Vec<Palette>,
    pub rooms: Vec<Room>,
    pub tiles: Vec<Tile>,
    pub avatar: Avatar,
    pub sprites: Vec<Sprite>,
    pub items: Vec<Item>,
    pub dialogues: Vec<Dialogue>,
    pub endings: Vec<Ending>,
    pub variables: Vec<Variable>,
}

impl From<String> for Game {
    fn from(string: String) -> Game {
        // dialogues and endings can have 2+ line breaks inside, so deal with these separately
        // otherwise, everything can be split on a double line break (\n\n)
        let mut dialogues: Vec<Dialogue> = Vec::new();
        let mut endings: Vec<Ending> = Vec::new();
        let mut variables: Vec<Variable> = Vec::new();
        let main_split: Vec<&str> = string.split("\n\nDLG").collect();
        let main = main_split[0].to_string();
        let mut dialogues_endings_variables: String = main_split[1..].join("\n\nDLG");

        let variable_segments = dialogues_endings_variables.clone();
        let variable_segments: Vec<&str> = variable_segments.split("\n\nVAR").collect();
        if variable_segments.len() > 0 {
            dialogues_endings_variables = variable_segments[0].to_string();
            let variable_segments = variable_segments[1..].to_owned();

            for segment in variable_segments {
                let segment = format!("VAR{}", segment);
                variables.push(Variable::from(segment));
            }
        }

        let ending_segments = dialogues_endings_variables.clone();
        let ending_segments: Vec<&str> = ending_segments.split("\n\nEND").collect();
        if ending_segments.len() > 0 {
            dialogues_endings_variables = ending_segments[0].to_string();
            let ending_segments = ending_segments[1..].to_owned();

            for segment in ending_segments {
                let segment = format!("END{}", segment);
                endings.push(Ending::from(segment));
            }
        }

        let dialogue_segments = format!("\n\nDLG {}", dialogues_endings_variables.trim());
        let dialogue_segments: Vec<&str> = dialogue_segments.split("\n\nDLG").collect();
        for segment in dialogue_segments[1..].to_owned() {
            let segment = format!("DLG{}", segment);
            dialogues.push(Dialogue::from(segment));
        }

        let segments: Vec<&str> = main.split("\n\n").collect();

        let name = segments[0].to_string();
        let mut version: f64 = 1.0;
        let mut room_format: u8 = 1;
        let mut palettes: Vec<Palette> = Vec::new();
        let mut rooms: Vec<Room> = Vec::new();
        let mut tiles: Vec<Tile> = Vec::new();
        let mut avatar: Option<Avatar> = None; // unwrap this later
        let mut sprites: Vec<Sprite> = Vec::new();
        let mut items: Vec<Item> = Vec::new();

        for segment in segments[1..].to_owned() {
            let segment = segment.to_string();

            if segment.starts_with("# BITSY VERSION") {
                version = segment.replace("# BITSY VERSION ", "").parse().unwrap();
            } else if segment.starts_with("! ROOM_FORMAT") {
                room_format = segment.replace("! ROOM_FORMAT ", "").parse().unwrap();
            } else if segment.starts_with("PAL") {
                palettes.push(Palette::from(segment));
            } else if segment.starts_with("ROOM") {
                rooms.push(Room::from(segment));
            } else if segment.starts_with("TIL") {
                tiles.push(Tile::from(segment));
            } else if segment.starts_with("SPR A") {
                avatar = Some(Avatar::from(segment));
            } else if segment.starts_with("SPR") {
                sprites.push(Sprite::from(segment));
            } else if segment.starts_with("ITM") {
                items.push(Item::from(segment));
            }
        }

        assert!(avatar.is_some());
        let avatar = avatar.unwrap();

        Game {
            name,
            version,
            room_format,
            palettes,
            rooms,
            tiles,
            avatar,
            sprites,
            items,
            dialogues,
            endings,
            variables,
        }
    }
}

impl ToString for Game {
    #[inline]
    fn to_string(&self) -> String {
        let mut segments: Vec<String> = Vec::new();

        // todo refactor

        for palette in &self.palettes {
            segments.push(palette.to_string());
        }

        for room in &self.rooms {
            segments.push(room.to_string());
        }

        for tile in &self.tiles {
            segments.push(tile.to_string());
        }

        segments.push(self.avatar.to_string());

        for sprite in &self.sprites {
            segments.push(sprite.to_string());
        }

        for item in &self.items {
            segments.push(item.to_string());
        }

        for dialogue in &self.dialogues {
            segments.push(dialogue.to_string());
        }

        for ending in &self.endings {
            segments.push(ending.to_string());
        }

        for variable in &self.variables {
            segments.push(variable.to_string());
        }

        format!(
            "{}\n\n# BITSY VERSION {}\n\n! ROOM_FORMAT {}\n\n{}\n\n",
            &self.name,
            &self.version,
            &self.room_format,
            segments.join("\n\n"),
        )
    }
}

pub trait TileIds {
    fn tile_ids(&self) -> Vec<u64>;
}

impl TileIds for Game {
    fn tile_ids(&self) -> Vec<u64> {
        self.tiles.iter().map(|tile| {tile.id}).collect()
    }
}

/// 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 trait NewTileId {
    fn new_tile_id(&self) -> u64;
}

impl NewTileId for Game {
    fn new_tile_id(&self) -> u64 {
        let mut new_id = 0;

        let mut ids = self.tile_ids();
        ids.sort();

        for id in ids {
            if new_id == id {
                new_id += 1;
            } else {
                return new_id;
            }
        }

        new_id + 1
    }
}

impl Game {
    /// adds a tile safely and returns the new tile ID
    fn add_tile(&mut self, mut tile: Tile) -> u64 {
        let new_id = self.new_tile_id();
        tile.id = new_id;
        self.tiles.push(tile);
        new_id
    }
}

#[test]
fn test_game_from_string() {
    let output = Game::from(
        include_str!["../test/resources/default.bitsy"].to_string()
    );

    let expected = mock::game_default();

    assert_eq!(output, expected);
}

#[test]
fn test_game_to_string() {
    let output = mock::game_default().to_string();
    let expected = include_str!["../test/resources/default.bitsy"].to_string();
    assert_eq!(output, expected);
}

#[test]
fn test_tile_ids() {
    assert_eq!(mock::game_default().tile_ids(), vec![10]);
}

#[test]
fn test_new_tile_id() {
    // default tile has an id of 10 ("a"), so 0 is available
    assert_eq!(mock::game_default().new_tile_id(), 0);

    let mut game = mock::game_default();
    let mut tiles : Vec<Tile> = Vec::new();

    for n in 0..9 {
        if n != 4 {
            let mut new_tile = mock::tile_default();
            new_tile.id = n;
            tiles.push(new_tile);
        }
    }

    game.tiles = tiles;

    assert_eq!(game.new_tile_id(), 4);

    // fill in the space created above, and test that tile IDs get sorted

    let mut new_tile = mock::tile_default();
    new_tile.id = 4;
    game.tiles.push(new_tile);

    assert_eq!(game.new_tile_id(), 10);
}

#[test]
fn test_add_tile() {
    let mut game = mock::game_default();
    let new_id = game.add_tile(mock::tile_default());
    assert_eq!(new_id, 0);
    assert_eq!(game.tiles.len(), 2);
    let new_id = game.add_tile(mock::tile_default());
    assert_eq!(new_id, 1);
    assert_eq!(game.tiles.len(), 3);
}