179 lines
5 KiB
Rust
179 lines
5 KiB
Rust
#![feature(proc_macro_hygiene)]
|
|
|
|
extern crate serde;
|
|
#[macro_use]
|
|
extern crate serde_derive;
|
|
extern crate serde_json;
|
|
|
|
extern crate async_std;
|
|
extern crate futures;
|
|
extern crate mozaic;
|
|
extern crate rand;
|
|
|
|
extern crate tracing;
|
|
extern crate tracing_futures;
|
|
extern crate tracing_subscriber;
|
|
|
|
#[macro_use]
|
|
extern crate rocket;
|
|
extern crate rocket_contrib;
|
|
|
|
use tracing_subscriber::{EnvFilter, FmtSubscriber};
|
|
|
|
use std::net::SocketAddr;
|
|
use std::{env, time};
|
|
|
|
use mozaic::modules::types::*;
|
|
use mozaic::modules::{game, StepLock};
|
|
|
|
use futures::executor::ThreadPool;
|
|
use futures::future::FutureExt;
|
|
|
|
use mozaic::graph;
|
|
use mozaic::modules::*;
|
|
|
|
mod planetwars;
|
|
mod routes;
|
|
mod util;
|
|
|
|
use rocket_contrib::templates::{Template, Engines};
|
|
use rocket_contrib::templates::tera::{self, Value};
|
|
|
|
use std::collections::HashMap;
|
|
|
|
const COLOURS: [&'static str; 9] = ["grey", "blue", "cyan", "green", "yellow", "orange", "red", "pink", "purple"];
|
|
|
|
fn calc_viewbox(value: Value, _: HashMap<String, Value>) -> tera::Result<Value> {
|
|
let mut min_x = std::f64::MAX;
|
|
let mut min_y = std::f64::MAX;
|
|
let mut max_x = std::f64::MIN;
|
|
let mut max_y = std::f64::MIN;
|
|
for v in value.as_array().unwrap() {
|
|
let x = v.get("x").and_then(|v| v.as_f64()).unwrap();
|
|
let y = v.get("y").and_then(|v| v.as_f64()).unwrap();
|
|
if x < min_x { min_x = x; }
|
|
if x > max_x { max_x = x; }
|
|
if y < min_y { min_y = y; }
|
|
if y > max_y { max_y = y; }
|
|
}
|
|
|
|
return Ok(Value::String(format!("{} {} {} {}", min_x - 3., min_y - 3., (max_x - min_x) + 6., (max_y - min_y) + 6.)));
|
|
}
|
|
|
|
fn get_colour(value: Value, _: HashMap<String, Value>) -> tera::Result<Value> {
|
|
return Ok(Value::String(COLOURS[value.as_u64().unwrap_or(0) as usize].to_string()));
|
|
}
|
|
|
|
fn main() {
|
|
let mut routes = Vec::new();
|
|
routes::fuel(&mut routes);
|
|
|
|
let tera = Template::custom(|engines: &mut Engines| {
|
|
engines.tera.register_filter("calc_viewbox", calc_viewbox);
|
|
engines.tera.register_filter("get_colour", get_colour);
|
|
});
|
|
|
|
rocket::ignite()
|
|
.attach(tera)
|
|
.mount("/", routes)
|
|
.launch()
|
|
.unwrap();
|
|
}
|
|
|
|
// // Load the config and start the game.
|
|
// #[async_std::main]
|
|
// async fn main() {
|
|
// let args: Vec<String> = env::args().collect();
|
|
// let name = args[0].clone();
|
|
// match run(args).await {
|
|
// None => print_info(&name),
|
|
// _ => {}
|
|
// };
|
|
// }
|
|
|
|
fn build_builder(
|
|
pool: ThreadPool,
|
|
number_of_clients: u64,
|
|
max_turns: u64,
|
|
map: &str,
|
|
location: &str,
|
|
) -> game::Builder<planetwars::PlanetWarsGame> {
|
|
let config = planetwars::Config {
|
|
map_file: map.to_string(),
|
|
max_turns: max_turns,
|
|
};
|
|
|
|
let game =
|
|
planetwars::PlanetWarsGame::new(config.create_game(number_of_clients as usize), location);
|
|
|
|
let players: Vec<PlayerId> = (0..number_of_clients).collect();
|
|
|
|
game::Builder::new(players.clone(), game).with_step_lock(
|
|
StepLock::new(players.clone(), pool.clone())
|
|
.with_timeout(std::time::Duration::from_secs(1)),
|
|
)
|
|
}
|
|
|
|
async fn run(args: Vec<String>) -> Option<()> {
|
|
let fut = graph::set_default();
|
|
|
|
let sub = FmtSubscriber::builder()
|
|
.with_env_filter(EnvFilter::from_default_env())
|
|
.finish();
|
|
tracing::subscriber::set_global_default(sub).unwrap();
|
|
|
|
let addr = "127.0.0.1:9142".parse::<SocketAddr>().unwrap();
|
|
|
|
let map = args.get(1)?;
|
|
let number_of_clients = args
|
|
.get(2)
|
|
.map(|x| x.parse().expect("Client number should be a number"))
|
|
.unwrap_or(1);
|
|
let location = args.get(3).map(|x| x.as_str()).unwrap_or("game.json");
|
|
let max_turns: u64 = args
|
|
.get(4)
|
|
.map(|x| x.parse().expect("Max turns should be a number"))
|
|
.unwrap_or(500);
|
|
|
|
let pool = ThreadPool::new().ok()?;
|
|
pool.spawn_ok(fut.map(|_| ()));
|
|
|
|
let (gmb, handle) = game::Manager::builder(pool.clone());
|
|
let ep = TcpEndpoint::new(addr, pool.clone());
|
|
let gmb = gmb.add_endpoint(ep, "TCP endpoint");
|
|
let mut gm = gmb.build();
|
|
|
|
let game_builder = build_builder(pool.clone(), number_of_clients, max_turns, map, location);
|
|
std::thread::sleep(time::Duration::from_millis(3000));
|
|
|
|
let mut current_game = gm.start_game(game_builder).await.unwrap();
|
|
|
|
// loop {
|
|
// match gm.get_state(current_game).await {
|
|
// None => {
|
|
// println!("Game finished, let's play a new one");
|
|
// let game_builder =
|
|
// build_builder(pool.clone(), number_of_clients, max_turns, map, location);
|
|
// current_game = gm.start_game(game_builder).await.unwrap();
|
|
// }
|
|
// Some(state) => {
|
|
// println!("{:?}", state);
|
|
// }
|
|
// }
|
|
// std::thread::sleep(time::Duration::from_millis(3000));
|
|
// }
|
|
|
|
handle.await;
|
|
|
|
std::thread::sleep(time::Duration::from_millis(100));
|
|
|
|
Some(())
|
|
}
|
|
|
|
// fn print_info(name: &str) {
|
|
// println!(
|
|
// "Usage: {} map_location [number_of_clients [output [max_turns]]]",
|
|
// name
|
|
// );
|
|
// }
|