394 lines
11 KiB
Rust
394 lines
11 KiB
Rust
use bitsy_parser::game::Game;
|
||
use bitsy_parser::image::Image;
|
||
use bitsy_parser::tile::Tile;
|
||
use image::{GenericImageView, Pixel, DynamicImage};
|
||
use image::imageops::ColorMap;
|
||
use image::imageops::FilterType::CatmullRom;
|
||
use lazy_static::lazy_static;
|
||
use std::sync::Mutex;
|
||
use wasm_bindgen::prelude::*;
|
||
|
||
mod colour_map;
|
||
|
||
use colour_map::ColourMap;
|
||
|
||
const SD: u32 = 8;
|
||
|
||
enum SelectedPalette {
|
||
None,
|
||
Existing {
|
||
id: String,
|
||
},
|
||
New {
|
||
background: bitsy_parser::Colour,
|
||
foreground: bitsy_parser::Colour,
|
||
}
|
||
}
|
||
|
||
struct State {
|
||
game: Option<Game>,
|
||
image: Option<DynamicImage>,
|
||
room_name: Option<String>,
|
||
palette: SelectedPalette,
|
||
dither: bool,
|
||
brightness: i32,
|
||
}
|
||
|
||
lazy_static! {
|
||
static ref STATE: Mutex<State> = Mutex::new(
|
||
State {
|
||
game: None,
|
||
image: None,
|
||
room_name: None,
|
||
palette: SelectedPalette::None,
|
||
dither: false,
|
||
brightness: 0,
|
||
}
|
||
);
|
||
}
|
||
|
||
fn tile_name(prefix: &Option<String>, x: &u32, y: &u32) -> Option<String> {
|
||
if let Some(prefix) = prefix {
|
||
Some(format!("{} ({},{})", prefix, x, y))
|
||
} else {
|
||
None
|
||
}
|
||
}
|
||
|
||
#[wasm_bindgen]
|
||
pub fn load_default_game() {
|
||
let mut state = STATE.lock().unwrap();
|
||
|
||
state.game = Some(bitsy_parser::mock::game_default());
|
||
|
||
// yes, this will probably always just be "0", but to be safe…
|
||
state.palette = SelectedPalette::Existing {
|
||
id: bitsy_parser::mock::game_default().palette_ids()[0].clone()
|
||
}
|
||
}
|
||
|
||
#[wasm_bindgen]
|
||
pub fn load_game(game_data: String) -> String {
|
||
let mut state = STATE.lock().unwrap();
|
||
|
||
let result = Game::from(game_data);
|
||
|
||
match result {
|
||
Ok((game, _errs)) => {
|
||
let palette_id = game.palette_ids()[0].clone();
|
||
state.game = Some(game);
|
||
state.palette = SelectedPalette::Existing { id: palette_id };
|
||
format!("Loaded game")
|
||
},
|
||
_ => {
|
||
state.game = None;
|
||
state.palette = SelectedPalette::None;
|
||
format!("{}", result.err().unwrap())
|
||
}
|
||
}
|
||
}
|
||
|
||
#[wasm_bindgen]
|
||
pub fn load_image(image_base64: String) -> String {
|
||
let mut state = STATE.lock().expect("Couldn't lock application state");
|
||
|
||
let image_base64: Vec<&str> = image_base64.split("base64,").collect();
|
||
|
||
if image_base64.len() < 2 {
|
||
return format!("Error: Badly-formatted base64: {}", image_base64.join(""));
|
||
}
|
||
|
||
let image_base64 = image_base64[1];
|
||
|
||
match base64::decode(image_base64) {
|
||
Ok(image) => {
|
||
match image::load_from_memory(image.as_ref()) {
|
||
Ok(image) => {
|
||
let size = format!("{}×{}", image.width(), image.height());
|
||
// todo get rid of magic numbers! what about Bitsy HD?
|
||
let image = image.resize(128, 128, CatmullRom);
|
||
state.image = Some(image);
|
||
size
|
||
},
|
||
_ => {
|
||
state.image = None;
|
||
"Error: Couldn't load image".to_string()
|
||
}
|
||
}
|
||
},
|
||
_ => {
|
||
state.image = None;
|
||
"Error: Couldn't decode image".to_string()
|
||
}
|
||
}
|
||
}
|
||
|
||
#[wasm_bindgen]
|
||
pub fn set_dither(dither: bool) {
|
||
let mut state = STATE.lock().unwrap();
|
||
state.dither = dither;
|
||
}
|
||
|
||
#[wasm_bindgen]
|
||
pub fn set_palette(palette_id: &str, background: String, foreground: String) {
|
||
let mut state = STATE.lock().unwrap();
|
||
|
||
state.palette = match palette_id {
|
||
"NEW_PALETTE" => SelectedPalette::New {
|
||
background: bitsy_parser::Colour::from_hex(&background).unwrap(),
|
||
foreground: bitsy_parser::Colour::from_hex(&foreground).unwrap(),
|
||
},
|
||
"" => SelectedPalette::None,
|
||
_ => SelectedPalette::Existing { id: palette_id.to_string() },
|
||
}
|
||
}
|
||
|
||
#[wasm_bindgen]
|
||
pub fn set_room_name(room_name: String) {
|
||
let mut state = STATE.lock().unwrap();
|
||
|
||
match room_name.is_empty() {
|
||
true => { state.room_name = None },
|
||
false => { state.room_name = Some(room_name) },
|
||
}
|
||
}
|
||
|
||
#[wasm_bindgen]
|
||
pub fn set_brightness(brightness: i32) {
|
||
let mut state = STATE.lock().unwrap();
|
||
state.brightness = brightness;
|
||
}
|
||
|
||
#[wasm_bindgen]
|
||
pub fn get_palettes() -> String {
|
||
let state = STATE.lock().unwrap();
|
||
|
||
let mut palette_objects = json::JsonValue::new_array();
|
||
|
||
for palette in &state.game.as_ref().unwrap().palettes {
|
||
let mut object = json::JsonValue::new_object();
|
||
|
||
object.insert("id", palette.id.clone()).unwrap();
|
||
|
||
object.insert(
|
||
"name",
|
||
palette.name.clone().unwrap_or(
|
||
format!("Palette {}", palette.id))
|
||
).unwrap();
|
||
|
||
palette_objects.push(object).unwrap();
|
||
}
|
||
|
||
json::stringify(palette_objects)
|
||
}
|
||
|
||
fn image_to_base64(image: &DynamicImage) -> String {
|
||
let mut bytes: Vec<u8> = Vec::new();
|
||
image.write_to(&mut bytes, image::ImageOutputFormat::Png).unwrap();
|
||
format!("data:image/png;base64,{}", base64::encode(&bytes))
|
||
}
|
||
|
||
fn palette_from(bg: &bitsy_parser::Colour, fg: &bitsy_parser::Colour) -> bitsy_parser::Palette {
|
||
bitsy_parser::Palette {
|
||
id: "0".to_string(),
|
||
name: None,
|
||
colours: vec![
|
||
bg.clone(), fg.clone(), bitsy_parser::Colour { red: 0, green: 0, blue: 0 }
|
||
],
|
||
}
|
||
}
|
||
|
||
fn render_preview(state: &State) -> DynamicImage {
|
||
let mut buffer = state.image.as_ref().unwrap().clone().into_rgba8();
|
||
|
||
let palette = match &state.palette {
|
||
SelectedPalette::None => bitsy_parser::mock::game_default().palettes[0].clone(),
|
||
SelectedPalette::Existing { id } => state.game.as_ref().unwrap().get_palette(id).unwrap().clone(),
|
||
SelectedPalette::New { background, foreground } => palette_from(background, foreground),
|
||
};
|
||
|
||
let colour_map = crate::ColourMap::from(&palette);
|
||
|
||
// adjust brightness
|
||
let mut buffer = image::imageops::brighten(&mut buffer, state.brightness);
|
||
|
||
if state.dither {
|
||
image::imageops::dither(&mut buffer, &colour_map);
|
||
} else {
|
||
// just do colour indexing
|
||
let indices = image::imageops::colorops::index_colors(&mut buffer, &colour_map);
|
||
|
||
// todo get rid of magic numbers! what about Bitsy HD?
|
||
buffer = image::ImageBuffer::from_fn(128, 128, |x, y| -> image::Rgba<u8> {
|
||
let p = indices.get_pixel(x, y);
|
||
|
||
colour_map
|
||
.lookup(p.0[0] as usize)
|
||
.expect("indexed colour out-of-range")
|
||
.into()
|
||
});
|
||
}
|
||
|
||
image::DynamicImage::ImageRgba8(buffer)
|
||
}
|
||
|
||
#[wasm_bindgen]
|
||
pub fn get_preview() -> String {
|
||
let state = STATE.lock().unwrap();
|
||
|
||
match &state.image.is_some() {
|
||
true => image_to_base64(&render_preview(&state)),
|
||
false => "".to_string(),
|
||
}
|
||
}
|
||
|
||
#[wasm_bindgen]
|
||
pub fn add_room() -> String {
|
||
let mut state = STATE.lock().expect("Couldn't lock application state");
|
||
|
||
if state.game.is_none() {
|
||
return "No game data loaded".into();
|
||
}
|
||
|
||
match &state.palette {
|
||
SelectedPalette::None => { return "No palette selected".into(); },
|
||
_ => {}
|
||
};
|
||
|
||
let mut game = state.game.clone().unwrap();
|
||
|
||
if state.image.is_none() {
|
||
return "No image loaded".into();
|
||
}
|
||
|
||
let palette_id = Some(match &state.palette {
|
||
SelectedPalette::None => bitsy_parser::mock::game_default().palettes[0].id.clone(),
|
||
SelectedPalette::Existing { id } => id.clone(),
|
||
SelectedPalette::New { background, foreground } => {
|
||
game.add_palette(palette_from(background, foreground))
|
||
},
|
||
});
|
||
|
||
let foreground = &game.palettes
|
||
.iter()
|
||
.find(|&palette| &palette.id == palette_id.as_ref().unwrap())
|
||
.unwrap().colours[1].clone();
|
||
|
||
let preview = render_preview(&state);
|
||
|
||
let width = 128;
|
||
let height = 128;
|
||
let columns = (width as f64 / SD as f64).floor() as u32;
|
||
let rows = (height as f64 / SD as f64).floor() as u32;
|
||
|
||
let mut tile_ids = Vec::new();
|
||
let initial_tile_count = game.tiles.len();
|
||
|
||
for row in 0..rows {
|
||
for column in 0..columns {
|
||
let mut pixels = Vec::with_capacity(64);
|
||
|
||
fn colour_match(a: &image::Rgb<u8>, b: &bitsy_parser::Colour) -> u8 {
|
||
if a[0] == b.red && a[1] == b.green && a[2] == b.blue { 1 } else { 0 }
|
||
}
|
||
|
||
for y in (row * SD)..((row + 1) * SD) {
|
||
for x in (column * SD)..((column + 1) * SD) {
|
||
let pixel = preview.get_pixel(x, y).to_rgb();
|
||
pixels.push(colour_match(&pixel, foreground));
|
||
}
|
||
}
|
||
|
||
let tile = Tile {
|
||
// "0" will get overwritten to a new, safe tile ID
|
||
id: "0".to_string(),
|
||
name: tile_name(&state.room_name, &column, &row),
|
||
wall: None,
|
||
animation_frames: vec![Image { pixels }],
|
||
colour_id: None
|
||
};
|
||
|
||
let tile_id = if game.tiles.contains(&tile) {
|
||
game.tiles.iter().find(|&t| t == &tile).unwrap().id.clone()
|
||
} else {
|
||
game.add_tile(tile)
|
||
};
|
||
|
||
tile_ids.push(tile_id);
|
||
}
|
||
}
|
||
|
||
game.add_room(bitsy_parser::Room {
|
||
id: "0".to_string(),
|
||
palette_id,
|
||
name: state.room_name.clone(),
|
||
tiles: tile_ids,
|
||
items: vec![],
|
||
exits: vec![],
|
||
endings: vec![],
|
||
walls: None
|
||
});
|
||
|
||
game.dedupe_tiles();
|
||
|
||
let new_tile_count = game.tiles.len();
|
||
|
||
state.game = Some(game.to_owned());
|
||
|
||
format!(
|
||
"Added room \"{}\" with {} new tiles",
|
||
&state.room_name.as_ref().unwrap_or(&"untitled".to_string()),
|
||
new_tile_count - initial_tile_count
|
||
)
|
||
}
|
||
|
||
#[wasm_bindgen]
|
||
pub fn output() -> String {
|
||
let state = STATE.lock().unwrap();
|
||
|
||
match &state.game {
|
||
Some(game) => game.to_string(),
|
||
None => "No game loaded".to_string(),
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod test {
|
||
use crate::{add_room, load_image, load_default_game, output, get_preview, set_room_name};
|
||
|
||
#[test]
|
||
fn image_to_base64() {
|
||
let image = image::load_from_memory(include_bytes!("test-resources/test.png")).unwrap();
|
||
let output = crate::image_to_base64(&image);
|
||
let expected = include_str!("test-resources/test.png.base64").trim();
|
||
assert_eq!(output, expected);
|
||
}
|
||
|
||
#[test]
|
||
fn get_palettes() {
|
||
load_default_game();
|
||
let output = crate::get_palettes();
|
||
let expected = "[{\"id\":\"0\",\"name\":\"blueprint\"}]";
|
||
assert_eq!(output, expected);
|
||
}
|
||
|
||
#[test]
|
||
fn render_preview() {
|
||
load_default_game();
|
||
load_image(include_str!("test-resources/colour_input.png.base64").trim().to_string());
|
||
let output = get_preview();
|
||
let expected = include_str!("test-resources/colour_input.png.base64.blueprint").trim();
|
||
assert_eq!(output, expected);
|
||
}
|
||
|
||
#[test]
|
||
fn example() {
|
||
load_default_game();
|
||
load_image(include_str!("test-resources/test.png.base64").trim().to_string());
|
||
set_room_name("test".to_string());
|
||
println!("add_room(): {}", add_room());
|
||
// todo what? why are extraneous pixels appearing in the output tiles?
|
||
assert_eq!(output(), include_str!("test-resources/expected.bitsy"));
|
||
}
|
||
}
|