FFI for Turn Choices

src/ffi/dynamic_data/choices.rs

@@ -0,0 +1,104 @@
+use crate::dynamic_data::{FleeChoice, LearnedMove, MoveChoice, PassChoice, Pokemon, TurnChoice};
+use crate::ffi::{ExternPointer, IdentifiablePointer, OwnedPtr};
+use std::ptr::drop_in_place;
+use std::sync::Arc;
+
+/// Disposes a turn choice.
+#[no_mangle]
+extern "C" fn turn_choice_drop(choice: OwnedPtr<TurnChoice>) {
+    unsafe { drop_in_place(choice) }
+}
+
+/// Get the user of the given choice.
+#[no_mangle]
+extern "C" fn turn_choice_user(choice: ExternPointer<TurnChoice>) -> IdentifiablePointer<Arc<Pokemon>> {
+    choice.as_ref().user().clone().into()
+}
+
+/// Get the speed of the user for the choice. Note that this speed is the speed of the Pokemon
+/// at the start of the turn!
+#[no_mangle]
+extern "C" fn turn_choice_speed(choice: ExternPointer<TurnChoice>) -> u32 {
+    choice.as_ref().speed()
+}
+
+/// Gets whether or not the choice has failed. If we notice this when we execute the choice, we
+/// will not execute it.
+#[no_mangle]
+extern "C" fn turn_choice_has_failed(choice: ExternPointer<TurnChoice>) -> u8 {
+    u8::from(choice.as_ref().has_failed())
+}
+
+/// Fails the choice. This will prevent it from executing and run a specific fail handling during
+/// execution. Note that this can not be undone.
+#[no_mangle]
+extern "C" fn turn_choice_fail(choice: ExternPointer<TurnChoice>) {
+    choice.as_ref().fail()
+}
+
+/// Creates a new Turn Choice with a move to use.
+#[no_mangle]
+extern "C" fn turn_choice_move_new(
+    user: ExternPointer<Arc<Pokemon>>,
+    learned_move: ExternPointer<Arc<LearnedMove>>,
+    target_side: u8,
+    target_index: u8,
+) -> IdentifiablePointer<TurnChoice> {
+    Box::new(TurnChoice::Move(MoveChoice::new(
+        user.as_ref().clone(),
+        learned_move.as_ref().clone(),
+        target_side,
+        target_index,
+    )))
+    .into()
+}
+
+/// The actual learned move on the Pokemon we use for this choice.
+#[no_mangle]
+extern "C" fn turn_choice_move_learned_move(
+    choice: ExternPointer<TurnChoice>,
+) -> IdentifiablePointer<Arc<LearnedMove>> {
+    if let TurnChoice::Move(c) = choice.as_ref() {
+        return c.used_move().clone().into();
+    }
+    panic!("Turn choice was not a learned move");
+}
+
+/// The target side the move is aimed at.
+#[no_mangle]
+extern "C" fn turn_choice_move_target_side(choice: ExternPointer<TurnChoice>) -> u8 {
+    if let TurnChoice::Move(c) = choice.as_ref() {
+        return c.target_side();
+    }
+    panic!("Turn choice was not a learned move");
+}
+
+/// The Pokemon index on the side we're aiming at.
+#[no_mangle]
+extern "C" fn turn_choice_move_target_index(choice: ExternPointer<TurnChoice>) -> u8 {
+    if let TurnChoice::Move(c) = choice.as_ref() {
+        return c.target_index();
+    }
+    panic!("Turn choice was not a learned move");
+}
+
+/// The priority of the move choice at the beginning of the turn.
+#[no_mangle]
+extern "C" fn turn_choice_move_priority(choice: ExternPointer<TurnChoice>) -> i8 {
+    if let TurnChoice::Move(c) = choice.as_ref() {
+        return c.priority();
+    }
+    panic!("Turn choice was not a learned move");
+}
+
+/// Creates a new Turn Choice for the user to flee.
+#[no_mangle]
+extern "C" fn turn_choice_flee_new(user: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<TurnChoice> {
+    Box::new(TurnChoice::Flee(FleeChoice::new(user.as_ref().clone()))).into()
+}
+
+/// Creates a new Turn Choice for the user to pass the turn.
+#[no_mangle]
+extern "C" fn turn_choice_pass_new(user: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<TurnChoice> {
+    Box::new(TurnChoice::Pass(PassChoice::new(user.as_ref().clone()))).into()
+}

src/ffi/dynamic_data/mod.rs

@@ -1,3 +1,5 @@
+/// The foreign function interfaces for the turn choices
+mod choices;
 /// The foreign function interfaces for the dynamic data libraries
 mod libraries;
 /// The foreign function interfaces for the dynamic data models