dandadan/src/main.rs

#[macro_use]
extern crate rocket;
mod game;
use game::GameState;
use game::Player;
use rocket::fs::{relative, FileServer};
use rocket::response::content;
use rocket::response::status::BadRequest;
use rocket::State;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use uuid::{uuid, Uuid};

#[get("/")]
fn index(player_uuids: &State<PlayerUuids>) -> content::RawHtml<String> {
    content::RawHtml(format!(
        "<a href=\"localhost:8000/{}/\">localhost:8000/{}</a><br /><a href=\"localhost:8000/{}/\">localhost:8000/{}</a>",
        player_uuids.a, player_uuids.a, player_uuids.b, player_uuids.b
   ))
}

#[get("/get_events")]
fn get_events(game_state_arc: &State<ArcMutexGameState>) -> String {
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let game_state = game_state_mutex.lock().unwrap();
    format!("{}", game::get_events(&game_state))
}

#[post("/<uuid>/shuffle")]
fn shuffle(
    uuid: Uuid,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    game::shuffle(&mut game_state, player.clone());
    Ok(format!("Deck Shuffled!"))
}

#[get("/<uuid>/pass")]
fn pass(
    uuid: Uuid,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    match player_uuids.map.get(&uuid) {
        Some(_) => (),
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::pass(&mut game_state);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/bounce/<play_id>")]
fn bounce(
    uuid: Uuid,
    play_id: Uuid,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    match player_uuids.map.get(&uuid) {
        Some(_) => (),
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::bounce(&mut game_state, play_id);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/move/<play_id>/<x>/<y>")]
fn move_card(
    uuid: Uuid,
    play_id: Uuid,
    x: u8,
    y: u8,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    match player_uuids.map.get(&uuid) {
        Some(_) => (),
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::move_played_card(&mut game_state, play_id, x, y);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/tap/<play_id>")]
fn tap(
    uuid: Uuid,
    play_id: Uuid,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    match player_uuids.map.get(&uuid) {
        Some(_) => (),
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::tap(&mut game_state, play_id);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/play/<index>")]
fn play(
    uuid: Uuid,
    index: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::play_from_hand(&mut game_state, index, player.clone());
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/unkill/<index>")]
fn unkill(
    uuid: Uuid,
    index: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::unkill(&mut game_state, player.clone(), index, false);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/unbanish/<index>")]
fn unbanish(
    uuid: Uuid,
    index: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::unkill(&mut game_state, player.clone(), index, true);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/discard/<index>")]
fn discard(
    uuid: Uuid,
    index: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::discard(&mut game_state, index, player.clone(), false);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/forget/<index>")]
fn forget(
    uuid: Uuid,
    index: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::discard(&mut game_state, index, player.clone(), true);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/kill/<play_id>")]
fn kill(
    uuid: Uuid,
    play_id: Uuid,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    match player_uuids.map.get(&uuid) {
        Some(_) => (),
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::kill(&mut game_state, play_id, false);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/banish/<play_id>")]
fn banish(
    uuid: Uuid,
    play_id: Uuid,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    match player_uuids.map.get(&uuid) {
        Some(_) => (),
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::kill(&mut game_state, play_id, true);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/unshadow/<index>")]
fn unshadow(
    uuid: Uuid,
    index: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    match player_uuids.map.get(&uuid) {
        Some(_) => (),
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::transfer_dead_card(&mut game_state, index, true);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/undiscard/<index>")]
fn undiscard(
    uuid: Uuid,
    index: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::undiscard(&mut game_state, index, player.clone(), false);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/remember/<index>")]
fn remember(
    uuid: Uuid,
    index: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::undiscard(&mut game_state, index, player.clone(), true);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/shadow/<index>")]
fn shadow(
    uuid: Uuid,
    index: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    match player_uuids.map.get(&uuid) {
        Some(_) => (),
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    game::transfer_dead_card(&mut game_state, index, false);
    Ok(format!("{}", game::get_events(&game_state)))
}

#[get("/<uuid>/get_state")]
fn get_state(
    uuid: Uuid,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let game_state = game_state_mutex.lock().unwrap();
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    Ok(format!(
        "{}",
        game::get_game_one_player(&game_state, player.clone())
    ))
}

#[get("/<uuid>/draw/<count>")]
fn draw(
    uuid: Uuid,
    count: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    game::draw(&mut game_state, count, player.clone());
    Ok(format!(
        "{}",
        game::get_game_one_player(&game_state, player.clone())
    ))
}

#[get("/<uuid>/fade/<index>")]
fn fade(
    uuid: Uuid,
    index: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    game::fade_from_hand(&mut game_state, index, player.clone(), false);
    Ok(format!(
        "{}",
        game::get_game_one_player(&game_state, player.clone())
    ))
}

#[get("/<uuid>/fade-bottom/<index>")]
fn fade_bottom(
    uuid: Uuid,
    index: usize,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    game::fade_from_hand(&mut game_state, index, player.clone(), true);
    Ok(format!(
        "{}",
        game::get_game_one_player(&game_state, player.clone())
    ))
}

#[get("/<uuid>/life/<count>")]
fn life(
    uuid: Uuid,
    count: i32,
    game_state_arc: &State<ArcMutexGameState>,
    player_uuids: &State<PlayerUuids>,
) -> Result<String, BadRequest<String>> {
    let game_state_mutex = Arc::clone(&game_state_arc.state);
    let mut game_state = game_state_mutex.lock().unwrap();
    let player = match player_uuids.map.get(&uuid) {
        Some(player) => player,
        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
    };
    game::change_life(&mut game_state, count, player.clone());
    Ok(format!(
        "{}",
        game::get_game_one_player(&game_state, player.clone())
    ))
}

struct ArcMutexGameState {
    state: Arc<Mutex<GameState>>,
}

struct PlayerUuids {
    a: Uuid,
    b: Uuid,
    map: HashMap<Uuid, Player>,
}

#[launch]
fn rocket() -> _ {
    let mut game_state = game::new();
    //game::draw(&mut game_state, 7, Player::A);
    //game::draw(&mut game_state, 7, Player::B);
    let game_state_arc = Arc::new(Mutex::new(game_state));

    #[cfg(debug_assertions)]
    let a_uuid: Uuid = uuid!("9b0a2a95-72a9-4e03-930e-a9583d2a2a5a");
    #[cfg(not(debug_assertions))]
    let a_uuid: Uuid = Uuid::new_v4();
    #[cfg(debug_assertions)]
    let b_uuid: Uuid = uuid!("2efc0332-975d-4f71-9dd0-ffc9213098a5");
    #[cfg(not(debug_assertions))]
    let b_uuid: Uuid = Uuid::new_v4();

    let uuid_map = HashMap::from([(a_uuid, Player::A), (b_uuid, Player::B)]);
    println!("A: {}", a_uuid);
    println!("B: {}", b_uuid);

    rocket::build()
        .mount("/", FileServer::from(relative!("web/static")).rank(0))
        .mount(
            format!("/{}/", a_uuid.hyphenated()),
            FileServer::from(relative!("web/dynamic")),
        )
        .mount(
            format!("/{}/", b_uuid.hyphenated()),
            FileServer::from(relative!("web/dynamic")),
        )
        .mount(
            "/",
            routes![
                index,
                get_events,
                get_state,
                draw,
                shuffle,
                pass,
                life,
                fade,
                fade_bottom,
                play,
                bounce,
                tap,
                move_card,
                discard,
                kill,
                forget,
                banish,
                unkill,
                unbanish,
                shadow,
                unshadow,
                undiscard,
                remember,
            ],
        )
        .manage(ArcMutexGameState {
            state: game_state_arc,
        })
        .manage(PlayerUuids {
            a: a_uuid,
            b: b_uuid,
            map: uuid_map,
        })
}