166 lines
5.2 KiB
Rust
166 lines
5.2 KiB
Rust
use crate::ffi::{ffi_arc_dyn_getter, BorrowedPtr, ExternPointer, IdentifiablePointer, NativeResult, OwnedPtr};
|
|
use crate::static_data::{
|
|
EffectParameter, MoveCategory, MoveData, MoveDataImpl, MoveTarget, SecondaryEffect, SecondaryEffectImpl,
|
|
TypeIdentifier,
|
|
};
|
|
use crate::StringKey;
|
|
use anyhow::anyhow;
|
|
use hashbrown::HashSet;
|
|
use std::ffi::{c_char, CStr, CString};
|
|
use std::ptr::drop_in_place;
|
|
use std::sync::Arc;
|
|
|
|
/// Instantiates a new move.
|
|
#[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,
|
|
secondary_effect: *mut Box<dyn SecondaryEffect>,
|
|
flags: *const *const c_char,
|
|
flags_length: usize,
|
|
) -> NativeResult<IdentifiablePointer<Arc<dyn MoveData>>> {
|
|
let flags = std::slice::from_raw_parts(flags, flags_length);
|
|
let name: StringKey = match CStr::from_ptr(name).to_str() {
|
|
Ok(name) => name.into(),
|
|
Err(_) => return NativeResult::err_from_str("Unable to convert name to string"),
|
|
};
|
|
let mut flags_set: HashSet<StringKey> = HashSet::with_capacity(flags_length);
|
|
for flag in flags {
|
|
let flag = match CStr::from_ptr(*flag).to_str() {
|
|
Ok(flag) => flag,
|
|
Err(_) => return NativeResult::err_from_str("Unable to convert flag to string"),
|
|
};
|
|
flags_set.insert(flag.into());
|
|
}
|
|
let secondary_effect = if secondary_effect.is_null() {
|
|
None
|
|
} else {
|
|
Some(*Box::from_raw(secondary_effect))
|
|
};
|
|
let a: Arc<dyn MoveData> = Arc::new(MoveDataImpl::new(
|
|
&name,
|
|
move_type,
|
|
category,
|
|
base_power,
|
|
accuracy,
|
|
base_usages,
|
|
target,
|
|
priority,
|
|
secondary_effect,
|
|
flags_set,
|
|
));
|
|
NativeResult::ok(a.into())
|
|
}
|
|
|
|
/// Drops a reference counted move.
|
|
#[no_mangle]
|
|
unsafe extern "C" fn move_data_drop(ptr: OwnedPtr<Arc<dyn MoveData>>) {
|
|
drop_in_place(ptr)
|
|
}
|
|
|
|
/// The name of the move.
|
|
#[no_mangle]
|
|
unsafe extern "C" fn move_data_name(ptr: ExternPointer<Arc<dyn MoveData>>) -> NativeResult<OwnedPtr<c_char>> {
|
|
let name = ptr.as_ref().name();
|
|
match CString::new(name.str()) {
|
|
Ok(name) => NativeResult::ok(name.into_raw()),
|
|
Err(_) => NativeResult::err_from_str("Unable to convert name to string"),
|
|
}
|
|
}
|
|
|
|
ffi_arc_dyn_getter!(MoveData, move_type, TypeIdentifier);
|
|
ffi_arc_dyn_getter!(MoveData, category, MoveCategory);
|
|
ffi_arc_dyn_getter!(MoveData, base_power, u8);
|
|
ffi_arc_dyn_getter!(MoveData, accuracy, u8);
|
|
ffi_arc_dyn_getter!(MoveData, base_usages, u8);
|
|
ffi_arc_dyn_getter!(MoveData, target, MoveTarget);
|
|
ffi_arc_dyn_getter!(MoveData, priority, i8);
|
|
|
|
/// The optional secondary effect the move has.
|
|
#[no_mangle]
|
|
unsafe extern "C" fn move_data_secondary_effect(
|
|
ptr: ExternPointer<Arc<dyn MoveData>>,
|
|
) -> IdentifiablePointer<Box<dyn SecondaryEffect>> {
|
|
ptr.as_ref().secondary_effect().into()
|
|
}
|
|
|
|
/// Arbitrary flags that can be applied to the move.
|
|
#[no_mangle]
|
|
unsafe extern "C" fn move_data_has_flag(ptr: ExternPointer<Arc<dyn MoveData>>, flag: *const c_char) -> u8 {
|
|
let flag = CStr::from_ptr(flag).into();
|
|
u8::from(ptr.as_ref().has_flag(&flag))
|
|
}
|
|
|
|
/// Instantiates a new Secondary Effect.
|
|
#[no_mangle]
|
|
unsafe extern "C" fn secondary_effect_new(
|
|
chance: f32,
|
|
effect_name: BorrowedPtr<c_char>,
|
|
parameters: *mut OwnedPtr<EffectParameter>,
|
|
parameters_length: usize,
|
|
) -> IdentifiablePointer<Box<dyn SecondaryEffect>> {
|
|
let parameter_slice = std::slice::from_raw_parts(parameters, parameters_length);
|
|
let mut parameters = Vec::with_capacity(parameters_length);
|
|
for parameter in parameter_slice {
|
|
parameters.push(*Box::from_raw(*parameter))
|
|
}
|
|
|
|
let b: Box<dyn SecondaryEffect> = Box::new(SecondaryEffectImpl::new(
|
|
chance,
|
|
CStr::from_ptr(effect_name).into(),
|
|
parameters,
|
|
));
|
|
b.into()
|
|
}
|
|
|
|
/// Drop a secondary effect.
|
|
#[no_mangle]
|
|
unsafe extern "C" fn secondary_effect_drop(ptr: OwnedPtr<Box<dyn SecondaryEffect>>) {
|
|
drop_in_place(ptr)
|
|
}
|
|
|
|
/// The chance the effect triggers.
|
|
#[no_mangle]
|
|
unsafe extern "C" fn secondary_effect_chance(ptr: ExternPointer<Box<dyn SecondaryEffect>>) -> f32 {
|
|
ptr.as_ref().chance()
|
|
}
|
|
|
|
/// The name of the effect.
|
|
#[no_mangle]
|
|
unsafe extern "C" fn secondary_effect_effect_name(
|
|
ptr: ExternPointer<Box<dyn SecondaryEffect>>,
|
|
) -> NativeResult<OwnedPtr<c_char>> {
|
|
match CString::new(ptr.as_ref().effect_name().str()) {
|
|
Ok(name) => NativeResult::ok(name.into_raw()),
|
|
Err(_) => NativeResult::err(anyhow!(
|
|
"Unable to convert effect name '{}' to CString",
|
|
ptr.as_ref().effect_name()
|
|
)),
|
|
}
|
|
}
|
|
|
|
/// The length of parameters of the effect.
|
|
#[no_mangle]
|
|
unsafe extern "C" fn secondary_effect_parameter_length(ptr: ExternPointer<Box<dyn SecondaryEffect>>) -> usize {
|
|
ptr.as_ref().parameters().len()
|
|
}
|
|
|
|
/// Get a parameter of the effect.
|
|
#[no_mangle]
|
|
unsafe extern "C" fn secondary_effect_parameter_get(
|
|
ptr: ExternPointer<Box<dyn SecondaryEffect>>,
|
|
index: usize,
|
|
) -> IdentifiablePointer<EffectParameter> {
|
|
if let Some(v) = ptr.as_ref().parameters().get(index) {
|
|
(v as *const EffectParameter).into()
|
|
} else {
|
|
IdentifiablePointer::none()
|
|
}
|
|
}
|