#![feature(exit_status_error)]
use colored::Colorize;
use notify::{Event, EventKind, RecursiveMode, Watcher};
use std::env::{args, var};
use std::fs;
use std::io::{stdout, Cursor, Write};
use std::path::{Path, PathBuf};
use std::process::{exit, Command};
use std::sync::mpsc;
use std::sync::mpsc::TryRecvError;
use std::thread::sleep;
use std::time::{Duration, Instant};
use tiny_http::{Response, Server, StatusCode};
use wasm_pack::command::build::{BuildOptions, Target};
use wasm_pack::command::run_wasm_pack;
use wasm_pack::progressbar::LogLevel;
fn workspace_dir() -> PathBuf {
let output = std::process::Command::new(env!("CARGO"))
.arg("locate-project")
.arg("--workspace")
.arg("--message-format=plain")
.output()
.unwrap()
.stdout;
let cargo_path = Path::new(std::str::from_utf8(&output).unwrap().trim());
cargo_path.parent().unwrap().to_path_buf()
}
fn build_client() -> anyhow::Result<()> {
let cli = wasm_pack::Cli {
cmd: wasm_pack::command::Command::Build(BuildOptions {
path: Some(workspace_dir().join("crates/client")),
scope: None,
mode: Default::default(),
disable_dts: false,
weak_refs: false,
reference_types: false,
target: Target::Web,
debug: false,
dev: false,
release: false,
profiling: false,
out_dir: "pkg".to_string(),
out_name: None,
no_pack: false,
no_opt: true,
extra_options: vec![],
}),
verbosity: 0,
quiet: true,
log_level: LogLevel::Error,
};
run_wasm_pack(cli.cmd)
}
fn try_build_client() -> bool {
match build_client() {
Ok(_) => {
println!(
"{} -- Client package built successfully",
"✓ Success".green().bold()
);
true
}
Err(e) => {
eprintln!(
"{} -- Client package failed to build: {}",
"✗ Failed".red().bold(),
e
);
false
}
}
}
fn start_server() {
let bind = var("BIND").unwrap_or("[::]:8000".to_string());
let server = Server::http(&bind).unwrap();
println!("{} on {bind}", "✓ Listening".magenta().bold());
for req in server.incoming_requests() {
let mut path = Path::new(req.url());
if path == Path::new("/") {
path = Path::new("/index.html");
}
let path = path.strip_prefix(Path::new("/")).unwrap();
let full_path = workspace_dir().join("crates/unified").join(path);
let content = match fs::read(full_path.clone()) {
Ok(r) => r,
Err(_) => {
let _ = req.respond(Response::new(
StatusCode::from(404),
vec![],
Cursor::new(vec![]),
None,
None,
));
continue;
}
};
let len = content.len();
let header = tiny_http::Header::from_bytes(
&b"Content-Type"[..],
if full_path.to_str().unwrap().ends_with(".html") {
&b"text/html"[..]
} else if full_path.to_str().unwrap().ends_with(".js") {
&b"text/javascript"[..]
} else if full_path.to_str().unwrap().ends_with(".wasm") {
&b"application/wasm"[..]
} else {
&b"application/octet-stream"[..]
},
)
.unwrap();
let response = Response::new(
StatusCode::from(200),
vec![header],
Cursor::new(content),
Some(len),
None,
);
let _ = req.respond(response);
}
}
fn main() {
let mut args = args();
let subcommand = args.nth(1).unwrap();
match subcommand.as_str() {
"hp:unified:native" => {
let asset_dir = workspace_dir().join("crates/unified/");
Command::new("dx")
.args([
"serve",
"--package",
"starkingdoms",
"--hot-patch",
"--features",
"bevy/hotpatching",
"--features",
"native",
"--features",
"bevy/dynamic_linking",
"--args",
&args.collect::<Vec<_>>().join(" ")
])
.env("BEVY_ASSET_ROOT", asset_dir.to_string_lossy().to_string())
.env("RUST_LOG", "info,starkingdoms=trace")
.spawn()
.unwrap()
.wait()
.unwrap();
},
"client" => {
if !try_build_client() {
exit(1);
}
}
"watch" | "serve" => {
let serve = subcommand == "serve";
if serve {
std::thread::spawn(start_server);
}
//try_build_client();
let (tx, rx) = mpsc::channel::<notify::Result<Event>>();
// Use recommended_watcher() to automatically select the best implementation
// for your platform. The `EventHandler` passed to this constructor can be a
// closure, a `std::sync::mpsc::Sender`, a `crossbeam_channel::Sender`, or
// another type the trait is implemented for.
let mut watcher = notify::recommended_watcher(tx).unwrap();
// Add a path to be watched. All files and directories at that path and
// below will be monitored for changes.
watcher
.watch(&workspace_dir().join("crates"), RecursiveMode::Recursive)
.unwrap();
println!("{}", "[Watch] 🛈 Watching for file changes".blue().bold());
// Block forever, printing out events as they come in
let mut needs_rebuild = false;
loop {
let res = rx.try_recv();
let res = match res {
Ok(r) => r,
Err(TryRecvError::Empty) => {
if needs_rebuild {
// wait 1s then check again, then rebuild
sleep(Duration::from_secs(1));
if let Ok(r) = rx.try_recv() {
r
} else {
try_build_client();
needs_rebuild = false;
rx.recv().unwrap()
}
} else {
rx.recv().unwrap()
}
}
Err(TryRecvError::Disconnected) => panic!("{:?}", TryRecvError::Disconnected),
};
match res {
Ok(event) => {
if let EventKind::Modify(_) = event.kind {
for path in &event.paths {
if !path.to_str().unwrap().contains("client/pkg")
&& !path.to_str().unwrap().ends_with("~")
{
needs_rebuild = true;
}
}
}
}
Err(e) => {
eprintln!(
"{} -- Error watching for files: {}",
"[Watch] ✗ Error".red().bold(),
e
);
}
}
}
}
"asset:process" => {
// png-ify textures
let paths =
fs::read_dir(workspace_dir().join("crates/unified/assets/vector_textures/"))
.unwrap();
let output_dir = workspace_dir().join("crates/unified/assets/textures/");
for path in paths {
let path = path.unwrap().path();
let Some(extension) = path.extension() else {
continue;
};
if extension != "svg" {
continue;
}
let Some(filename) = path.file_stem() else {
continue;
};
print!("[{}] {}.svg", ">".blue(), filename.to_string_lossy());
stdout().flush().unwrap();
let start = Instant::now();
let tree = {
let mut opt = resvg::usvg::Options {
resources_dir: std::fs::canonicalize(&path)
.ok()
.and_then(|p| p.parent().map(|p| p.to_path_buf())),
..resvg::usvg::Options::default()
};
opt.fontdb_mut().load_system_fonts();
let svg_data = std::fs::read(&path).unwrap();
resvg::usvg::Tree::from_data(&svg_data, &opt).unwrap()
};
let pixmap_size = tree.size().to_int_size();
let mut pixmap =
resvg::tiny_skia::Pixmap::new(pixmap_size.width(), pixmap_size.height())
.unwrap();
resvg::render(
&tree,
resvg::tiny_skia::Transform::default(),
&mut pixmap.as_mut(),
);
pixmap
.save_png(output_dir.join(format!("{}.png", filename.to_string_lossy())))
.unwrap();
println!(
" {} {}.png {} {}",
"-->".dimmed(),
filename.to_string_lossy(),
"✓ success".green(),
format!("{}ms", start.elapsed().as_millis()).dimmed()
);
}
}
"unified:web" => {
let start = Instant::now();
let target = workspace_dir().join("target/");
let unified = workspace_dir().join("crates/unified/");
exec("cargo", "build --package starkingdoms --target wasm32-unknown-unknown -F wasm --no-default-features");
let wasm_file = target.join("wasm32-unknown-unknown/debug/starkingdoms.wasm");
exec(
"wasm-bindgen",
format!(
"--target web --typescript --out-dir {} {}",
unified.join("web/").display(),
wasm_file.display()
)
.as_str(),
);
println!(
"{} {} {}",
"-->".dimmed(),
"✓ done".green(),
format!("{}ms", start.elapsed().as_millis()).dimmed()
);
}
"unified:web:release" => {
let start = Instant::now();
let target = workspace_dir().join("target/");
let unified = workspace_dir().join("crates/unified/");
exec("cargo", "build --package starkingdoms --lib --target wasm32-unknown-unknown -F wasm --no-default-features --profile wasm-release");
let wasm_file = target.join("wasm32-unknown-unknown/wasm-release/starkingdoms.wasm");
exec(
"wasm-bindgen",
format!(
"--target web --typescript --out-dir {} {}",
unified.join("web/").display(),
wasm_file.display()
)
.as_str(),
);
exec(
"wasm-opt",
format!(
"-Oz -d {} -o {}",
unified.join("web/starkingdoms_bg.wasm").display(),
unified.join("web/starkingdoms_bg.wasm").display()
)
.as_str(),
);
println!(
"{} {} {}",
"-->".dimmed(),
"✓ done".green(),
format!("{}ms", start.elapsed().as_millis()).dimmed()
);
}
_ => panic!("unsupported command"),
}
}
fn exec(program: &str, args: &str) {
println!("[{}] {} {}", "+".blue(), program, args);
Command::new(program)
.args(args.split(" ").collect::<Vec<&str>>())
.spawn()
.unwrap()
.wait()
.unwrap()
.exit_ok().unwrap();
}