317 lines
9.9 KiB
Rust
317 lines
9.9 KiB
Rust
use crate::{Avatar, Dialogue, Ending, Item, Palette, Room, Sprite, Tile, Variable, mock};
|
|
use std::fs;
|
|
|
|
#[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 {
|
|
let mut string = format!("{}\n\n", string.trim());
|
|
|
|
if string.starts_with("# BITSY VERSION") {
|
|
string = format!("\n\n{}", string);
|
|
}
|
|
|
|
let string = string;
|
|
|
|
// 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"),
|
|
)
|
|
}
|
|
}
|
|
|
|
impl 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`
|
|
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
|
|
}
|
|
/// 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);
|
|
}
|
|
|
|
#[test]
|
|
fn test_bitsy_omnibus() {
|
|
let acceptable_failures: Vec<String> = vec![
|
|
// avatar ordering issues
|
|
"src/test-resources/omnibus/682993AC.bitsy.txt".to_string(),
|
|
"src/test-resources/omnibus/0D901EE6.bitsy.txt".to_string(),
|
|
"src/test-resources/omnibus/7FEF71E4.bitsy.txt".to_string(),
|
|
"src/test-resources/omnibus/245E93CB.bitsy.txt".to_string(),
|
|
"src/test-resources/omnibus/A643C5F4.bitsy.txt".to_string(),
|
|
"src/test-resources/omnibus/7533372B.bitsy.txt".to_string(),
|
|
"src/test-resources/omnibus/DBD5D375.bitsy.txt".to_string(),
|
|
|
|
// fails because of sprite colours but also because a tile contains "NaN"
|
|
"src/test-resources/omnibus/DA88C287.bitsy.txt".to_string(),
|
|
|
|
// fails because room wall array is not implemented - @todo investigate
|
|
// (this game uses room_format 1 - I thought it'd be using 0...)
|
|
"src/test-resources/omnibus/76EB6E4A.bitsy.txt".to_string(),
|
|
"src/test-resources/omnibus/DC053B1A.bitsy.txt".to_string(),
|
|
|
|
// todo handle fonts!
|
|
"src/test-resources/omnibus/4B4EB988.bitsy.txt".to_string(),
|
|
];
|
|
|
|
let mut passes = 0;
|
|
let mut skips = 0;
|
|
|
|
for file in fs::read_dir("src/test-resources/omnibus").unwrap() {
|
|
let path = file.unwrap().path();
|
|
let nice_name = format!("{}", path.display());
|
|
|
|
if ! nice_name.contains("bitsy") || acceptable_failures.contains(&nice_name) {
|
|
skips += 1;
|
|
println!("Skipping: {}", nice_name);
|
|
println!("Skipped. {} passes, {} skips.", passes, skips);
|
|
continue;
|
|
}
|
|
|
|
println!("\nTesting: {}...", path.display());
|
|
let game_data = fs::read_to_string(path).unwrap();
|
|
let game = Game::from(game_data.clone());
|
|
assert_eq!(game.to_string().trim(), game_data.trim());
|
|
passes += 1;
|
|
println!("Success! {} passes, {} skips.", passes, skips);
|
|
}
|
|
}
|