PkmnLib_rs/src/ffi/static_data/move_data.rs

use crate::ffi::{ffi_arc_getter, BorrowedPtr, ExternPointer, IdentifiablePointer, OwnedPtr};
use crate::static_data::{
    EffectParameter, MoveCategory, MoveData, MoveDataImpl, MoveTarget, SecondaryEffect, SecondaryEffectImpl,
    TypeIdentifier,
};
use crate::StringKey;
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,
) -> IdentifiablePointer<Arc<dyn MoveData>> {
    let flags = std::slice::from_raw_parts(flags, flags_length);
    let name: StringKey = CStr::from_ptr(name).to_str().unwrap().into();
    let mut flags_set: HashSet<StringKey> = HashSet::with_capacity(flags_length);
    for flag in flags {
        flags_set.insert(CStr::from_ptr(*flag).to_str().unwrap().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,
    ));
    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>>) -> OwnedPtr<c_char> {
    let name = ptr.as_ref().name();
    CString::new(name.str()).unwrap().into_raw()
}

ffi_arc_getter!(dyn MoveData, move_type, TypeIdentifier);
ffi_arc_getter!(dyn MoveData, category, MoveCategory);
ffi_arc_getter!(dyn MoveData, base_power, u8);
ffi_arc_getter!(dyn MoveData, accuracy, u8);
ffi_arc_getter!(dyn MoveData, base_usages, u8);
ffi_arc_getter!(dyn MoveData, target, MoveTarget);
ffi_arc_getter!(dyn 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>>) -> OwnedPtr<c_char> {
    CString::new(ptr.as_ref().effect_name().str()).unwrap().into_raw()
}

/// 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()
    }
}