nil_core/world/

config.rs

// Copyright (C) Call of Nil contributors
// SPDX-License-Identifier: AGPL-3.0-only

use crate::error::AnyResult;
use crate::world::WorldOptions;
use bon::Builder;
use nil_util::{ClampNew, ConstDeref, F64Math};
use serde::{Deserialize, Serialize};
use std::ops::Deref;
use strum::EnumString;
use uuid::Uuid;

#[derive(Builder, Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
#[builder(builder_type(vis = "pub(crate)"))]
#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
pub struct WorldConfig {
  #[builder(start_fn, into)]
  name: WorldName,

  #[builder(skip)]
  id: WorldId,

  #[serde(default)]
  #[builder(default)]
  locale: Locale,

  #[serde(default)]
  #[builder(default)]
  allow_cheats: bool,

  #[serde(default)]
  #[builder(default, into)]
  speed: WorldSpeed,

  #[serde(default)]
  #[builder(default, into)]
  unit_speed: WorldUnitSpeed,

  #[serde(default)]
  #[builder(default, into)]
  bot_density: BotDensity,

  #[serde(default)]
  #[builder(default, into)]
  bot_advanced_start_ratio: BotAdvancedStartRatio,
}

impl WorldConfig {
  pub fn new(options: &WorldOptions) -> Self {
    Self {
      id: WorldId::new(),
      name: options.name.clone(),
      locale: options.locale.unwrap_or_default(),
      allow_cheats: options.allow_cheats.unwrap_or_default(),
      speed: options.speed.unwrap_or_default(),
      unit_speed: options.unit_speed.unwrap_or_default(),
      bot_density: options.bot_density.unwrap_or_default(),
      bot_advanced_start_ratio: options
        .bot_advanced_start_ratio
        .unwrap_or_default(),
    }
  }

  #[inline]
  pub fn id(&self) -> WorldId {
    self.id
  }

  #[inline]
  pub fn name(&self) -> WorldName {
    self.name.clone()
  }

  #[inline]
  pub fn locale(&self) -> Locale {
    self.locale
  }

  #[inline]
  pub fn are_cheats_allowed(&self) -> bool {
    self.allow_cheats
  }

  #[inline]
  pub fn speed(&self) -> WorldSpeed {
    self.speed
  }

  #[inline]
  pub fn unit_speed(&self) -> WorldUnitSpeed {
    self.unit_speed
  }

  #[inline]
  pub fn bot_density(&self) -> BotDensity {
    self.bot_density
  }

  #[inline]
  pub fn bot_advanced_start_ratio(&self) -> BotAdvancedStartRatio {
    self.bot_advanced_start_ratio
  }
}

#[derive(
  Clone,
  Copy,
  Debug,
  derive_more::Deref,
  derive_more::Display,
  PartialEq,
  Eq,
  PartialOrd,
  Ord,
  Hash,
  Deserialize,
  Serialize,
)]
#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
pub struct WorldId(Uuid);

impl WorldId {
  #[must_use]
  pub fn new() -> Self {
    Self(Uuid::now_v7())
  }
}

impl Default for WorldId {
  fn default() -> Self {
    Self::new()
  }
}

impl TryFrom<&str> for WorldId {
  type Error = anyhow::Error;

  fn try_from(value: &str) -> AnyResult<Self> {
    Ok(Self(Uuid::try_parse(value)?))
  }
}

#[derive(Clone, Debug, derive_more::Display, PartialEq, Eq, Deserialize, Serialize)]
#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
pub struct WorldName(Box<str>);

impl Deref for WorldName {
  type Target = str;

  fn deref(&self) -> &Self::Target {
    self.0.as_str()
  }
}

impl<T: AsRef<str>> From<T> for WorldName {
  fn from(value: T) -> Self {
    Self(Box::from(value.as_ref()))
  }
}

#[derive(Copy, Debug, strum::Display, EnumString, Deserialize, Serialize)]
#[derive_const(Clone, Default)]
#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
pub enum Locale {
  #[default]
  #[serde(rename = "en-US")]
  #[strum(serialize = "en-US")]
  English,

  #[serde(rename = "pt-BR")]
  #[strum(serialize = "pt-BR")]
  Portuguese,
}

macro_rules! impl_f64_newtype {
  ($name:ident, min = $min:expr, max = $max:expr) => {
    impl $name {
      pub const MIN: Self = $name($min);
      pub const MAX: Self = $name($max);

      #[inline]
      pub const fn new(value: f64) -> Self {
        debug_assert!(value.is_finite());
        debug_assert!(!value.is_subnormal());
        Self(value.clamp(Self::MIN.0, Self::MAX.0))
      }
    }

    const impl From<f64> for $name {
      fn from(value: f64) -> Self {
        Self::new(value)
      }
    }

    const impl From<$name> for f64 {
      fn from(value: $name) -> Self {
        value.0
      }
    }
  };
  ($name:ident, min = $min:expr, max = $max:expr, default = $default:expr) => {
    impl_f64_newtype!($name, min = $min, max = $max);

    const impl Default for $name {
      fn default() -> Self {
        Self::new($default)
      }
    }
  };
}

#[derive(
  Copy, Debug, derive_more::Display, Deserialize, Serialize, ClampNew, ConstDeref, F64Math,
)]
#[derive_const(Clone, PartialEq, PartialOrd)]
#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
pub struct WorldSpeed(f64);

impl_f64_newtype!(WorldSpeed, min = 0.1, max = 10.0, default = 1.0);

#[derive(
  Copy, Debug, derive_more::Display, Deserialize, Serialize, ClampNew, ConstDeref, F64Math,
)]
#[derive_const(Clone, PartialEq, PartialOrd)]
#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
pub struct WorldUnitSpeed(f64);

impl_f64_newtype!(WorldUnitSpeed, min = 0.1, max = 10.0, default = 1.0);

#[derive(
  Copy, Debug, derive_more::Display, Deserialize, Serialize, ClampNew, ConstDeref, F64Math,
)]
#[derive_const(Clone, PartialEq, PartialOrd)]
#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
pub struct BotDensity(f64);

impl_f64_newtype!(BotDensity, min = 0.0, max = 3.0, default = 2.0);

/// Proportion of bots that will have an advanced start with higher level infrastructure.
#[derive(
  Copy, Debug, derive_more::Display, Deserialize, Serialize, ClampNew, ConstDeref, F64Math,
)]
#[derive_const(Clone, PartialEq, PartialOrd)]
#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
pub struct BotAdvancedStartRatio(f64);

impl_f64_newtype!(BotAdvancedStartRatio, min = 0.0, max = 1.0, default = 0.2);