PkmnLib_rs/src/static_data/species_data/form.rs

261 lines
9.2 KiB
Rust
Executable File

use anyhow_ext::{ensure, Result};
use hashbrown::HashSet;
use std::fmt::Debug;
use std::sync::Arc;
use crate::static_data::Statistic;
use crate::static_data::TypeIdentifier;
use crate::static_data::{Ability, StaticStatisticSet};
use crate::static_data::{AbilityIndex, LearnableMoves};
use crate::Random;
use crate::{StringKey, VecExt};
/// A form is a variant of a specific species. A species always has at least one form, but can have
/// many more.
pub trait Form: Debug {
/// The name of the form.
fn name(&self) -> &StringKey;
/// The height of the form in meters.
fn height(&self) -> f32;
/// The weight of the form in kilograms.
fn weight(&self) -> f32;
/// The base amount of experience that is gained when beating a Pokemon with this form.
fn base_experience(&self) -> u32;
/// The normal types a Pokemon with this form has.
fn types(&self) -> &Vec<TypeIdentifier>;
/// The inherent values of a form of species that are used for the stats of a Pokemon.
fn base_stats(&self) -> &Arc<StaticStatisticSet<u16>>;
/// The possible abilities a Pokemon with this form can have.
fn abilities(&self) -> &Vec<StringKey>;
/// The possible hidden abilities a Pokemon with this form can have.
fn hidden_abilities(&self) -> &Vec<StringKey>;
/// The moves a Pokemon with this form can learn.
fn moves(&self) -> &Arc<dyn LearnableMoves>;
/// Arbitrary flags can be set on a form for scripting use.
fn flags(&self) -> &HashSet<StringKey>;
/// Get a type of the move at a certain index.
fn get_type(&self, index: usize) -> Result<TypeIdentifier>;
/// Gets a single base stat value.
fn get_base_stat(&self, stat: Statistic) -> u16;
/// Find the index of an ability that can be on this form.
fn find_ability_index(&self, ability: &dyn Ability) -> Option<AbilityIndex>;
/// Gets an ability from the form.
fn get_ability(&self, index: AbilityIndex) -> Result<&StringKey>;
/// Gets a random ability from the form.
fn get_random_ability(&self, rand: &mut Random) -> Result<&StringKey>;
/// Gets a random hidden ability from the form.
fn get_random_hidden_ability(&self, rand: &mut Random) -> Result<&StringKey>;
/// Check if the form has a specific flag set.
fn has_flag(&self, key: &StringKey) -> bool;
/// Arbitrary flags that can be applied to the move.
fn has_flag_by_hash(&self, key_hash: u32) -> bool;
/// Check if two forms are equal.
fn eq(&self, other: &dyn Form) -> bool;
}
/// A form is a variant of a specific species. A species always has at least one form, but can have
/// many more.
#[derive(Debug)]
pub struct FormImpl {
/// The name of the form.
name: StringKey,
/// The height of the form in meters.
height: f32,
/// The weight of the form in kilograms.
weight: f32,
/// The base amount of experience that is gained when beating a Pokemon with this form.
base_experience: u32,
/// The normal types a Pokemon with this form has.
types: Vec<TypeIdentifier>,
/// The inherent values of a form of species that are used for the stats of a Pokemon.
base_stats: Arc<StaticStatisticSet<u16>>,
/// The possible abilities a Pokemon with this form can have.
abilities: Vec<StringKey>,
/// The possible hidden abilities a Pokemon with this form can have.
hidden_abilities: Vec<StringKey>,
/// The moves a Pokemon with this form can learn.
moves: Arc<dyn LearnableMoves>,
/// Arbitrary flags can be set on a form for scripting use.
flags: HashSet<StringKey>,
}
impl FormImpl {
/// Instantiates a new form.
pub fn new(
name: &StringKey,
height: f32,
weight: f32,
base_experience: u32,
types: Vec<TypeIdentifier>,
base_stats: Arc<StaticStatisticSet<u16>>,
abilities: Vec<StringKey>,
hidden_abilities: Vec<StringKey>,
moves: Arc<dyn LearnableMoves>,
flags: HashSet<StringKey>,
) -> Self {
Self {
name: name.clone(),
height,
weight,
base_experience,
types,
base_stats,
abilities,
hidden_abilities,
moves,
flags,
}
}
}
impl Form for FormImpl {
/// The name of the form.
fn name(&self) -> &StringKey {
&self.name
}
/// The height of the form in meters.
fn height(&self) -> f32 {
self.height
}
/// The weight of the form in kilograms.
fn weight(&self) -> f32 {
self.weight
}
/// The base amount of experience that is gained when beating a Pokemon with this form.
fn base_experience(&self) -> u32 {
self.base_experience
}
/// The normal types a Pokemon with this form has.
fn types(&self) -> &Vec<TypeIdentifier> {
&self.types
}
/// The inherent values of a form of species that are used for the stats of a Pokemon.
fn base_stats(&self) -> &Arc<StaticStatisticSet<u16>> {
&self.base_stats
}
/// The possible abilities a Pokemon with this form can have.
fn abilities(&self) -> &Vec<StringKey> {
&self.abilities
}
/// The possible hidden abilities a Pokemon with this form can have.
fn hidden_abilities(&self) -> &Vec<StringKey> {
&self.hidden_abilities
}
/// The moves a Pokemon with this form can learn.
fn moves(&self) -> &Arc<dyn LearnableMoves> {
&self.moves
}
/// Arbitrary flags can be set on a form for scripting use.
fn flags(&self) -> &HashSet<StringKey> {
&self.flags
}
/// Get a type of the move at a certain index.
fn get_type(&self, index: usize) -> Result<TypeIdentifier> {
Ok(*self.types.get_res(index)?)
}
/// Gets a single base stat value.
fn get_base_stat(&self, stat: Statistic) -> u16 {
self.base_stats.get_stat(stat)
}
/// Find the index of an ability that can be on this form.
fn find_ability_index(&self, ability: &dyn Ability) -> Option<AbilityIndex> {
for (index, a) in self.abilities.iter().enumerate() {
if a == ability.name() {
return Some(AbilityIndex {
hidden: false,
index: index as u8,
});
}
}
for (index, a) in self.hidden_abilities.iter().enumerate() {
if a == ability.name() {
return Some(AbilityIndex {
hidden: true,
index: index as u8,
});
}
}
None
}
/// Gets an ability from the form.
fn get_ability(&self, index: AbilityIndex) -> Result<&StringKey> {
if index.hidden {
Ok(self.hidden_abilities.get_res(index.index as usize)?)
} else {
Ok(self.abilities.get_res(index.index as usize)?)
}
}
/// Gets a random ability from the form.
fn get_random_ability(&self, rand: &mut Random) -> Result<&StringKey> {
ensure!(!self.abilities.is_empty(), "No abilities on form");
self.abilities
.get_res(rand.get_between_unsigned(0, self.abilities.len() as u32) as usize)
}
/// Gets a random hidden ability from the form.
fn get_random_hidden_ability(&self, rand: &mut Random) -> Result<&StringKey> {
ensure!(!self.hidden_abilities.is_empty(), "No hidden abilities on form");
self.hidden_abilities
.get_res(rand.get_between_unsigned(0, self.hidden_abilities.len() as u32) as usize)
}
/// Check if the form has a specific flag set.
fn has_flag(&self, key: &StringKey) -> bool {
self.flags.contains(key)
}
fn has_flag_by_hash(&self, key_hash: u32) -> bool {
self.flags.contains::<u32>(&key_hash)
}
fn eq(&self, other: &dyn Form) -> bool {
std::ptr::eq(self, other as *const dyn Form as *const Self)
}
}
#[cfg(test)]
#[allow(clippy::indexing_slicing)]
#[allow(clippy::unwrap_used)]
pub(crate) mod tests {
use super::*;
mockall::mock! {
#[derive(Debug)]
pub Form {}
impl Form for Form {
fn name(&self) -> &StringKey;
fn height(&self) -> f32;
fn weight(&self) -> f32;
fn base_experience(&self) -> u32;
fn types(&self) -> &Vec<TypeIdentifier>;
fn base_stats(&self) -> &Arc<StaticStatisticSet<u16>>;
fn abilities(&self) -> &Vec<StringKey>;
fn hidden_abilities(&self) -> &Vec<StringKey>;
fn moves(&self) -> &Arc<dyn LearnableMoves>;
fn flags(&self) -> &HashSet<StringKey>;
fn get_type(&self, index: usize) -> Result<TypeIdentifier>;
fn get_base_stat(&self, stat: Statistic) -> u16;
fn find_ability_index(&self, ability: &dyn Ability) -> Option<AbilityIndex>;
fn get_ability<'a>(&'a self, index: AbilityIndex) -> Result<&'a StringKey>;
fn get_random_ability<'a>(&'a self, rand: &mut Random) -> Result<&'a StringKey>;
fn get_random_hidden_ability<'a>(&'a self, rand: &mut Random) -> Result<&'a StringKey>;
fn has_flag(&self, key: &StringKey) -> bool;
fn has_flag_by_hash(&self, key_hash: u32) -> bool;
fn eq(&self, other: &dyn Form) -> bool;
}
}
}