497 lines
20 KiB
Rust
497 lines
20 KiB
Rust
use config::{default_config_filename, load_config, Config};
|
|
use eframe::egui;
|
|
use eframe::egui::Color32;
|
|
use infos::{
|
|
CommandErrors, CommandManager, Difficulty, LauncherInfo, MultiManager, SingleManager, WadInfo,
|
|
};
|
|
use native_dialog::{MessageDialog, MessageType};
|
|
use std::path::PathBuf;
|
|
use std::process::Command;
|
|
use wad::get_summary;
|
|
use walkdir::{DirEntry, WalkDir};
|
|
|
|
pub mod config;
|
|
pub mod infos;
|
|
pub mod wad;
|
|
|
|
fn main() -> Result<(), eframe::Error> {
|
|
let gui_options = eframe::NativeOptions {
|
|
..Default::default()
|
|
};
|
|
eframe::run_native(
|
|
"Rust Doom Launcher",
|
|
gui_options,
|
|
Box::new(|_cc| Box::<RustDoomLauncher>::default()),
|
|
)
|
|
}
|
|
|
|
#[derive(PartialEq)]
|
|
enum FileType {
|
|
Iwad,
|
|
Pwad,
|
|
Launcher,
|
|
}
|
|
|
|
struct RustDoomLauncher {
|
|
launcher_manager: SingleManager<LauncherInfo>,
|
|
iwad_manager: SingleManager<WadInfo>,
|
|
pwad_manager: MultiManager<WadInfo>,
|
|
add_name: String,
|
|
config_filename: PathBuf,
|
|
config: Option<Config>,
|
|
config_tried: bool,
|
|
command_manager: CommandManager,
|
|
display_command: bool,
|
|
add_stuff_window_displayed: bool,
|
|
selected_file_type: FileType,
|
|
selected_file_path: PathBuf,
|
|
}
|
|
|
|
impl Default for RustDoomLauncher {
|
|
fn default() -> Self {
|
|
Self {
|
|
launcher_manager: SingleManager::new(),
|
|
iwad_manager: SingleManager::new(),
|
|
pwad_manager: MultiManager::new(),
|
|
command_manager: CommandManager::default(),
|
|
add_name: "".to_string(),
|
|
config_filename: default_config_filename(),
|
|
config: None, // TODO: put the config_filename in the config stuct - or something
|
|
config_tried: false,
|
|
display_command: false,
|
|
add_stuff_window_displayed: false,
|
|
selected_file_type: FileType::Pwad,
|
|
selected_file_path: PathBuf::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn is_wad_file(entry: &DirEntry) -> bool {
|
|
let filename = entry.file_name().to_str().unwrap().to_lowercase();
|
|
println!("{} - > {}", filename, filename.ends_with("wad"));
|
|
filename.ends_with("wad") || filename.ends_with("pk3")
|
|
}
|
|
|
|
fn get_wads_in_folder(path: &PathBuf) -> Vec<WadInfo> {
|
|
let mut wads = Vec::new();
|
|
for entry in WalkDir::new(path).max_depth(2) {
|
|
let entry = entry.unwrap();
|
|
if is_wad_file(&entry) {
|
|
|
|
wads.push(WadInfo {
|
|
name: format!("{}", entry.path().file_name().unwrap().to_str().unwrap()),
|
|
path: entry.path().to_path_buf(),
|
|
info_text: None,
|
|
})
|
|
}
|
|
}
|
|
wads
|
|
}
|
|
|
|
impl RustDoomLauncher {
|
|
fn get_config_file_stuff(&mut self) {
|
|
// TODO - Throw some kind of error if a config file isn't found and/or missing iwad folder
|
|
println!("{:?}", self.config_filename);
|
|
match load_config(&self.config_filename) {
|
|
Ok(c) => {
|
|
println!("{:?}", c);
|
|
if let Some(launchers) = &c.launchers {
|
|
for launcher in launchers {
|
|
self.launcher_manager.add(&launcher);
|
|
}
|
|
}
|
|
for iwad in get_wads_in_folder(&c.iwads_folder) {
|
|
self.iwad_manager.add(&iwad);
|
|
}
|
|
if let Some(pwad_folder) = &c.pwads_folder {
|
|
for pwad in get_wads_in_folder(pwad_folder) {
|
|
self.pwad_manager.add(&pwad)
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
println!("{:?}", e);
|
|
}
|
|
};
|
|
}
|
|
|
|
fn launch_doom(&self) {
|
|
match self.command_manager.generate_command() {
|
|
Err(e) => {
|
|
let text = match e {
|
|
CommandErrors::NoIwad => "an IWAD",
|
|
CommandErrors::NoLauncher => "a launcher",
|
|
};
|
|
MessageDialog::new()
|
|
.set_type(MessageType::Error)
|
|
.set_title("I can't let you do that")
|
|
.set_text(&format!("You didn't pick {}!\nPlease do that", text))
|
|
.show_alert()
|
|
.unwrap();
|
|
}
|
|
Ok((launcher, command)) => {
|
|
// Note to self, don't hit launch button when running from emacs
|
|
// if you do, close it and hold down C+g
|
|
let result = Command::new(launcher).args(command).spawn();
|
|
match result {
|
|
Err(e) => panic!("{}", e),
|
|
Ok(_o) => (),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn launcher_and_iwad(&self) -> Result<(&LauncherInfo, &WadInfo), CommandErrors> {
|
|
let launcher = match self.launcher_manager.get_current() {
|
|
Some(l) => l,
|
|
None => {
|
|
return Err(CommandErrors::NoLauncher);
|
|
}
|
|
};
|
|
let iwad = match self.iwad_manager.get_current() {
|
|
Some(iwad) => iwad,
|
|
None => {
|
|
return Err(CommandErrors::NoIwad);
|
|
}
|
|
};
|
|
Ok((launcher, iwad))
|
|
}
|
|
}
|
|
|
|
impl eframe::App for RustDoomLauncher {
|
|
fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
|
|
if !self.config_tried {
|
|
self.get_config_file_stuff();
|
|
self.config_tried = true;
|
|
};
|
|
egui::containers::panel::CentralPanel::default().show(ctx, |ui| {
|
|
ui.horizontal(|ui| {
|
|
ui.heading("RustDoomLauncher");
|
|
let button = match self.launcher_and_iwad() {
|
|
Err(_) => egui::Button::new("PLAY SOME DOOM!"),
|
|
Ok((_, _)) => egui::Button::new("PLAY SOME DOOM!").fill(Color32::DARK_GREEN),
|
|
};
|
|
if ui.add(button).clicked() {
|
|
self.launch_doom();
|
|
}
|
|
if ui.button("Add WAD or Launcher").clicked() {
|
|
self.add_stuff_window_displayed = true;
|
|
}
|
|
});
|
|
ui.horizontal(|ui| {
|
|
ui.vertical(|ui| {
|
|
ui.set_max_width(100.0);
|
|
ui.label("Launchers");
|
|
let mut remove_pos: Option<usize> = None;
|
|
let mut add_pos: Option<usize> = None;
|
|
for (launcher, pos, selected) in self
|
|
.launcher_manager
|
|
.iter_selectable_with_pos_and_selected()
|
|
{
|
|
ui.horizontal(|ui| {
|
|
if ui
|
|
.add(egui::SelectableLabel::new(selected, &launcher.name))
|
|
.clicked()
|
|
{
|
|
add_pos = Some(pos);
|
|
}
|
|
if ui.button("❌").clicked() {
|
|
remove_pos = Some(pos);
|
|
}
|
|
});
|
|
}
|
|
// I'm unsure whether there's a better way to do this.
|
|
// The iterator call is a mutable borrow - thus compiler doesn't let me
|
|
// do a mutable thing in the middle of that, which I guess is fair enough,
|
|
// but I would like to break out of the loop as soon as that occurs...
|
|
// Completely unsure
|
|
if let Some(rp) = remove_pos {
|
|
self.launcher_manager.remove_selectable(rp);
|
|
if self.launcher_manager.get_current().is_none() {
|
|
self.command_manager.remove_launcher();
|
|
}
|
|
}
|
|
if let Some(ap) = add_pos {
|
|
self.launcher_manager.set_current(ap);
|
|
self.command_manager
|
|
.add_launcher(self.launcher_manager.get_current().unwrap())
|
|
}
|
|
ui.separator();
|
|
ui.label("IWADs");
|
|
let mut remove_pos: Option<usize> = None;
|
|
let mut add_pos: Option<usize> = None;
|
|
for (iwad, pos, selected) in
|
|
self.iwad_manager.iter_selectable_with_pos_and_selected()
|
|
{
|
|
ui.horizontal(|ui| {
|
|
if ui
|
|
.add(egui::SelectableLabel::new(selected, &iwad.name))
|
|
.clicked()
|
|
{
|
|
add_pos = Some(pos);
|
|
}
|
|
if ui.button("❌").clicked() {
|
|
remove_pos = Some(pos);
|
|
}
|
|
});
|
|
}
|
|
if let Some(rp) = remove_pos {
|
|
self.iwad_manager.remove_selectable(rp);
|
|
if self.launcher_manager.get_current().is_none() {
|
|
self.command_manager.remove_launcher();
|
|
}
|
|
}
|
|
if let Some(ap) = add_pos {
|
|
self.iwad_manager.set_current(ap);
|
|
self.command_manager
|
|
.add_iwad(self.iwad_manager.get_current().unwrap());
|
|
}
|
|
});
|
|
ui.separator();
|
|
ui.vertical(|ui| {
|
|
ui.set_min_width(100.0);
|
|
ui.label("PWADs");
|
|
let mut remove_pos: Option<usize> = None;
|
|
let mut add_pos: Option<usize> = None;
|
|
for (pwad, pos, selected) in
|
|
self.pwad_manager.iter_selectable_with_pos_and_selected()
|
|
{
|
|
ui.horizontal(|ui| {
|
|
if ui
|
|
.add(egui::SelectableLabel::new(selected, &pwad.name))
|
|
.clicked()
|
|
{
|
|
add_pos = Some(pos);
|
|
}
|
|
if ui.button("❌").clicked() {
|
|
remove_pos = Some(pos);
|
|
}
|
|
});
|
|
}
|
|
/*
|
|
if let Some(rp) = remove_pos {
|
|
self.pwad_manager.remove_selectable(rp);
|
|
self.command_manager
|
|
.add_pwads(&self.pwad_manager.get_current())
|
|
}
|
|
*/
|
|
if let Some(ap) = add_pos {
|
|
self.pwad_manager.set_current(ap);
|
|
self.command_manager
|
|
.add_pwads(&self.pwad_manager.get_current())
|
|
}
|
|
|
|
});
|
|
});
|
|
ui.separator();
|
|
ui.horizontal_wrapped(|ui| {
|
|
ui.horizontal(|ui| {
|
|
ui.set_max_width(180.0);
|
|
let warp_label = ui.label("warp");
|
|
let r = ui
|
|
.text_edit_singleline(&mut self.command_manager.warp)
|
|
.labelled_by(warp_label.id);
|
|
if r.changed() {
|
|
self.command_manager.update_command();
|
|
}
|
|
});
|
|
ui.separator();
|
|
ui.horizontal(|ui| {
|
|
ui.horizontal(|ui| {
|
|
ui.label("difficulty");
|
|
eframe::egui::ComboBox::new("difficulty", "")
|
|
.selected_text(format!("{}", self.command_manager.difficulty))
|
|
.width(140.0)
|
|
.show_ui(ui, |ui| {
|
|
for diff in Difficulty::iterator() {
|
|
let r = ui.selectable_value(
|
|
&mut self.command_manager.difficulty,
|
|
*diff,
|
|
diff.to_string(),
|
|
);
|
|
if r.clicked() {
|
|
self.command_manager.update_command();
|
|
}
|
|
}
|
|
});
|
|
});
|
|
ui.separator();
|
|
ui.horizontal(|ui| {
|
|
ui.label("fast");
|
|
let r = ui.add(egui::Checkbox::without_text(
|
|
&mut self.command_manager.fast_monsters,
|
|
));
|
|
if r.clicked() {
|
|
self.command_manager.update_command();
|
|
}
|
|
});
|
|
ui.separator();
|
|
ui.horizontal(|ui| {
|
|
ui.label("respawn");
|
|
let r = ui.add(egui::Checkbox::without_text(
|
|
&mut self.command_manager.respawning_monsters,
|
|
));
|
|
if r.clicked() {
|
|
self.command_manager.update_command();
|
|
}
|
|
});
|
|
});
|
|
});
|
|
ui.separator();
|
|
ui.horizontal(|ui| {
|
|
ui.label("Command");
|
|
ui.add(egui::Checkbox::without_text(&mut self.display_command));
|
|
});
|
|
ui.horizontal_wrapped(|ui| {
|
|
if let Some(l) = self.launcher_manager.get_current() {
|
|
if ui.add(egui::SelectableLabel::new(false, &l.name)).clicked() {
|
|
self.launcher_manager.remove_current();
|
|
self.command_manager.remove_launcher();
|
|
}
|
|
} else {
|
|
ui.label("Select a launcher plz");
|
|
}
|
|
|
|
if let Some(iwad) = self.iwad_manager.get_current() {
|
|
if ui
|
|
.add(egui::SelectableLabel::new(false, &iwad.name))
|
|
.clicked()
|
|
{
|
|
self.iwad_manager.remove_current();
|
|
self.command_manager.remove_iwad();
|
|
}
|
|
} else {
|
|
ui.label("Select an iwad plz");
|
|
}
|
|
let mut remove: Option<usize> = None;
|
|
for (pos, pwad) in self.pwad_manager.get_current().iter().enumerate() {
|
|
if ui
|
|
.add(egui::SelectableLabel::new(false, &pwad.name))
|
|
.clicked()
|
|
{
|
|
remove = Some(pos);
|
|
break;
|
|
}
|
|
}
|
|
if let Some(r) = remove {
|
|
self.pwad_manager.remove_current(r);
|
|
self.command_manager
|
|
.add_pwads(&self.pwad_manager.get_current())
|
|
}
|
|
});
|
|
if self.display_command {
|
|
ui.horizontal(|ui| {
|
|
let mut text = self.command_manager.command_string.clone();
|
|
let window_size = frame.info().window_info.size;
|
|
ui.add(egui::TextEdit::multiline(&mut text).desired_width(window_size[0]));
|
|
});
|
|
}
|
|
});
|
|
|
|
egui::Window::new("Add WAD or Launcher")
|
|
.open(&mut self.add_stuff_window_displayed)
|
|
.show(ctx, |ui| {
|
|
ui.horizontal(|ui| {
|
|
let name_label = ui.label("Name");
|
|
ui.text_edit_singleline(&mut self.add_name)
|
|
.labelled_by(name_label.id);
|
|
});
|
|
ui.horizontal(|ui| {
|
|
ui.label("Path");
|
|
ui.label(
|
|
self.selected_file_path
|
|
.clone()
|
|
.into_os_string()
|
|
.into_string()
|
|
.unwrap(),
|
|
);
|
|
if ui.button("Find").clicked() {
|
|
if let Some(path) = rfd::FileDialog::new().pick_file() {
|
|
self.selected_file_path = path;
|
|
}
|
|
}
|
|
});
|
|
ui.horizontal(|ui| {
|
|
ui.label("What sort of file is it?");
|
|
if ui
|
|
.add(egui::SelectableLabel::new(
|
|
self.selected_file_type == FileType::Launcher,
|
|
"Launcher",
|
|
))
|
|
.clicked()
|
|
{
|
|
self.selected_file_type = FileType::Launcher
|
|
}
|
|
if ui
|
|
.add(egui::SelectableLabel::new(
|
|
self.selected_file_type == FileType::Iwad,
|
|
"IWAD",
|
|
))
|
|
.clicked()
|
|
{
|
|
self.selected_file_type = FileType::Iwad
|
|
}
|
|
if ui
|
|
.add(egui::SelectableLabel::new(
|
|
self.selected_file_type == FileType::Pwad,
|
|
"PWAD",
|
|
))
|
|
.clicked()
|
|
{
|
|
self.selected_file_type = FileType::Pwad
|
|
}
|
|
});
|
|
if ui.button("Add!").clicked() {
|
|
if self.add_name.is_empty() || self.selected_file_path.as_os_str().is_empty() {
|
|
return;
|
|
}
|
|
let info_text = get_summary(&self.selected_file_path);
|
|
match self.selected_file_type {
|
|
FileType::Iwad => {
|
|
self.iwad_manager.add(&WadInfo {
|
|
name: self.add_name.clone(),
|
|
path: self.selected_file_path.clone(),
|
|
info_text: Some(
|
|
"I'm sure you know what's in that bloody IWAD!".to_string(),
|
|
),
|
|
});
|
|
}
|
|
FileType::Pwad => {
|
|
self.pwad_manager.add(&WadInfo {
|
|
name: self.add_name.clone(),
|
|
path: self.selected_file_path.clone(),
|
|
info_text: info_text,
|
|
});
|
|
}
|
|
FileType::Launcher => {
|
|
self.launcher_manager.add(&LauncherInfo {
|
|
name: self.add_name.clone(),
|
|
path: self.selected_file_path.clone(),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
ctx.input(|i| {
|
|
if !i.raw.dropped_files.is_empty() {
|
|
let dropped_files = i.raw.dropped_files.clone();
|
|
match dropped_files.len() {
|
|
1 => {
|
|
self.selected_file_path = dropped_files[0].path.clone().unwrap();
|
|
self.add_stuff_window_displayed = true;
|
|
}
|
|
_ => {
|
|
MessageDialog::new()
|
|
.set_type(MessageType::Error)
|
|
.set_title("I can't let you do that")
|
|
.set_text(&format!("Multiple files not supported"))
|
|
.show_alert()
|
|
.unwrap();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|