Registration of MoveTurnChoices

pkmn_lib_interface/src/app_interface/dynamic_data/turn_choices.rs

@@ -1,7 +1,8 @@
-use crate::app_interface::Pokemon;
+use crate::app_interface::{LearnedMove, Pokemon};
 use crate::handling::cached_value::CachedValue;
 use crate::handling::temporary::Temporary;
-use crate::{cached_value, ExternRef, ExternalReferenceType};
+use crate::{cached_value, wasm_value_getters, ExternRef, ExternalReferenceType, Script};
+use alloc::boxed::Box;
 use alloc::rc::Rc;
 
 struct BaseTurnChoiceData {
@@ -11,6 +12,9 @@ struct BaseTurnChoiceData {
 
 struct MoveTurnChoiceDataInner {
     base: BaseTurnChoiceData,
+    used_move: CachedValue<LearnedMove>,
+    target_side: CachedValue<u8>,
+    target_index: CachedValue<u8>,
 }
 #[derive(Clone)]
 struct MoveTurnChoiceDataTemporary {
@@ -29,12 +33,50 @@ pub enum TurnChoice {
 }
 
 impl TurnChoice {
-    pub fn user(&self) -> Pokemon {
+    fn base(&self) -> &BaseTurnChoiceData {
         match self {
-            TurnChoice::Move(data) => data.temp.value().inner.base.user.value(),
-            _ => panic!("Unknown turn choice type"),
+            TurnChoice::Move(d) => &d.temp.value_ref().inner.base,
+            TurnChoice::Item() => unimplemented!(),
+            TurnChoice::Switch() => unimplemented!(),
+            TurnChoice::Flee => unimplemented!(),
+            TurnChoice::Pass => unimplemented!(),
         }
     }
+
+    pub fn user(&self) -> Pokemon {
+        self.base().user.value()
+    }
+
+    pub fn speed(&self) -> u32 {
+        unsafe { turn_choice_get_speed(self.base().reference) }
+    }
+
+    pub fn has_failed(&self) -> bool {
+        unsafe { turn_choice_has_failed(self.base().reference) }
+    }
+
+    pub fn fail(&self) {
+        unsafe { turn_choice_fail(self.base().reference) }
+    }
+}
+
+impl MoveTurnChoiceData {
+    pub fn used_move(&self) -> LearnedMove {
+        self.temp.value().inner.used_move.value()
+    }
+    pub fn target_side(&self) -> u8 {
+        self.temp.value().inner.target_side.value()
+    }
+    pub fn target_index(&self) -> u8 {
+        self.temp.value().inner.target_index.value()
+    }
+    pub fn priority(&self) -> i8 {
+        unsafe { turn_choice_move_priority(self.temp.value().inner.base.reference.cast()) }
+    }
+
+    pub fn move_script(&self) -> Option<&Box<dyn Script>> {
+        unsafe { turn_choice_move_script(self.temp.value().inner.base.reference.cast()).as_ref() }
+    }
 }
 
 impl ExternalReferenceType for TurnChoice {
@@ -59,6 +101,13 @@ impl ExternalReferenceType for MoveTurnChoiceDataTemporary {
                         turn_choice_get_user(reference.cast()).get_value().unwrap()
                     }),
                 },
+                used_move: cached_value!({
+                    turn_choice_move_used_move(reference.cast())
+                        .get_value()
+                        .unwrap()
+                }),
+                target_side: cached_value!({ turn_choice_move_target_side(reference.cast()) }),
+                target_index: cached_value!({ turn_choice_move_target_index(reference.cast()) }),
             }),
         }
     }
@@ -67,6 +116,15 @@ impl ExternalReferenceType for MoveTurnChoiceDataTemporary {
 extern "wasm" {
     fn turn_choice_get_kind(r: ExternRef<TurnChoice>) -> u8;
     fn turn_choice_get_user(r: ExternRef<TurnChoice>) -> ExternRef<Pokemon>;
+    fn turn_choice_get_speed(r: ExternRef<TurnChoice>) -> u32;
+    fn turn_choice_has_failed(r: ExternRef<TurnChoice>) -> bool;
+    fn turn_choice_fail(r: ExternRef<TurnChoice>);
+
+    fn turn_choice_move_used_move(r: ExternRef<MoveTurnChoiceData>) -> ExternRef<LearnedMove>;
+    fn turn_choice_move_target_side(r: ExternRef<MoveTurnChoiceData>) -> u8;
+    fn turn_choice_move_target_index(r: ExternRef<MoveTurnChoiceData>) -> u8;
+    fn turn_choice_move_priority(r: ExternRef<MoveTurnChoiceData>) -> i8;
+    fn turn_choice_move_script(r: ExternRef<MoveTurnChoiceData>) -> *const Box<dyn Script>;
 }
 
 #[no_mangle]