nil_core/world/

mod.rs

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

mod battle;
mod chat;
mod cheat;
mod city;
pub mod config;
mod continent;
mod event;
mod infrastructure;
mod military;
mod npc;
mod player;
mod ranking;
mod resources;
mod round;
mod savedata;
pub mod stats;

use crate::chat::Chat;
use crate::city::City;
use crate::continent::{Continent, ContinentSize, Coord};
use crate::error::{Error, Result};
use crate::event::Emitter;
use crate::hooks::OnNextRound;
use crate::infrastructure::Infrastructure;
use crate::military::Military;
use crate::npc::bot::{Bot, BotId, BotManager};
use crate::npc::precursor::{Precursor, PrecursorId, PrecursorManager};
use crate::player::{Player, PlayerId, PlayerManager};
use crate::ranking::Ranking;
use crate::report::ReportManager;
use crate::round::Round;
use crate::ruler::{Ruler, RulerRef, RulerRefMut};
use crate::savedata::{SaveHandle, Savedata};
use bon::Builder;
use config::{BotAdvancedStartRatio, BotDensity, Locale, WorldConfig, WorldId, WorldName};
use serde::{Deserialize, Serialize};
use stats::WorldStats;

#[derive(Debug)]
pub struct World {
  round: Round,
  continent: Continent,
  player_manager: PlayerManager,
  bot_manager: BotManager,
  precursor_manager: PrecursorManager,
  military: Military,
  ranking: Ranking,
  report: ReportManager,
  config: WorldConfig,
  stats: WorldStats,
  chat: Chat,

  // These are not included in the savedata.
  emitter: Emitter,
  save_handle: Option<SaveHandle>,
  on_next_round: Option<OnNextRound>,
}

impl World {
  pub fn new(options: &WorldOptions) -> Result<Self> {
    let config = WorldConfig::new(options);
    let continent = Continent::new(options.size.get());
    let precursor_manager = PrecursorManager::new(continent.size());
    let military = Military::new(continent.size());

    let mut world = Self {
      round: Round::default(),
      continent,
      player_manager: PlayerManager::default(),
      bot_manager: BotManager::default(),
      precursor_manager,
      military,
      ranking: Ranking::default(),
      report: ReportManager::default(),
      config,
      stats: WorldStats::new(),
      chat: Chat::default(),

      emitter: Emitter::default(),
      save_handle: None,
      on_next_round: None,
    };

    world.spawn_precursors()?;
    world.spawn_bots()?;
    world.update_ranking()?;

    Ok(world)
  }

  #[inline]
  pub fn with_savedata(savedata: Savedata) -> Self {
    Self::from(savedata)
  }

  pub fn load(bytes: &[u8]) -> Result<Self> {
    let savedata = Savedata::read(bytes)?;
    Ok(Self::with_savedata(savedata))
  }

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

  #[inline]
  pub fn config(&self) -> &WorldConfig {
    &self.config
  }

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

  #[inline]
  pub fn continent(&self) -> &Continent {
    &self.continent
  }

  #[inline]
  pub fn city(&self, coord: Coord) -> Result<&City> {
    self.continent.city(coord)
  }

  #[inline]
  pub(crate) fn city_mut(&mut self, coord: Coord) -> Result<&mut City> {
    self.continent.city_mut(coord)
  }

  #[inline]
  pub fn infrastructure(&self, coord: Coord) -> Result<&Infrastructure> {
    self.city(coord).map(City::infrastructure)
  }

  #[inline]
  pub fn round(&self) -> &Round {
    &self.round
  }

  #[inline]
  pub fn chat(&self) -> &Chat {
    &self.chat
  }

  #[inline]
  pub fn ranking(&self) -> &Ranking {
    &self.ranking
  }

  #[inline]
  pub fn report(&self) -> &ReportManager {
    &self.report
  }

  #[inline]
  pub fn player_manager(&self) -> &PlayerManager {
    &self.player_manager
  }

  #[inline]
  pub fn player(&self, id: &PlayerId) -> Result<&Player> {
    self.player_manager.player(id)
  }

  #[inline]
  fn player_mut(&mut self, id: &PlayerId) -> Result<&mut Player> {
    self.player_manager.player_mut(id)
  }

  pub fn players(&self) -> impl Iterator<Item = &Player> {
    self.player_manager.players()
  }

  #[inline]
  pub fn bot_manager(&self) -> &BotManager {
    &self.bot_manager
  }

  #[inline]
  pub fn bot(&self, id: &BotId) -> Result<&Bot> {
    self.bot_manager.bot(id)
  }

  #[inline]
  fn bot_mut(&mut self, id: &BotId) -> Result<&mut Bot> {
    self.bot_manager.bot_mut(id)
  }

  pub fn bots(&self) -> impl Iterator<Item = &Bot> {
    self.bot_manager.bots()
  }

  #[inline]
  pub fn precursor_manager(&self) -> &PrecursorManager {
    &self.precursor_manager
  }

  #[inline]
  pub fn precursor(&self, id: PrecursorId) -> &dyn Precursor {
    self.precursor_manager.precursor(id)
  }

  #[inline]
  fn precursor_mut(&mut self, id: PrecursorId) -> &mut dyn Precursor {
    self.precursor_manager.precursor_mut(id)
  }

  pub fn precursors(&self) -> impl Iterator<Item = &dyn Precursor> {
    self.precursor_manager.precursors()
  }

  pub fn ruler(&self, ruler: &Ruler) -> Result<RulerRef<'_>> {
    let ruler = match ruler {
      Ruler::Bot { id } => RulerRef::Bot(self.bot(id)?),
      Ruler::Player { id } => RulerRef::Player(self.player(id)?),
      Ruler::Precursor { id } => RulerRef::Precursor(self.precursor(*id)),
    };

    Ok(ruler)
  }

  fn ruler_mut(&mut self, ruler: &Ruler) -> Result<RulerRefMut<'_>> {
    let ruler = match ruler {
      Ruler::Bot { id } => RulerRefMut::Bot(self.bot_mut(id)?),
      Ruler::Player { id } => RulerRefMut::Player(self.player_mut(id)?),
      Ruler::Precursor { id } => RulerRefMut::Precursor(self.precursor_mut(*id)),
    };

    Ok(ruler)
  }

  pub fn rulers(&self) -> impl Iterator<Item = RulerRef<'_>> {
    self
      .players()
      .map(RulerRef::from)
      .chain(self.bots().map(RulerRef::from))
      .chain(self.precursors().map(RulerRef::from))
  }

  #[inline]
  pub fn military(&self) -> &Military {
    &self.military
  }

  pub fn save<F>(&mut self, f: F)
  where
    F: FnOnce(Vec<u8>) + Send + Sync + 'static,
  {
    self.save_handle = Some(SaveHandle::new(f));
  }

  pub fn on_next_round<F>(&mut self, f: F)
  where
    F: Fn(&mut World) + Send + Sync + 'static,
  {
    self.on_next_round = Some(OnNextRound::new(f));
  }
}

#[derive(Builder, Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorldOptions {
  #[builder(start_fn, into)]
  pub name: WorldName,

  #[serde(default)]
  #[builder(default)]
  pub size: ContinentSize,

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

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

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

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

impl WorldOptions {
  pub fn to_world(&self) -> Result<World> {
    World::try_from(self)
  }
}

impl TryFrom<&WorldOptions> for World {
  type Error = Error;

  fn try_from(options: &WorldOptions) -> Result<Self> {
    Self::new(options)
  }
}