Merge pull request #37 from yellowcake-org/develop

Parsing and exporting `.map` files, and everything needed for it.

Author: 0xceed

Cargo.toml

@@ -1,10 +1,27 @@
 [package]
-edition = "2018"
+edition = "2021"
 name = "libycresources"
-version = "0.1.0"
+version = "0.2.0"
 
 [[example]]
 name = "undat"
 
+[[example]]
+name = "fontview"
+
+[[example]]
+name = "frameview"
+
+[[example]]
+name = "protoview"
+
+[[example]]
+name = "mapview"
+
+[dependencies]
+byteorder = "1.2"
+
 [dev-dependencies]
-clap = "3.0.0-beta.2"
+png = "0.17.7"
+bmp = "0.5.0"
+clap = "3.0.0-beta.5"

README.md

@@ -0,0 +1,23 @@
+## libycresources
+
+This repository is a part of [Yellowcake](https://github.com/yellowcake-org) project.
+
+### What it does
+
+The library intended to provide instruments for working with original Fallout™ resources, such as `.map`, `.pro`, `.dat` files, and many others, which were used in classic Fallout™ games. This repository also does include example tools, provided for each file format separately, using `examples` targets. Sometimes they are just print out available info, but very often they provide additional functionality, which goes beyond simple examples, like `mapview` tool.
+
+### Why this is useful
+
+It is useful in obvious way for reproducing original game, providing modern, safe and stable codebase to work with original games' resources. It also may serve as a documenation for those, who want to learn about original file formats. And finally, it's example tools could be a good starting point for modders of original games. In very first release it can't do much, though, but it's already better than original tools released by the publisher in what it actually allows to do. For instance, again, `mapview` can be used to create some arts from maps, or guides. In case of significant demand from the community, it might become something bigger, like full-featured map editor, so stay tuned.
+
+### How to get started
+
+Basically you just use Cargo and default Rust tooling to explore different modules and examples. Each file format is represented with different Rust module. It also has a couple of common modules, which provided basic data structures, needed for the game files' formats and abstractions. Examples' targets provide a view on intended way of using the library's functions.
+
+### Where to get help
+
+[GitHub Discussions](https://github.com/yellowcake-org/libycresources/discussions) is a good starting point. GitHub Issues are disabled at the moment, but will be enabled in case of significant activity from community. As for now, I am handling all issues internally, using additional software.
+
+### Who maintains and contributes
+
+Currently, only [@0xceed](https://github.com/0xceed) is working on the library. While help from the community will be _very_ needed in the future, this early in development I need to focus on creating good example of my vision, guidelines and many, many more.

examples/fontview/main.rs

@@ -0,0 +1,81 @@
+use std::fs::File;
+
+use clap::Parser;
+
+use libycresources::formats::aaf;
+
+pub(crate) mod print;
+
+#[derive(Parser)]
+#[clap(name = "fontview", version)]
+struct Options {
+    /// Path to the input font file (.aaf)
+    #[clap(short, long)]
+    input: String,
+    #[clap(subcommand)]
+    action: Action,
+}
+
+#[derive(Parser)]
+enum Action {
+    /// Prints all glyphs from specified font
+    Dump,
+    /// Prints specified string with glyphs from font
+    Print(Print),
+}
+
+#[derive(Parser)]
+struct Print {
+    string: String,
+}
+
+fn main() {
+    let options = Options::parse();
+
+    let file = match File::open(&options.input) {
+        Err(error) => {
+            eprintln!("Couldn't open input file: {:?}", error);
+            return;
+        }
+        Ok(value) => value,
+    };
+
+    let mut reader = std::io::BufReader::with_capacity(1 * 1024 * 1024, file);
+
+    let font = match aaf::parse::font(&mut reader) {
+        Err(error) => {
+            eprintln!("Error occurred: {:?}", error);
+            return;
+        }
+        Ok(value) => value,
+    };
+
+    match options.action {
+        Action::Dump => {
+            println!("Line height: {:?}", font.height);
+            println!("Vertical spacing: {:?}", font.spacing.vertical);
+            println!("Horizontal spacing: {:?}", font.spacing.horizontal);
+
+            println!();
+
+            for glyph in font.glyphs {
+                print::glyph(&glyph);
+            }
+        }
+        Action::Print(arguments) => {
+            for char in arguments.string.chars() {
+                if char.is_ascii() {
+                    if let Some(glyph) = &font.glyphs.get(char as usize) {
+                        print::glyph(&glyph);
+                    } else {
+                        eprintln!("Encountered char, which is absent in provided font. Aborting.");
+                        return;
+                    }
+                } else {
+                    eprintln!("Non-ASCII char was found within provided string. Aborting.");
+                    return;
+                }
+            }
+        }
+    }
+}

examples/fontview/print.rs

@@ -0,0 +1,26 @@
+use libycresources::formats::aaf;
+
+pub fn glyph(glyph: &aaf::Glyph) {
+    if !glyph.dots.is_empty() {
+        for row in 0..glyph.height {
+            for column in 0..glyph.width {
+                let index = (row * glyph.width + column) as usize;
+
+                if let Some(pixel) = &glyph.dots.get(index) {
+                    let levels = [' ', '.', ':', '-', '=', '+', '*', '#', '%', '@'];
+                    let index = levels.len() * pixel.value / (pixel.scale.end - pixel.scale.start);
+
+                    if let Some(level) = levels.get(index) {
+                        print!("{:}", level);
+                    } else {
+                        eprintln!("Encountered a pixel, which brightness level is of bounds.")
+                    }
+                } else {
+                    eprintln!("Encountered a pixel located out of bounds.")
+                }
+            }
+
+            if row != glyph.height { println!(); }
+        }
+    }
+}

examples/frameview/main.rs

@@ -0,0 +1,153 @@
+use std::fs::File;
+
+use clap::Parser;
+
+use libycresources::formats::{frm, pal};
+
+pub mod render;
+
+#[derive(Parser)]
+#[clap(name = "frameview", version)]
+struct Options {
+    /// Path to the input frame file (.frm, .fr0-5)
+    #[clap(short, long)]
+    input: String,
+    #[clap(subcommand)]
+    action: Action,
+}
+
+#[derive(Parser)]
+enum Action {
+    /// Prints summary info about contents of the file
+    Info,
+    /// Renders frame contents into .bmp file(s) in specified directory
+    Render(Render),
+}
+
+#[derive(Parser)]
+struct Render {
+    /// Path to the input palette file (.pal)
+    #[clap(short, long)]
+    palette: String,
+    /// Output directory path
+    #[clap(short, long)]
+    directory: String,
+}
+
+fn main() {
+    let options = Options::parse();
+
+    let file = match File::open(&options.input) {
+        Err(error) => {
+            eprintln!("Couldn't open input file: {:?}", error);
+            return;
+        }
+        Ok(value) => value,
+    };
+
+    let mut reader = std::io::BufReader::with_capacity(1 * 1024 * 1024, file);
+
+    let sprite = match frm::parse::sprite(&mut reader) {
+        Err(error) => {
+            eprintln!("Error occurred: {:?}", error);
+            return;
+        }
+        Ok(value) => value,
+    };
+
+    match options.action {
+        Action::Info => {
+            println!("FPS: {:}.", sprite.fps);
+            println!("Frames per orientation: {:}.", sprite.count);
+            println!("Unique animations: {:}.", sprite.animations.len());
+            println!("Orientated animations: {:?}.", sprite.orientations);
+
+            println!();
+
+            for (index, animation) in sprite.animations.iter().enumerate() {
+                println!(
+                    "Animation {:} has {:} frame(s).",
+                    index,
+                    animation.frames.len()
+                );
+            }
+        }
+        Action::Render(arguments) => {
+            let output = std::path::Path::new(&arguments.directory);
+
+            if !output.exists() {
+                eprintln!("Output path does not exist. Aborting.");
+                return;
+            }
+
+            if !output.is_dir() {
+                eprintln!("Output path is not a directory. Aborting.");
+                return;
+            }
+
+            let directory_name = match std::path::Path::new(&options.input).file_stem() {
+                Some(value) => value,
+                None => {
+                    eprintln!("Couldn't determine frame output filename.");
+                    return;
+                }
+            };
+
+            let path = output.join(directory_name);
+
+            let mut reader = std::io::BufReader::with_capacity(
+                1 * 1024 * 1024,
+                match File::open(arguments.palette) {
+                    Err(error) => {
+                        eprintln!("Couldn't open palette file: {:?}", error);
+                        return;
+                    }
+                    Ok(value) => value,
+                },
+            );
+
+            let palette = match pal::parse::palette(&mut reader) {
+                Err(error) => {
+                    eprintln!("Error occurred: {:?}", error);
+                    return;
+                }
+                Ok(value) => value,
+            };
+
+            for (index, animation) in sprite.animations.iter().enumerate() {
+                let animation_dir = path.join(index.to_string());
+
+                match std::fs::create_dir_all(&animation_dir) {
+                    Err(error) => {
+                        eprintln!(
+                            "Couldn't create animation output directory tree: {:?}, error: {:}",
+                            animation_dir, error
+                        );
+                        return;
+                    }
+                    Ok(_) => (),
+                };
+
+                for (index, frame) in animation.frames.iter().enumerate() {
+                    let frame_path = animation_dir.join(index.to_string()).with_extension("bmp");
+
+                    match render::frame(&frame, &palette) {
+                        Ok(image) => {
+                            match image.save(frame_path) {
+                                Ok(_) => {}
+                                Err(error) => {
+                                    eprintln!("Couldn't write output file: {:}", error);
+                                    return;
+                                }
+                            }
+                        }
+                        Err(error) => {
+                            eprintln!("Couldn't write output file: {:?}", error);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

examples/frameview/render.rs

@@ -0,0 +1,41 @@
+use libycresources::formats::{frm, pal};
+
+#[derive(Debug)]
+pub enum Error { Corrupted }
+
+pub fn frame(frame: &frm::Frame, palette: &pal::Palette) -> Result<bmp::Image, Error> {
+    let mut image = bmp::Image::new(frame.size.width as u32, frame.size.height as u32);
+
+    for (x, y) in image.coordinates() {
+        let index = (frame.size.width as u32 * y + x) as usize;
+
+        if let Some(&index) = frame.indexes.get(index) {
+            if let Some(&index) = frame.indexes.get(index as usize) {
+                if let Some(pixel) = &palette.colors.get(index as usize) {
+                    image.set_pixel(
+                        x,
+                        y,
+                        match pixel {
+                            None => bmp::Pixel::new(0, 0, 0),
+                            Some(color) => {
+                                let red = ((color.red.value as usize * (u8::MAX as usize + 1)) / color.red.scale.len()) as u8;
+                                let green = ((color.green.value as usize * (u8::MAX as usize + 1)) / color.green.scale.len()) as u8;
+                                let blue = ((color.blue.value as usize * (u8::MAX as usize + 1)) / color.blue.scale.len()) as u8;
+
+                                bmp::Pixel::new(red, green, blue)
+                            }
+                        },
+                    );
+                } else {
+                    return Err(Error::Corrupted);
+                }
+            } else {
+                return Err(Error::Corrupted);
+            }
+        } else {
+            return Err(Error::Corrupted);
+        }
+    }
+
+    Ok(image)
+}

examples/mapview/cli.rs

@@ -0,0 +1,28 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+
+use export::Export;
+
+pub(crate) mod export;
+
+#[derive(Parser)]
+#[clap(name = "mapview", version)]
+pub(crate) struct Options {
+    /// Path to the input map file (.map)
+    #[clap(short, long)]
+    pub(crate) input: PathBuf,
+    /// Path to the root resources directory
+    #[clap(short, long)]
+    pub(crate) resources: PathBuf,
+    #[clap(subcommand)]
+    pub(crate) action: Action,
+}
+
+#[derive(Parser)]
+pub(crate) enum Action {
+    /// Prints out all available info about map
+    Dump,
+    /// Renders the map into .bmp file
+    Export(Export),
+}