346 lines
16 KiB
Rust
346 lines
16 KiB
Rust
use crate::static_data::{
|
|
Ability, Form, GrowthRate, Item, LearnableMoves, MoveData, Nature, Parameter, SecondaryEffect, Species,
|
|
StaticStatisticSet, StatisticSet,
|
|
};
|
|
use anyhow::anyhow;
|
|
use hashbrown::HashMap;
|
|
use parking_lot::RwLock;
|
|
use std::hash::Hash;
|
|
use std::sync::atomic::AtomicUsize;
|
|
use std::sync::{Arc, LazyLock};
|
|
|
|
/// This function can be called from the FFI to release a handle when it is no longer needed. This
|
|
/// does not drop the object per se, but will reduce the reference count of the object. If the object
|
|
/// is then no longer referenced, it will be dropped.
|
|
#[no_mangle]
|
|
extern "C" fn ffi_release_handle(handle: usize) {
|
|
let mut write_lock = FFI_OBJECTS.write();
|
|
let mut write_lock_inverse = FFI_OBJECTS_INVERSE.write();
|
|
|
|
let obj = write_lock.remove(&handle);
|
|
if let Some(obj) = obj {
|
|
write_lock_inverse.remove(&obj);
|
|
}
|
|
}
|
|
|
|
/// A handle of an object that can be passed over FFI. We use this to avoid passing pointers over the
|
|
/// FFI boundary. This allows us to be able to move the data around in memory without having to worry
|
|
/// about the pointers being invalidated. It also allows us to have a type-safe interface.
|
|
#[repr(C)]
|
|
pub(super) struct FFIHandle<T> {
|
|
/// An incrementing handle that is unique for each object.
|
|
handle: usize,
|
|
/// The type of the object.
|
|
_marker: std::marker::PhantomData<T>,
|
|
}
|
|
|
|
impl<T> Clone for FFIHandle<T> {
|
|
fn clone(&self) -> Self {
|
|
Self {
|
|
handle: self.handle,
|
|
_marker: std::marker::PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T> Copy for FFIHandle<T> {}
|
|
|
|
impl<T> Default for FFIHandle<T> {
|
|
fn default() -> Self {
|
|
Self {
|
|
handle: 0,
|
|
_marker: std::marker::PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// An FFIObject we can fetch from the FFIHandle. We store this in a hashmap to be able to fetch
|
|
/// the object from the handle, and to be able to drop the object when the FFI is done with the handle
|
|
#[derive(Clone)]
|
|
#[allow(clippy::missing_docs_in_private_items)] // I'm not documenting these items.
|
|
pub(super) enum FFIObject {
|
|
Ability(Arc<dyn Ability>),
|
|
EffectParameter(Arc<Parameter>),
|
|
StatisticSetU8(Arc<StatisticSet<u8>>),
|
|
StatisticSetI8(Arc<StatisticSet<i8>>),
|
|
StatisticSetU32(Arc<StatisticSet<u32>>),
|
|
StaticStatisticSetU16(Arc<StaticStatisticSet<u16>>),
|
|
Form(Arc<dyn Form>),
|
|
LearnableMoves(Arc<dyn LearnableMoves>),
|
|
GrowthRate(Arc<dyn GrowthRate>),
|
|
Item(Arc<dyn Item>),
|
|
SecondaryEffect(Arc<dyn SecondaryEffect>),
|
|
MoveData(Arc<dyn MoveData>),
|
|
Nature(Arc<dyn Nature>),
|
|
Species(Arc<dyn Species>),
|
|
|
|
SpeciesLibrary(Arc<dyn crate::static_data::SpeciesLibrary>),
|
|
MoveLibrary(Arc<dyn crate::static_data::MoveLibrary>),
|
|
AbilityLibrary(Arc<dyn crate::static_data::AbilityLibrary>),
|
|
ItemLibrary(Arc<dyn crate::static_data::ItemLibrary>),
|
|
GrowthRateLibrary(Arc<dyn crate::static_data::GrowthRateLibrary>),
|
|
LibrarySettings(Arc<dyn crate::static_data::LibrarySettings>),
|
|
NatureLibrary(Arc<dyn crate::static_data::NatureLibrary>),
|
|
TypeLibrary(Arc<dyn crate::static_data::TypeLibrary>),
|
|
StaticData(Arc<dyn crate::static_data::StaticData>),
|
|
|
|
// DynamicData
|
|
TurnChoice(Arc<crate::dynamic_data::TurnChoice>),
|
|
Pokemon(crate::dynamic_data::Pokemon),
|
|
LearnedMove(Arc<crate::dynamic_data::LearnedMove>),
|
|
PokemonParty(Arc<crate::dynamic_data::PokemonParty>),
|
|
BattleParty(Arc<crate::dynamic_data::BattleParty>),
|
|
Battle(crate::dynamic_data::Battle),
|
|
BattleSide(crate::dynamic_data::BattleSide),
|
|
BattleRandom(Arc<crate::dynamic_data::BattleRandom>),
|
|
|
|
// DynamicLibrary
|
|
BattleStatCalculator(Arc<dyn crate::dynamic_data::BattleStatCalculator>),
|
|
DamageLibrary(Arc<dyn crate::dynamic_data::DamageLibrary>),
|
|
MiscLibrary(Arc<dyn crate::dynamic_data::MiscLibrary>),
|
|
ScriptResolver(Arc<dyn crate::dynamic_data::ScriptResolver>),
|
|
DynamicLibrary(Arc<dyn crate::dynamic_data::DynamicLibrary>),
|
|
|
|
// Events
|
|
Event(Arc<crate::dynamic_data::EventData>),
|
|
}
|
|
|
|
unsafe impl Send for FFIObject {}
|
|
|
|
unsafe impl Sync for FFIObject {}
|
|
|
|
/// The next handle to be used.
|
|
static NEXT_HANDLE: AtomicUsize = AtomicUsize::new(1);
|
|
/// A lookup to get an actual object from a handle.
|
|
static FFI_OBJECTS: LazyLock<RwLock<HashMap<usize, FFIObject>>> = LazyLock::new(|| RwLock::new(HashMap::new()));
|
|
/// A lookup to get a handle from an object.
|
|
static FFI_OBJECTS_INVERSE: LazyLock<RwLock<HashMap<FFIObject, usize>>> = LazyLock::new(|| RwLock::new(HashMap::new()));
|
|
|
|
impl<T> FFIHandle<T> {
|
|
/// Get a handle from an object.
|
|
pub fn get_handle(o: FFIObject) -> Self {
|
|
if let Some(handle) = FFI_OBJECTS_INVERSE.read().get(&o) {
|
|
return Self {
|
|
handle: *handle,
|
|
_marker: std::marker::PhantomData,
|
|
};
|
|
}
|
|
|
|
let handle = NEXT_HANDLE.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
|
FFI_OBJECTS.write().insert(handle, o.clone());
|
|
FFI_OBJECTS_INVERSE.write().insert(o, handle);
|
|
Self {
|
|
handle,
|
|
_marker: std::marker::PhantomData,
|
|
}
|
|
}
|
|
|
|
/// An empty handle. This is used when no value is returned. Represented as handle 0
|
|
pub fn none() -> Self {
|
|
Self {
|
|
handle: 0,
|
|
_marker: std::marker::PhantomData,
|
|
}
|
|
}
|
|
|
|
/// Get the object from the handle.
|
|
#[allow(clippy::unwrap_used)] // Unwrap used, as it is a potential security bug if this fails
|
|
pub fn resolve(&self) -> FFIObject {
|
|
FFI_OBJECTS
|
|
.read()
|
|
.get(&self.handle)
|
|
.ok_or(anyhow!("Unable to get handle {} from FFI_OBJECTS", self.handle))
|
|
.unwrap()
|
|
.clone()
|
|
}
|
|
|
|
/// Check if the handle is empty.
|
|
pub fn is_none(&self) -> bool {
|
|
self.handle == 0
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::from_over_into)]
|
|
impl<T> Into<anyhow_ext::Result<FFIObject>> for FFIHandle<T> {
|
|
fn into(self) -> anyhow_ext::Result<FFIObject> {
|
|
Ok(FFI_OBJECTS
|
|
.read()
|
|
.get(&self.handle)
|
|
.ok_or(anyhow!("Unable to get handle"))?
|
|
.clone())
|
|
}
|
|
}
|
|
|
|
impl Eq for FFIObject {}
|
|
|
|
/// A trait to convert a handle into an object.
|
|
#[allow(clippy::wrong_self_convention)]
|
|
pub(super) trait FromFFIHandle<T> {
|
|
/// Convert a handle into an object.
|
|
fn from_ffi_handle(&self) -> T;
|
|
/// Convert a handle into an object, returning `None` if the handle is empty.
|
|
fn from_ffi_handle_opt(&self) -> Option<T>;
|
|
}
|
|
|
|
impl Hash for FFIObject {
|
|
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
|
|
match self {
|
|
Self::Ability(a) => Arc::as_ptr(a).hash(state),
|
|
Self::EffectParameter(a) => Arc::as_ptr(a).hash(state),
|
|
Self::StatisticSetU8(a) => Arc::as_ptr(a).hash(state),
|
|
Self::StatisticSetI8(a) => Arc::as_ptr(a).hash(state),
|
|
Self::StatisticSetU32(a) => Arc::as_ptr(a).hash(state),
|
|
Self::StaticStatisticSetU16(a) => Arc::as_ptr(a).hash(state),
|
|
Self::Form(a) => Arc::as_ptr(a).hash(state),
|
|
Self::LearnableMoves(a) => Arc::as_ptr(a).hash(state),
|
|
Self::GrowthRate(a) => Arc::as_ptr(a).hash(state),
|
|
Self::Item(a) => Arc::as_ptr(a).hash(state),
|
|
Self::SecondaryEffect(a) => Arc::as_ptr(a).hash(state),
|
|
Self::MoveData(a) => Arc::as_ptr(a).hash(state),
|
|
Self::Nature(a) => Arc::as_ptr(a).hash(state),
|
|
Self::Species(a) => Arc::as_ptr(a).hash(state),
|
|
Self::SpeciesLibrary(a) => Arc::as_ptr(a).hash(state),
|
|
Self::MoveLibrary(a) => Arc::as_ptr(a).hash(state),
|
|
Self::AbilityLibrary(a) => Arc::as_ptr(a).hash(state),
|
|
Self::ItemLibrary(a) => Arc::as_ptr(a).hash(state),
|
|
Self::GrowthRateLibrary(a) => Arc::as_ptr(a).hash(state),
|
|
Self::LibrarySettings(a) => Arc::as_ptr(a).hash(state),
|
|
Self::NatureLibrary(a) => Arc::as_ptr(a).hash(state),
|
|
Self::TypeLibrary(a) => Arc::as_ptr(a).hash(state),
|
|
Self::StaticData(a) => Arc::as_ptr(a).hash(state),
|
|
Self::TurnChoice(a) => Arc::as_ptr(a).hash(state),
|
|
Self::Pokemon(a) => a.as_ptr().hash(state),
|
|
Self::LearnedMove(a) => Arc::as_ptr(a).hash(state),
|
|
Self::PokemonParty(a) => Arc::as_ptr(a).hash(state),
|
|
Self::BattleParty(a) => Arc::as_ptr(a).hash(state),
|
|
Self::Battle(a) => a.as_ptr().hash(state),
|
|
Self::BattleSide(a) => a.as_ptr().hash(state),
|
|
Self::BattleRandom(a) => Arc::as_ptr(a).hash(state),
|
|
Self::BattleStatCalculator(a) => Arc::as_ptr(a).hash(state),
|
|
Self::DamageLibrary(a) => Arc::as_ptr(a).hash(state),
|
|
Self::MiscLibrary(a) => Arc::as_ptr(a).hash(state),
|
|
Self::ScriptResolver(a) => Arc::as_ptr(a).hash(state),
|
|
Self::DynamicLibrary(a) => Arc::as_ptr(a).hash(state),
|
|
FFIObject::Event(a) => Arc::as_ptr(a).hash(state),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialEq for FFIObject {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
match (self, other) {
|
|
(Self::Ability(a), Self::Ability(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::EffectParameter(a), Self::EffectParameter(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::StatisticSetU8(a), Self::StatisticSetU8(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::StatisticSetI8(a), Self::StatisticSetI8(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::StatisticSetU32(a), Self::StatisticSetU32(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::StaticStatisticSetU16(a), Self::StaticStatisticSetU16(b)) => {
|
|
Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr()
|
|
}
|
|
(Self::Form(a), Self::Form(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::LearnableMoves(a), Self::LearnableMoves(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::GrowthRate(a), Self::GrowthRate(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::Item(a), Self::Item(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::SecondaryEffect(a), Self::SecondaryEffect(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::MoveData(a), Self::MoveData(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::Nature(a), Self::Nature(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::Species(a), Self::Species(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::SpeciesLibrary(a), Self::SpeciesLibrary(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::MoveLibrary(a), Self::MoveLibrary(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::AbilityLibrary(a), Self::AbilityLibrary(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::ItemLibrary(a), Self::ItemLibrary(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::GrowthRateLibrary(a), Self::GrowthRateLibrary(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::LibrarySettings(a), Self::LibrarySettings(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::NatureLibrary(a), Self::NatureLibrary(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::TypeLibrary(a), Self::TypeLibrary(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::StaticData(a), Self::StaticData(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::TurnChoice(a), Self::TurnChoice(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::Pokemon(a), Self::Pokemon(b)) => a.eq(b),
|
|
(Self::LearnedMove(a), Self::LearnedMove(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::PokemonParty(a), Self::PokemonParty(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::BattleParty(a), Self::BattleParty(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::Battle(a), Self::Battle(b)) => a.eq(b),
|
|
(Self::BattleSide(a), Self::BattleSide(b)) => a.eq(b),
|
|
(Self::BattleRandom(a), Self::BattleRandom(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::BattleStatCalculator(a), Self::BattleStatCalculator(b)) => {
|
|
Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr()
|
|
}
|
|
(Self::DamageLibrary(a), Self::DamageLibrary(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::MiscLibrary(a), Self::MiscLibrary(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::ScriptResolver(a), Self::ScriptResolver(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::DynamicLibrary(a), Self::DynamicLibrary(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
(Self::Event(a), Self::Event(b)) => Arc::as_ptr(a).addr() == Arc::as_ptr(b).addr(),
|
|
_ => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Helper macro to implement the `From` trait for a `FFIObject` enum variant, and the `FromFFIHandle`
|
|
/// trait for a `FFIHandle` enum variant.
|
|
macro_rules! ffi_obj_conversions {
|
|
($res_type:ty, $ffi_obj_name:ident) => {
|
|
impl From<$res_type> for FFIObject {
|
|
fn from(a: $res_type) -> Self {
|
|
Self::$ffi_obj_name(a)
|
|
}
|
|
}
|
|
|
|
impl FromFFIHandle<$res_type> for FFIHandle<$res_type> {
|
|
fn from_ffi_handle(&self) -> $res_type {
|
|
match self.resolve() {
|
|
FFIObject::$ffi_obj_name(a) => a.clone(),
|
|
_ => panic!("Invalid handle"),
|
|
}
|
|
}
|
|
|
|
fn from_ffi_handle_opt(&self) -> Option<$res_type> {
|
|
if (self.is_none()) {
|
|
return None;
|
|
}
|
|
match self.resolve() {
|
|
FFIObject::$ffi_obj_name(a) => Some(a.clone()),
|
|
_ => panic!("Invalid handle"),
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
ffi_obj_conversions!(Arc<dyn Ability>, Ability);
|
|
ffi_obj_conversions!(Arc<Parameter>, EffectParameter);
|
|
ffi_obj_conversions!(Arc<StatisticSet<i8>>, StatisticSetI8);
|
|
ffi_obj_conversions!(Arc<StatisticSet<u8>>, StatisticSetU8);
|
|
ffi_obj_conversions!(Arc<StatisticSet<u32>>, StatisticSetU32);
|
|
ffi_obj_conversions!(Arc<StaticStatisticSet<u16>>, StaticStatisticSetU16);
|
|
ffi_obj_conversions!(Arc<dyn Form>, Form);
|
|
ffi_obj_conversions!(Arc<dyn LearnableMoves>, LearnableMoves);
|
|
ffi_obj_conversions!(Arc<dyn GrowthRate>, GrowthRate);
|
|
ffi_obj_conversions!(Arc<dyn Item>, Item);
|
|
ffi_obj_conversions!(Arc<dyn SecondaryEffect>, SecondaryEffect);
|
|
ffi_obj_conversions!(Arc<dyn MoveData>, MoveData);
|
|
ffi_obj_conversions!(Arc<dyn Nature>, Nature);
|
|
ffi_obj_conversions!(Arc<dyn Species>, Species);
|
|
ffi_obj_conversions!(Arc<dyn crate::static_data::SpeciesLibrary>, SpeciesLibrary);
|
|
ffi_obj_conversions!(Arc<dyn crate::static_data::MoveLibrary>, MoveLibrary);
|
|
ffi_obj_conversions!(Arc<dyn crate::static_data::AbilityLibrary>, AbilityLibrary);
|
|
ffi_obj_conversions!(Arc<dyn crate::static_data::ItemLibrary>, ItemLibrary);
|
|
ffi_obj_conversions!(Arc<dyn crate::static_data::GrowthRateLibrary>, GrowthRateLibrary);
|
|
ffi_obj_conversions!(Arc<dyn crate::static_data::LibrarySettings>, LibrarySettings);
|
|
ffi_obj_conversions!(Arc<dyn crate::static_data::NatureLibrary>, NatureLibrary);
|
|
ffi_obj_conversions!(Arc<dyn crate::static_data::TypeLibrary>, TypeLibrary);
|
|
ffi_obj_conversions!(Arc<dyn crate::static_data::StaticData>, StaticData);
|
|
ffi_obj_conversions!(Arc<crate::dynamic_data::TurnChoice>, TurnChoice);
|
|
ffi_obj_conversions!(crate::dynamic_data::Pokemon, Pokemon);
|
|
ffi_obj_conversions!(Arc<crate::dynamic_data::LearnedMove>, LearnedMove);
|
|
ffi_obj_conversions!(Arc<crate::dynamic_data::PokemonParty>, PokemonParty);
|
|
ffi_obj_conversions!(Arc<crate::dynamic_data::BattleParty>, BattleParty);
|
|
ffi_obj_conversions!(crate::dynamic_data::Battle, Battle);
|
|
ffi_obj_conversions!(crate::dynamic_data::BattleSide, BattleSide);
|
|
ffi_obj_conversions!(Arc<crate::dynamic_data::BattleRandom>, BattleRandom);
|
|
ffi_obj_conversions!(Arc<dyn crate::dynamic_data::BattleStatCalculator>, BattleStatCalculator);
|
|
ffi_obj_conversions!(Arc<dyn crate::dynamic_data::DamageLibrary>, DamageLibrary);
|
|
ffi_obj_conversions!(Arc<dyn crate::dynamic_data::MiscLibrary>, MiscLibrary);
|
|
ffi_obj_conversions!(Arc<dyn crate::dynamic_data::ScriptResolver>, ScriptResolver);
|
|
ffi_obj_conversions!(Arc<dyn crate::dynamic_data::DynamicLibrary>, DynamicLibrary);
|
|
ffi_obj_conversions!(Arc<crate::dynamic_data::EventData>, Event);
|