2023-06-24 12:44:23 +00:00
|
|
|
use crate::ffi::ffi_handle::{FFIHandle, FromFFIHandle};
|
2023-06-25 14:28:51 +00:00
|
|
|
use crate::ffi::{ffi_handle_arc_dyn_getter, FFIResult, NonOwnedPtrString, OwnedPtrString};
|
2022-11-27 17:22:57 +00:00
|
|
|
use crate::static_data::{
|
2023-07-29 10:57:52 +00:00
|
|
|
MoveCategory, MoveData, MoveDataImpl, MoveTarget, Parameter, SecondaryEffect, SecondaryEffectImpl, TypeIdentifier,
|
2022-11-27 17:22:57 +00:00
|
|
|
};
|
2022-09-18 16:02:13 +00:00
|
|
|
use crate::StringKey;
|
2023-04-16 17:57:21 +00:00
|
|
|
use anyhow::anyhow;
|
2022-09-18 16:02:13 +00:00
|
|
|
use hashbrown::HashSet;
|
|
|
|
use std::ffi::{c_char, CStr, CString};
|
2022-10-08 11:15:04 +00:00
|
|
|
use std::sync::Arc;
|
2022-09-18 16:02:13 +00:00
|
|
|
|
2022-10-14 14:53:30 +00:00
|
|
|
/// Instantiates a new move.
|
2022-09-18 16:02:13 +00:00
|
|
|
#[no_mangle]
|
|
|
|
unsafe extern "C" fn move_data_new(
|
|
|
|
name: *const c_char,
|
|
|
|
move_type: TypeIdentifier,
|
|
|
|
category: MoveCategory,
|
|
|
|
base_power: u8,
|
|
|
|
accuracy: u8,
|
|
|
|
base_usages: u8,
|
|
|
|
target: MoveTarget,
|
|
|
|
priority: i8,
|
2023-06-24 12:44:23 +00:00
|
|
|
secondary_effect: FFIHandle<Arc<dyn SecondaryEffect>>,
|
2022-09-18 16:02:13 +00:00
|
|
|
flags: *const *const c_char,
|
|
|
|
flags_length: usize,
|
2023-06-24 12:44:23 +00:00
|
|
|
) -> FFIResult<FFIHandle<Arc<dyn MoveData>>> {
|
2022-09-18 16:02:13 +00:00
|
|
|
let flags = std::slice::from_raw_parts(flags, flags_length);
|
2023-04-16 17:57:21 +00:00
|
|
|
let name: StringKey = match CStr::from_ptr(name).to_str() {
|
|
|
|
Ok(name) => name.into(),
|
2023-06-24 12:44:23 +00:00
|
|
|
Err(_) => return FFIResult::err_from_str("Unable to convert name to string"),
|
2023-04-16 17:57:21 +00:00
|
|
|
};
|
2022-09-18 16:02:13 +00:00
|
|
|
let mut flags_set: HashSet<StringKey> = HashSet::with_capacity(flags_length);
|
|
|
|
for flag in flags {
|
2023-04-16 17:57:21 +00:00
|
|
|
let flag = match CStr::from_ptr(*flag).to_str() {
|
|
|
|
Ok(flag) => flag,
|
2023-06-24 12:44:23 +00:00
|
|
|
Err(_) => return FFIResult::err_from_str("Unable to convert flag to string"),
|
2023-04-16 17:57:21 +00:00
|
|
|
};
|
|
|
|
flags_set.insert(flag.into());
|
2022-09-18 16:02:13 +00:00
|
|
|
}
|
2023-06-24 12:44:23 +00:00
|
|
|
let secondary_effect = if secondary_effect.is_none() {
|
2022-09-18 16:02:13 +00:00
|
|
|
None
|
|
|
|
} else {
|
2023-06-24 12:44:23 +00:00
|
|
|
Some(secondary_effect.from_ffi_handle())
|
2022-09-18 16:02:13 +00:00
|
|
|
};
|
2022-11-27 21:29:11 +00:00
|
|
|
let a: Arc<dyn MoveData> = Arc::new(MoveDataImpl::new(
|
2022-09-18 16:02:13 +00:00
|
|
|
&name,
|
|
|
|
move_type,
|
|
|
|
category,
|
|
|
|
base_power,
|
|
|
|
accuracy,
|
|
|
|
base_usages,
|
|
|
|
target,
|
|
|
|
priority,
|
|
|
|
secondary_effect,
|
|
|
|
flags_set,
|
2022-11-27 21:29:11 +00:00
|
|
|
));
|
2023-06-24 12:44:23 +00:00
|
|
|
FFIResult::ok(FFIHandle::get_handle(a.into()))
|
2022-09-18 16:02:13 +00:00
|
|
|
}
|
|
|
|
|
2022-10-14 14:53:30 +00:00
|
|
|
/// The name of the move.
|
2022-09-18 16:02:13 +00:00
|
|
|
#[no_mangle]
|
2023-06-24 12:44:23 +00:00
|
|
|
unsafe extern "C" fn move_data_name(ptr: FFIHandle<Arc<dyn MoveData>>) -> FFIResult<OwnedPtrString> {
|
|
|
|
let move_data = ptr.from_ffi_handle();
|
|
|
|
let name = move_data.name();
|
2023-04-16 17:57:21 +00:00
|
|
|
match CString::new(name.str()) {
|
2023-06-25 14:28:51 +00:00
|
|
|
Ok(name) => FFIResult::ok(OwnedPtrString(name.into_raw())),
|
2023-06-24 12:44:23 +00:00
|
|
|
Err(_) => FFIResult::err_from_str("Unable to convert name to string"),
|
2023-04-16 17:57:21 +00:00
|
|
|
}
|
2022-09-18 16:02:13 +00:00
|
|
|
}
|
|
|
|
|
2023-06-24 12:44:23 +00:00
|
|
|
ffi_handle_arc_dyn_getter!(MoveData, move_type, TypeIdentifier);
|
|
|
|
ffi_handle_arc_dyn_getter!(MoveData, category, MoveCategory);
|
|
|
|
ffi_handle_arc_dyn_getter!(MoveData, base_power, u8);
|
|
|
|
ffi_handle_arc_dyn_getter!(MoveData, accuracy, u8);
|
|
|
|
ffi_handle_arc_dyn_getter!(MoveData, base_usages, u8);
|
|
|
|
ffi_handle_arc_dyn_getter!(MoveData, target, MoveTarget);
|
|
|
|
ffi_handle_arc_dyn_getter!(MoveData, priority, i8);
|
2022-09-18 16:02:13 +00:00
|
|
|
|
2022-10-14 14:53:30 +00:00
|
|
|
/// The optional secondary effect the move has.
|
2022-09-18 16:02:13 +00:00
|
|
|
#[no_mangle]
|
2022-10-08 11:15:04 +00:00
|
|
|
unsafe extern "C" fn move_data_secondary_effect(
|
2023-06-24 12:44:23 +00:00
|
|
|
ptr: FFIHandle<Arc<dyn MoveData>>,
|
|
|
|
) -> FFIHandle<Arc<dyn SecondaryEffect>> {
|
|
|
|
match ptr.from_ffi_handle().secondary_effect() {
|
|
|
|
Some(secondary_effect) => FFIHandle::get_handle(secondary_effect.clone().into()),
|
|
|
|
None => FFIHandle::none(),
|
|
|
|
}
|
2022-09-18 16:02:13 +00:00
|
|
|
}
|
|
|
|
|
2022-10-14 14:53:30 +00:00
|
|
|
/// Arbitrary flags that can be applied to the move.
|
2022-09-18 16:02:13 +00:00
|
|
|
#[no_mangle]
|
2023-06-25 14:28:51 +00:00
|
|
|
unsafe extern "C" fn move_data_has_flag(ptr: FFIHandle<Arc<dyn MoveData>>, flag: *const c_char) -> u8 {
|
2022-09-18 16:02:13 +00:00
|
|
|
let flag = CStr::from_ptr(flag).into();
|
2023-06-25 14:28:51 +00:00
|
|
|
u8::from(ptr.from_ffi_handle().has_flag(&flag))
|
2022-09-18 16:02:13 +00:00
|
|
|
}
|
|
|
|
|
2022-10-14 14:53:30 +00:00
|
|
|
/// Instantiates a new Secondary Effect.
|
2022-09-18 16:02:13 +00:00
|
|
|
#[no_mangle]
|
|
|
|
unsafe extern "C" fn secondary_effect_new(
|
|
|
|
chance: f32,
|
2023-06-24 12:44:23 +00:00
|
|
|
effect_name: NonOwnedPtrString,
|
2023-07-29 10:57:52 +00:00
|
|
|
parameters: *mut FFIHandle<Arc<Parameter>>,
|
2022-09-18 16:02:13 +00:00
|
|
|
parameters_length: usize,
|
2023-06-24 12:44:23 +00:00
|
|
|
) -> FFIHandle<Box<dyn SecondaryEffect>> {
|
2022-09-18 16:02:13 +00:00
|
|
|
let parameter_slice = std::slice::from_raw_parts(parameters, parameters_length);
|
|
|
|
let mut parameters = Vec::with_capacity(parameters_length);
|
|
|
|
for parameter in parameter_slice {
|
2023-06-24 12:44:23 +00:00
|
|
|
parameters.push(parameter.from_ffi_handle())
|
2022-09-18 16:02:13 +00:00
|
|
|
}
|
|
|
|
|
2023-06-24 12:44:23 +00:00
|
|
|
let b: Arc<dyn SecondaryEffect> = Arc::new(SecondaryEffectImpl::new(
|
2022-09-18 16:02:13 +00:00
|
|
|
chance,
|
|
|
|
CStr::from_ptr(effect_name).into(),
|
|
|
|
parameters,
|
2022-11-27 17:22:57 +00:00
|
|
|
));
|
2023-06-24 12:44:23 +00:00
|
|
|
FFIHandle::get_handle(b.into())
|
2022-09-18 16:02:13 +00:00
|
|
|
}
|
|
|
|
|
2022-10-14 14:53:30 +00:00
|
|
|
/// The chance the effect triggers.
|
|
|
|
#[no_mangle]
|
2023-06-25 14:28:51 +00:00
|
|
|
unsafe extern "C" fn secondary_effect_chance(ptr: FFIHandle<Arc<dyn SecondaryEffect>>) -> f32 {
|
|
|
|
ptr.from_ffi_handle().chance()
|
2022-10-14 14:53:30 +00:00
|
|
|
}
|
2022-09-18 16:02:13 +00:00
|
|
|
|
2022-10-14 14:53:30 +00:00
|
|
|
/// The name of the effect.
|
2022-09-18 16:02:13 +00:00
|
|
|
#[no_mangle]
|
2023-04-16 17:57:21 +00:00
|
|
|
unsafe extern "C" fn secondary_effect_effect_name(
|
2023-06-25 14:28:51 +00:00
|
|
|
ptr: FFIHandle<Arc<dyn SecondaryEffect>>,
|
2023-06-24 12:44:23 +00:00
|
|
|
) -> FFIResult<OwnedPtrString> {
|
2023-06-25 14:28:51 +00:00
|
|
|
match CString::new(ptr.from_ffi_handle().effect_name().str()) {
|
|
|
|
Ok(name) => FFIResult::ok(OwnedPtrString(name.into_raw())),
|
2023-06-24 12:44:23 +00:00
|
|
|
Err(_) => FFIResult::err(anyhow!(
|
2023-04-16 17:57:21 +00:00
|
|
|
"Unable to convert effect name '{}' to CString",
|
2023-06-25 14:28:51 +00:00
|
|
|
ptr.from_ffi_handle().effect_name()
|
2023-04-16 17:57:21 +00:00
|
|
|
)),
|
|
|
|
}
|
2022-09-18 16:02:13 +00:00
|
|
|
}
|
|
|
|
|
2022-10-14 14:53:30 +00:00
|
|
|
/// The length of parameters of the effect.
|
2022-09-18 16:02:13 +00:00
|
|
|
#[no_mangle]
|
2023-06-25 14:28:51 +00:00
|
|
|
unsafe extern "C" fn secondary_effect_parameter_length(ptr: FFIHandle<Arc<dyn SecondaryEffect>>) -> usize {
|
|
|
|
ptr.from_ffi_handle().parameters().len()
|
2022-09-18 16:02:13 +00:00
|
|
|
}
|
|
|
|
|
2022-10-14 14:53:30 +00:00
|
|
|
/// Get a parameter of the effect.
|
2022-09-18 16:02:13 +00:00
|
|
|
#[no_mangle]
|
|
|
|
unsafe extern "C" fn secondary_effect_parameter_get(
|
2023-06-25 14:28:51 +00:00
|
|
|
ptr: FFIHandle<Arc<dyn SecondaryEffect>>,
|
2022-09-18 16:02:13 +00:00
|
|
|
index: usize,
|
2023-07-29 10:57:52 +00:00
|
|
|
) -> FFIHandle<Arc<Parameter>> {
|
2023-06-25 14:28:51 +00:00
|
|
|
if let Some(v) = ptr.from_ffi_handle().parameters().get(index) {
|
2023-06-24 12:44:23 +00:00
|
|
|
FFIHandle::get_handle(v.clone().into())
|
2022-09-18 16:02:13 +00:00
|
|
|
} else {
|
2023-06-24 12:44:23 +00:00
|
|
|
FFIHandle::none()
|
2022-09-18 16:02:13 +00:00
|
|
|
}
|
|
|
|
}
|