spring_ai_rs/ai_interface/callback/
skirmish_ai.rs

1use std::{collections::HashMap, error::Error, ffi::CStr};
2
3use crate::{ai_interface::AIInterface, get_callback};
4
5#[derive(Debug, Copy, Clone)]
6pub struct SkirmishAI {
7    ai_id: i32,
8}
9
10#[derive(Debug, Clone)]
11pub struct SkirmishAIAll {
12    number_of_ais: i32,
13    max_number_of_ais: i32,
14    team: i32,
15    info: HashMap<String, (String, String)>,
16    options: HashMap<String, String>,
17}
18
19impl AIInterface {
20    pub fn skirmish_ai(&self) -> SkirmishAI {
21        SkirmishAI { ai_id: self.ai_id }
22    }
23}
24
25impl SkirmishAI {
26    pub fn number_of_ais(&self) -> Result<i32, Box<dyn Error>> {
27        let get_size = get_callback!(self.ai_id, getNumSkirmishAIs)?;
28
29        Ok(unsafe { get_size(self.ai_id) })
30    }
31
32    pub fn max_number_of_ais(&self) -> Result<i32, Box<dyn Error>> {
33        let get_max = get_callback!(self.ai_id, getMaxSkirmishAIs)?;
34
35        Ok(unsafe { get_max(self.ai_id) })
36    }
37
38    pub fn team(&self) -> Result<i32, Box<dyn Error>> {
39        let get_team_id = get_callback!(self.ai_id, SkirmishAI_getTeamId)?;
40
41        Ok(unsafe { get_team_id(self.ai_id) })
42    }
43
44    pub fn info(&self) -> Result<HashMap<String, (String, String)>, Box<dyn Error>> {
45        let get_info_size = get_callback!(self.ai_id, SkirmishAI_Info_getSize)?;
46        let get_info_key = get_callback!(self.ai_id, SkirmishAI_Info_getKey)?;
47        let get_info_value = get_callback!(self.ai_id, SkirmishAI_Info_getValue)?;
48        let get_info_description = get_callback!(self.ai_id, SkirmishAI_Info_getDescription)?;
49
50        let mut info = HashMap::new();
51        let info_size = unsafe { get_info_size(self.ai_id) };
52        for i in 0..info_size {
53            let key =
54                String::from(unsafe { CStr::from_ptr(get_info_key(self.ai_id, i)) }.to_str()?);
55            let value =
56                String::from(unsafe { CStr::from_ptr(get_info_value(self.ai_id, i)) }.to_str()?);
57            let description = String::from(
58                unsafe { CStr::from_ptr(get_info_description(self.ai_id, i)) }.to_str()?,
59            );
60
61            info.insert(key, (value, description));
62        }
63
64        Ok(info)
65    }
66
67    pub fn options(&self) -> Result<HashMap<String, String>, Box<dyn Error>> {
68        let get_options_size = get_callback!(self.ai_id, SkirmishAI_OptionValues_getSize)?;
69        let get_options_key = get_callback!(self.ai_id, SkirmishAI_OptionValues_getKey)?;
70        let get_options_value = get_callback!(self.ai_id, SkirmishAI_OptionValues_getValue)?;
71
72        let mut options = HashMap::new();
73        let options_size = unsafe { get_options_size(self.ai_id) };
74        for i in 0..options_size {
75            let key =
76                String::from(unsafe { CStr::from_ptr(get_options_key(self.ai_id, i)) }.to_str()?);
77            let value =
78                String::from(unsafe { CStr::from_ptr(get_options_value(self.ai_id, i)) }.to_str()?);
79
80            options.insert(key, value);
81        }
82
83        Ok(options)
84    }
85
86    pub fn all(&self) -> Result<SkirmishAIAll, Box<dyn Error>> {
87        Ok(SkirmishAIAll {
88            number_of_ais: self.number_of_ais()?,
89            max_number_of_ais: self.max_number_of_ais()?,
90            team: self.team()?,
91            info: self.info()?,
92            options: self.options()?,
93        })
94    }
95}