Moved project into sub-folder 'dcb-tools' in preparation for merge with main repo

dcb-tools/src/extractor/cli.rs

@@ -0,0 +1,63 @@
+//! Cli manager for the extractor
+
+// Filesystem
+use std::path::{Path, PathBuf};
+
+// Clap
+use clap::{App as ClapApp, Arg as ClapArg};
+
+// Errors
+use err_panic::ErrorExtPanic;
+
+/// Data from the command line
+#[derive(PartialEq, Clone, Debug)]
+pub struct CliData {
+	/// The game file
+	pub game_file_path: PathBuf,
+
+	/// The ouput directory
+	pub output_dir: PathBuf,
+}
+
+impl CliData {
+	/// Constructs all of the cli data given and returns it
+	pub fn new() -> Self {
+		// Get all matches from cli
+		let matches = ClapApp::new("Dcb Extractor")
+			.version("0.0")
+			.author("Filipe [...] <[...]@gmail.com>")
+			.about("Extracts all data from a Digimon Digital Card Battle `.bin` game file")
+			.arg(
+				ClapArg::with_name("GAME_FILE")
+					.help("Sets the input game file to use")
+					.required(true)
+					.index(1),
+			)
+			.arg(
+				ClapArg::with_name("OUTPUT")
+					.help("Sets the output directory to use")
+					.short("o")
+					.long("output")
+					.takes_value(true)
+					.required(false),
+			)
+			.get_matches();
+
+		// Get the input filename
+		// Note: required
+		let game_file_path = matches
+			.value_of("GAME_FILE")
+			.map(Path::new)
+			.map(Path::to_path_buf)
+			.panic_msg("Unable to get required argument `GAME_FILE`");
+
+		// Try to get the output
+		let output_dir = match matches.value_of("OUTPUT") {
+			Some(output) => PathBuf::from(output),
+			None => game_file_path.parent().unwrap_or_else(|| Path::new(".")).to_path_buf(),
+		};
+
+		// Return the cli data
+		Self { game_file_path, output_dir }
+	}
+}

dcb-tools/src/extractor/main.rs

@@ -0,0 +1,73 @@
+//! Data extractor
+//!
+//! # Details
+//! Extracts data from the game file to several other files, that can be
+//! edited and then used by `Patcher` to modify the game file.
+//!
+//! # Syntax
+//! The executable may be called as `./extractor <game file> {-o <output directory>}`
+//!
+//! Use the command `./extractor --help` for more information.
+//!
+//! # Data extracted
+//! Currently only the following is extracted:
+//! - Card table
+
+// Features
+#![feature(box_syntax, backtrace, panic_info_message)]
+// Lints
+#![warn(clippy::restriction, clippy::pedantic, clippy::nursery)]
+#![allow(
+	clippy::implicit_return,         // We prefer implicit returns where possible
+	clippy::module_name_repetitions, // This happens often due to separating things into modules finely
+	clippy::wildcard_enum_match_arm, // We only use wildcards when we truly only care about some variants
+	clippy::result_expect_used,
+	clippy::option_expect_used,      // We use expect when there is no alternative.
+	clippy::used_underscore_binding, // Useful for macros and such
+)]
+
+// Modules
+// TODO: `cargo fmt` cannot use this syntax, possibly change it once possible
+mod cli;
+#[path = "../logger.rs"]
+mod logger;
+#[path = "../panic.rs"]
+mod panic;
+
+// Exports
+use cli::CliData;
+
+// Dcb
+use dcb::{
+	game::{card::Table as CardTable, deck::Table as DeckTable},
+	GameFile,
+};
+
+// Errors
+use err_panic::ErrorExtPanic;
+
+fn main() {
+	// Initialize the logger and set the panic handler
+	logger::init();
+	std::panic::set_hook(box panic::log_handler);
+
+	// Get all data from cli
+	let CliData { game_file_path, output_dir } = CliData::new();
+
+	// Open the game file
+	let input_file = std::fs::File::open(&game_file_path).panic_err_msg("Unable to open input file");
+	let mut game_file = GameFile::from_reader(input_file).panic_err_msg("Unable to parse input file as dcb");
+
+	// Get the cards table
+	let cards_table = CardTable::deserialize(&mut game_file).panic_err_msg("Unable to deserialize cards table from game file");
+	let cards_table_yaml = serde_yaml::to_string(&cards_table).panic_err_msg("Unable to serialize cards table to yaml");
+	log::info!("Extracted {} cards", cards_table.card_count());
+
+	// Get the decks table
+	let decks_table = DeckTable::deserialize(&mut game_file).panic_err_msg("Unable to deserialize decks table from game file");
+	let decks_table_yaml = serde_yaml::to_string(&decks_table).panic_err_msg("Unable to serialize decks table to yaml");
+
+	// And output everything to the files
+	std::fs::write(&output_dir.join("cards.yaml"), cards_table_yaml).panic_err_msg("Unable to write cards table to file");
+	std::fs::write(&output_dir.join("decks.yaml"), decks_table_yaml).panic_err_msg("Unable to write decks table to file");
+}

dcb-tools/src/logger.rs

@@ -0,0 +1,27 @@
+//! Logger initialization
+
+// Log
+use log::LevelFilter;
+use simplelog::{CombinedLogger, Config, SharedLogger, TermLogger, TerminalMode, WriteLogger};
+
+// Error
+use err_ext::ResultExt;
+
+/// The type of logger required to pass to `CombinedLogger::init`
+type BoxedLogger = Box<dyn SharedLogger>;
+
+/// Initializes the global logger
+pub fn init() {
+	// All loggers to try and initialize
+	let loggers: Vec<Option<BoxedLogger>> = vec![
+		TermLogger::new(LevelFilter::Warn, Config::default(), TerminalMode::Mixed).map(|logger| BoxedLogger::from(logger)),
+		std::fs::File::create("latest.log")
+			.ok()
+			.map(|file| WriteLogger::new(LevelFilter::Trace, Config::default(), file))
+			.map(|logger| BoxedLogger::from(logger)),
+	];
+
+	// Filter all logger that actually work and initialize them
+	CombinedLogger::init(loggers.into_iter().filter_map(std::convert::identity).collect())
+		.ignore_with_err(|_| log::warn!("Logger was already initialized at the start of the program"));
+}

dcb-tools/src/panic.rs

@@ -0,0 +1,31 @@
+//! Panic handlers for this application
+
+// Std
+use std::{
+	backtrace::{Backtrace, BacktraceStatus},
+	error::Error,
+};
+// Error backtrace
+use err_backtrace::ErrBacktraceExt;
+
+/// Panic handler based on logging to the current initialization
+pub fn log_handler(info: &std::panic::PanicInfo) {
+	// Log that this thread has panicked
+	log::error!("Thread \"{}\" panicked", std::thread::current().name().unwrap_or("[Unknown]"));
+
+	// Log any message that came with the panic
+	log::info!("Panic message: {}", info.message().unwrap_or(&format_args!("None")));
+
+	// Print an error backtrace if we found any
+	if let Some(err) = info.payload().downcast_ref::<Box<dyn Error + Send + Sync>>() {
+		log::info!("Error backtrace:\n{}", err.err_backtrace());
+	}
+
+	// And print a backtrace of where this panic occured.
+	let backtrace = Backtrace::force_capture();
+	if backtrace.status() == BacktraceStatus::Captured {
+		log::info!("Backtrace:\n{}", backtrace);
+	} else {
+		log::info!("Unable to get backtrace: {}", backtrace);
+	}
+}

dcb-tools/src/patcher/cli.rs

@@ -0,0 +1,58 @@
+//! Cli manager for the extractor
+
+// Filesystem
+use std::path::{Path, PathBuf};
+
+// Clap
+use clap::{App as ClapApp, Arg as ClapArg};
+
+// Errors
+use err_panic::ErrorExtPanic;
+
+/// Data from the command line
+#[derive(PartialEq, Clone, Debug)]
+pub struct CliData {
+	/// The game file
+	pub game_file_path: PathBuf,
+
+	/// The input directory
+	pub input_dir: PathBuf,
+}
+
+impl CliData {
+	/// Constructs all of the cli data given and returns it
+	pub fn new() -> Self {
+		// Get all matches from cli
+		let matches = ClapApp::new("Dcb Patcher")
+			.version("0.0")
+			.author("Filipe [...] <[...]@gmail.com>")
+			.about("Patches data to a Digimon Digital Card Battle `.bin` game file")
+			.arg(ClapArg::with_name("GAME_FILE").help("Sets the game file to use").required(true).index(1))
+			.arg(
+				ClapArg::with_name("INPUT")
+					.help("Sets the input directory to use")
+					.short("i")
+					.long("input")
+					.takes_value(true)
+					.required(false),
+			)
+			.get_matches();
+
+		// Get the ouput filename
+		// Note: required
+		let game_file_path = matches
+			.value_of("GAME_FILE")
+			.map(Path::new)
+			.map(Path::to_path_buf)
+			.panic_msg("Unable to get required argument `GAME_FILE`");
+
+		// Get the input dir as either an input, the game file directory or the current directory
+		let input_dir = matches
+			.value_of("INPUT")
+			.map_or_else(|| game_file_path.parent().unwrap_or_else(|| Path::new(".")), Path::new)
+			.to_path_buf();
+
+		// Return the cli data
+		Self { game_file_path, input_dir }
+	}
+}

dcb-tools/src/patcher/main.rs

@@ -0,0 +1,74 @@
+//! Data patches
+//!
+//! # Details
+//! Patches data to the game file from several other files.
+//!
+//! # Syntax
+//! The executable may be called as `./patcher <game file> <directory>`
+//!
+//! Use the command `./patcher --help` for more information.
+//!
+//! # Data patched
+//! Currently only the following is patched:
+//! - Card table
+
+// Features
+#![feature(box_syntax, backtrace, panic_info_message)]
+// Lints
+#![warn(clippy::restriction, clippy::pedantic, clippy::nursery)]
+#![allow(
+	clippy::implicit_return,         // We prefer implicit returns where possible
+	clippy::module_name_repetitions, // This happens often due to separating things into modules finely
+	clippy::wildcard_enum_match_arm, // We only use wildcards when we truly only care about some variants
+	clippy::result_expect_used,
+	clippy::option_expect_used,      // We use expect when there is no alternative.
+	clippy::used_underscore_binding, // Useful for macros and such
+)]
+
+// Modules
+mod cli;
+#[path = "../logger.rs"]
+mod logger;
+#[path = "../panic.rs"]
+mod panic;
+
+// Exports
+use cli::CliData;
+
+// Dcb
+use dcb::{
+	game::{card::Table as CardTable, deck::Table as DeckTable},
+	GameFile,
+};
+
+// Errors
+use err_panic::ErrorExtPanic;
+
+fn main() {
+	// Initialize the logger and set the panic handler
+	logger::init();
+	std::panic::set_hook(box panic::log_handler);
+
+	// Get all data from cli
+	let CliData { game_file_path, input_dir } = CliData::new();
+
+	// Load the card table
+	let cards_table_file = std::fs::File::open(input_dir.join("cards.yaml")).panic_err_msg("Unable to open `cards.yaml`");
+	let cards_table: CardTable = serde_yaml::from_reader(cards_table_file).panic_err_msg("Unable to parse `cards.yaml`");
+
+	// Load the decks table
+	let decks_table_file = std::fs::File::open(input_dir.join("decks.yaml")).panic_err_msg("Unable to open `decks.yaml`");
+	let decks_table: DeckTable = serde_yaml::from_reader(decks_table_file).panic_err_msg("Unable to parse `decks.yaml`");
+
+	// Open the game file
+	let game_file = std::fs::OpenOptions::new()
+		.write(true)
+		.truncate(false)
+		.open(game_file_path)
+		.panic_err_msg("Unable to open game file");
+	let mut game_file = GameFile::from_reader(game_file).panic_err_msg("Unable to initialize game file");
+
+	// And write everything
+	cards_table.serialize(&mut game_file).panic_err_msg("Unable to serialize cards table");
+	decks_table.serialize(&mut game_file).panic_err_msg("Unable to serialize decks table");
+}