/*
    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 <https://www.gnu.org/licenses/>.

*/
#![feature(
    if_let_guard,
    map_many_mut,
    let_chains,
    iterator_try_collect,
    isqrt,
    trait_upcasting,
    stmt_expr_attributes
)]
pub mod commands;
pub mod data;
pub mod entity;
pub mod interaction;
pub mod network;
pub mod scoreboard;
pub mod server;
pub mod state;

use hurrycurry_protocol::{glam::Vec2, Message};

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ConnectionID(pub i64);

pub trait InterpolateExt {
    fn exp_to(&mut self, target: Self, dt: f32);
}
impl InterpolateExt for Vec2 {
    fn exp_to(&mut self, target: Self, dt: f32) {
        self.x = target.x + (self.x - target.x) * (-dt).exp();
        self.y = target.y + (self.y - target.y) * (-dt).exp();
    }
}
impl InterpolateExt for f32 {
    fn exp_to(&mut self, target: Self, dt: f32) {
        *self = target + (*self - target) * (-dt).exp();
    }
}

#[macro_export]
macro_rules! trm {
    ($id:literal $(, $typ:ident = $param:expr)*) => {
        hurrycurry_protocol::Message::Translation {
            id: $id.to_owned(),
            params: vec![$(crate::trm_param!($typ, $param)),*]
        }
    };
}

#[macro_export]
macro_rules! trm_param {
    (s, $x:expr) => {
        hurrycurry_protocol::Message::Text($x)
    };
    (i, $x:expr) => {
        hurrycurry_protocol::Message::Item($x)
    };
    (t, $x:expr) => {
        hurrycurry_protocol::Message::Tile($x)
    };
    (m, $x:expr) => {
        $x
    };
}

#[derive(Debug)]
pub struct TrError {
    pub id: &'static str,
    pub params: Vec<Message>,
}
impl From<TrError> for Message {
    fn from(value: TrError) -> Self {
        Self::Translation {
            id: value.id.to_owned(),
            params: value.params,
        }
    }
}

#[macro_export]
macro_rules! tre {
    ($id:literal $(, $typ:ident = $param:expr)*) => {
        crate::TrError {
            id: $id,
            params: vec![$(crate::tre_param!($typ, $param)),*]
        }
    };
}

#[macro_export]
macro_rules! tre_param {
    (s, $x:expr) => {
        hurrycurry_protocol::Message::Text($x)
    };
    (i, $x:expr) => {
        hurrycurry_protocol::Message::Item($x)
    };
    (t, $x:expr) => {
        hurrycurry_protocol::Message::Tile($x)
    };
    (m, $x:expr) => {
        $x
    };
}