/*
Hurry Curry! - a game about cooking
Copyright 2024 metamuffin
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, version 3 of the License only.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
*/
use crate::{entity::bot::BotDriver, server::Server};
use anyhow::{anyhow, bail, Result};
use clap::{Parser, ValueEnum};
use hurrycurry_bot::algos::ALGO_CONSTRUCTORS;
use hurrycurry_protocol::{Message, PacketC, PlayerID};
use std::time::Duration;
#[derive(Parser)]
#[clap(multicall = true)]
enum Command {
/// Start a new game
Start {
/// Gamedata specification
#[arg(default_value = "junior")]
spec: String,
/// Duration in seconds
#[arg(default_value = "420")]
timer: u64,
},
/// Abort the current game
End,
/// Download recipe/map's source declaration
Download {
/// Resource kind
#[arg(value_enum)]
r#type: DownloadType,
/// Name
name: String,
},
/// List all recipes and maps
List,
/// Send an effect
Effect { name: String },
/// Send an item
Item { name: String },
/// Reload the resource index
ReloadIndex,
#[clap(alias = "summon-bot", alias = "spawn-bot")]
CreateBot { algo: String, name: Option },
/// Reload the current map
#[clap(alias = "r")]
Reload,
}
#[derive(ValueEnum, Clone)]
enum DownloadType {
Map,
Recipes,
}
impl Server {
pub async fn handle_command_parse(&mut self, player: PlayerID, command: &str) -> Result<()> {
for line in command.split("\n") {
self.handle_command(
player,
Command::try_parse_from(
shlex::split(line)
.ok_or(anyhow!("quoting invalid"))?
.into_iter(),
)?,
)
.await?;
}
Ok(())
}
async fn handle_command(&mut self, player: PlayerID, command: Command) -> Result<()> {
match command {
Command::Start { spec, timer } => {
let data = self.index.generate(&spec).await?;
self.load(data, Some(Duration::from_secs(timer)));
}
Command::End => {
self.tx
.send(PacketC::ServerMessage {
text: format!(
"Game was aborted by {}.",
self.game
.players
.get(&player)
.ok_or(anyhow!("player missing"))?
.name
),
})
.ok();
self.load(self.index.generate("lobby").await?, None);
}
Command::Reload => {
if self.count_chefs() > 1 {
bail!("must be at most one player to reload");
}
self.load(
self.index.generate(&self.game.data.current_map).await?,
None,
);
}
Command::ReloadIndex => {
self.index.reload().await?;
}
Command::Download { r#type, name } => {
let source = match r#type {
DownloadType::Map => self.index.read_map(&name).await,
DownloadType::Recipes => self.index.read_recipes(&name).await,
}?;
bail!("{source}");
}
Command::List => {
bail!(
"Maps: {:?}\nRecipes: {:?}",
self.index.maps.keys().collect::>(),
self.index.recipes
)
}
Command::Effect { name } => {
self.tx
.send(PacketC::Communicate {
player,
message: Some(Message::Effect(name)),
timeout: None,
})
.ok();
}
Command::Item { name } => {
let item = self
.game
.data
.get_item_by_name(&name)
.ok_or(anyhow!("unknown item"))?;
self.tx
.send(PacketC::Communicate {
player,
message: Some(Message::Item(item)),
timeout: None,
})
.ok();
}
Command::CreateBot { algo, name } => {
let (aname, cons) = ALGO_CONSTRUCTORS
.iter()
.find(|(name, _)| *name == algo.as_str())
.ok_or(anyhow!("algo name unknown"))?;
let algo = cons();
self.entities.push(Box::new(BotDriver::new(
format!("{}-bot", name.unwrap_or((*aname).to_owned())),
51,
algo,
)));
}
}
Ok(())
}
}