spring_ai_rs/ai_interface/callback/command/command_data/
unit.rs

1use spring_ai_sys::{
2    SAiSelectUnitCommand, SAttackAreaUnitCommand, SAttackUnitCommand, SBuildUnitCommand,
3    SCaptureAreaUnitCommand, SCaptureUnitCommand, SCloakUnitCommand, SCustomUnitCommand,
4    SDGunPosUnitCommand, SDGunUnitCommand, SDeathWaitUnitCommand, SFightUnitCommand,
5    SGatherWaitUnitCommand, SGuardUnitCommand, SLoadOntoUnitCommand, SLoadUnitsAreaUnitCommand,
6    SLoadUnitsUnitCommand, SMoveUnitCommand, SPatrolUnitCommand, SReclaimAreaUnitCommand,
7    SReclaimFeatureUnitCommand, SReclaimUnitUnitCommand, SRepairUnitCommand,
8    SRestoreAreaUnitCommand, SResurrectAreaUnitCommand, SResurrectUnitCommand,
9    SSelfDestroyUnitCommand, SSetAutoRepairLevelUnitCommand, SSetBaseUnitCommand,
10    SSetFireStateUnitCommand, SSetIdleModeUnitCommand, SSetMoveStateUnitCommand,
11    SSetOnOffUnitCommand, SSetRepeatUnitCommand, SSetTrajectoryUnitCommand, SSquadWaitUnitCommand,
12    SStockpileUnitCommand, SStopUnitCommand, STimeWaitUnitCommand, SUnloadUnitCommand,
13    SUnloadUnitsAreaUnitCommand, SWaitUnitCommand, UnitCommandOptions as UnitCommandOptions_Sys,
14};
15
16use crate::ai_interface::callback::{
17    command::{
18        command_data::{CData, CommandData},
19        options::UnitCommandOptions,
20    },
21    facing::Facing,
22    fire_state::FireState,
23    idle_mode::IdleMode,
24    move_state::MoveState,
25    trajectory::Trajectory,
26    unit::Unit,
27};
28
29// AI Select Unit command data
30pub struct AiSelectUnitCommandData {
31    pub unit_id: i32,
32    pub group_id: i32,
33    pub options: Vec<UnitCommandOptions>,
34    pub timeout: i32,
35}
36
37impl CommandData for AiSelectUnitCommandData {
38    type CDataType = SAiSelectUnitCommand;
39
40    fn c_data(&mut self) -> Self::CDataType {
41        SAiSelectUnitCommand {
42            unitId: self.unit_id,
43            groupId: self.group_id,
44            options: self
45                .options
46                .iter()
47                .map(|&uco| UnitCommandOptions_Sys::from(uco))
48                .sum::<i32>() as libc::c_short,
49            timeOut: self.timeout,
50        }
51    }
52}
53
54impl CData for SAiSelectUnitCommand {}
55
56// Unit Attack command data
57pub struct AttackUnitCommandData {
58    pub unit_id: i32,
59    pub group_id: i32,
60    pub options: Vec<UnitCommandOptions>,
61    pub timeout: i32,
62    pub target_unit_id: i32,
63}
64
65impl CommandData for AttackUnitCommandData {
66    type CDataType = SAttackUnitCommand;
67
68    fn c_data(&mut self) -> Self::CDataType {
69        SAttackUnitCommand {
70            unitId: self.unit_id,
71            groupId: self.group_id,
72            options: self
73                .options
74                .iter()
75                .map(|&uco| UnitCommandOptions_Sys::from(uco))
76                .sum::<i32>() as libc::c_short,
77            timeOut: self.timeout,
78            toAttackUnitId: self.target_unit_id,
79        }
80    }
81}
82
83impl CData for SAttackUnitCommand {}
84
85// Unit Attack Area command data
86pub struct AttackAreaUnitCommandData {
87    pub unit_id: i32,
88    pub group_id: i32,
89    pub options: Vec<UnitCommandOptions>,
90    pub timeout: i32,
91    pub attack_position: [f32; 3],
92    pub radius: f32,
93}
94
95impl CommandData for AttackAreaUnitCommandData {
96    type CDataType = SAttackAreaUnitCommand;
97
98    fn c_data(&mut self) -> Self::CDataType {
99        SAttackAreaUnitCommand {
100            unitId: self.unit_id,
101            groupId: self.group_id,
102            options: self
103                .options
104                .iter()
105                .map(|&uco| UnitCommandOptions_Sys::from(uco))
106                .sum::<i32>() as libc::c_short,
107            timeOut: self.timeout,
108            toAttackPos_posF3: self.attack_position.as_mut_ptr(),
109            radius: self.radius,
110        }
111    }
112}
113
114impl CData for SAttackAreaUnitCommand {}
115
116// Unit Build command data
117pub struct BuildUnitCommandData {
118    pub unit_id: i32,
119    pub group_id: i32,
120    pub options: Vec<UnitCommandOptions>,
121    pub timeout: i32,
122    pub to_build_unit_def_id: i32,
123    pub build_position: [f32; 3],
124    pub facing: Facing,
125}
126
127impl CommandData for BuildUnitCommandData {
128    type CDataType = SBuildUnitCommand;
129
130    fn c_data(&mut self) -> Self::CDataType {
131        SBuildUnitCommand {
132            unitId: self.unit_id,
133            groupId: self.group_id,
134            options: self
135                .options
136                .iter()
137                .map(|&uco| UnitCommandOptions_Sys::from(uco))
138                .sum::<i32>() as libc::c_short,
139            timeOut: self.timeout,
140            toBuildUnitDefId: self.to_build_unit_def_id,
141            buildPos_posF3: self.build_position.as_mut_ptr(),
142            facing: self.facing.into(),
143        }
144    }
145}
146
147impl CData for SBuildUnitCommand {}
148
149// Unit Capture command data
150pub struct CaptureUnitCommanddData {
151    pub unit_id: i32,
152    pub group_id: i32,
153    pub options: Vec<UnitCommandOptions>,
154    pub timeout: i32,
155    pub to_capture_unit_id: i32,
156}
157
158impl CommandData for CaptureUnitCommanddData {
159    type CDataType = SCaptureUnitCommand;
160
161    fn c_data(&mut self) -> Self::CDataType {
162        SCaptureUnitCommand {
163            unitId: self.unit_id,
164            groupId: self.group_id,
165            options: self
166                .options
167                .iter()
168                .map(|&uco| UnitCommandOptions_Sys::from(uco))
169                .sum::<i32>() as libc::c_short,
170            timeOut: self.timeout,
171            toCaptureUnitId: self.to_capture_unit_id,
172        }
173    }
174}
175
176impl CData for SCaptureUnitCommand {}
177
178// Unit Capture Area command data
179pub struct CaptureAreaUnitCommanddData {
180    pub unit_id: i32,
181    pub group_id: i32,
182    pub options: Vec<UnitCommandOptions>,
183    pub timeout: i32,
184    pub position: [f32; 3],
185    pub radius: f32,
186}
187
188impl CommandData for CaptureAreaUnitCommanddData {
189    type CDataType = SCaptureAreaUnitCommand;
190
191    fn c_data(&mut self) -> Self::CDataType {
192        SCaptureAreaUnitCommand {
193            unitId: self.unit_id,
194            groupId: self.group_id,
195            options: self
196                .options
197                .iter()
198                .map(|&uco| UnitCommandOptions_Sys::from(uco))
199                .sum::<i32>() as libc::c_short,
200            timeOut: self.timeout,
201            pos_posF3: self.position.as_mut_ptr(),
202            radius: self.radius,
203        }
204    }
205}
206
207impl CData for SCaptureAreaUnitCommand {}
208
209// Unit Cloak command data
210pub struct CloakUnitCommandData {
211    pub unit_id: i32,
212    pub group_id: i32,
213    pub options: Vec<UnitCommandOptions>,
214    pub timeout: i32,
215    pub cloak: bool,
216}
217
218impl CommandData for CloakUnitCommandData {
219    type CDataType = SCloakUnitCommand;
220
221    fn c_data(&mut self) -> Self::CDataType {
222        SCloakUnitCommand {
223            unitId: self.unit_id,
224            groupId: self.group_id,
225            options: self
226                .options
227                .iter()
228                .map(|&uco| UnitCommandOptions_Sys::from(uco))
229                .sum::<i32>() as libc::c_short,
230            timeOut: self.timeout,
231            cloak: self.cloak,
232        }
233    }
234}
235
236impl CData for SCloakUnitCommand {}
237
238// Unit Custom command data
239pub struct CustomUnitCommanddData {
240    pub unit_id: i32,
241    pub group_id: i32,
242    pub options: Vec<UnitCommandOptions>,
243    pub timeout: i32,
244    pub command_id: i32,
245    pub parameters: Vec<f32>,
246}
247
248impl CommandData for CustomUnitCommanddData {
249    type CDataType = SCustomUnitCommand;
250
251    fn c_data(&mut self) -> Self::CDataType {
252        SCustomUnitCommand {
253            unitId: self.unit_id,
254            groupId: self.group_id,
255            options: self
256                .options
257                .iter()
258                .map(|&uco| UnitCommandOptions_Sys::from(uco))
259                .sum::<i32>() as libc::c_short,
260            timeOut: self.timeout,
261            cmdId: self.command_id,
262            params: self.parameters.as_mut_ptr(),
263            params_size: self.parameters.len() as i32,
264        }
265    }
266}
267
268impl CData for SCustomUnitCommand {}
269
270// DGun Unit command data
271pub struct DGunUnitCommandData {
272    pub unitId: i32,
273    pub groupId: i32,
274    pub options: Vec<UnitCommandOptions>,
275    pub timeOut: i32,
276    pub toAttackUnitId: i32,
277}
278
279impl CommandData for DGunUnitCommandData {
280    type CDataType = SDGunUnitCommand;
281
282    fn c_data(&mut self) -> Self::CDataType {
283        SDGunUnitCommand {
284            unitId: self.unitId,
285            groupId: self.groupId,
286            options: self
287                .options
288                .iter()
289                .map(|&uco| UnitCommandOptions_Sys::from(uco))
290                .sum::<i32>() as libc::c_short,
291            timeOut: self.timeOut,
292            toAttackUnitId: self.toAttackUnitId,
293        }
294    }
295}
296
297impl CData for SDGunUnitCommand {}
298
299// DGun Position Unit command data
300pub struct DGunPosUnitCommandData {
301    pub unitId: i32,
302    pub groupId: i32,
303    pub options: Vec<UnitCommandOptions>,
304    pub timeOut: i32,
305    pub position: [f32; 3],
306}
307
308impl CommandData for DGunPosUnitCommandData {
309    type CDataType = SDGunPosUnitCommand;
310
311    fn c_data(&mut self) -> Self::CDataType {
312        SDGunPosUnitCommand {
313            unitId: self.unitId,
314            groupId: self.groupId,
315            options: self
316                .options
317                .iter()
318                .map(|&uco| UnitCommandOptions_Sys::from(uco))
319                .sum::<i32>() as libc::c_short,
320            timeOut: self.timeOut,
321            pos_posF3: self.position.as_mut_ptr(),
322        }
323    }
324}
325
326impl CData for SDGunPosUnitCommand {}
327
328// Unit Fight command data
329pub struct FightUnitCommandData {
330    pub unitId: i32,
331    pub groupId: i32,
332    pub options: Vec<UnitCommandOptions>,
333    pub timeOut: i32,
334    pub position: [f32; 3],
335}
336
337impl CommandData for FightUnitCommandData {
338    type CDataType = SFightUnitCommand;
339
340    fn c_data(&mut self) -> Self::CDataType {
341        SFightUnitCommand {
342            unitId: self.unitId,
343            groupId: self.groupId,
344            options: self
345                .options
346                .iter()
347                .map(|&uco| UnitCommandOptions_Sys::from(uco))
348                .sum::<i32>() as libc::c_short,
349            timeOut: self.timeOut,
350            toPos_posF3: self.position.as_mut_ptr(),
351        }
352    }
353}
354
355impl CData for SFightUnitCommand {}
356
357// Unit Guard command data
358pub struct GuardUnitCommandData {
359    pub unitId: i32,
360    pub groupId: i32,
361    pub options: Vec<UnitCommandOptions>,
362    pub timeOut: i32,
363    pub to_guard_unit_id: i32,
364}
365
366impl CommandData for GuardUnitCommandData {
367    type CDataType = SGuardUnitCommand;
368
369    fn c_data(&mut self) -> Self::CDataType {
370        SGuardUnitCommand {
371            unitId: self.unitId,
372            groupId: self.groupId,
373            options: self
374                .options
375                .iter()
376                .map(|&uco| UnitCommandOptions_Sys::from(uco))
377                .sum::<i32>() as libc::c_short,
378            timeOut: self.timeOut,
379            toGuardUnitId: self.to_guard_unit_id,
380        }
381    }
382}
383
384impl CData for SGuardUnitCommand {}
385
386// Unit Load Onto command data
387pub struct LoadOntoUnitCommandData {
388    pub unitId: i32,
389    pub groupId: i32,
390    pub options: Vec<UnitCommandOptions>,
391    pub timeOut: i32,
392    pub transporter_unit_id: i32,
393}
394
395impl CommandData for LoadOntoUnitCommandData {
396    type CDataType = SLoadOntoUnitCommand;
397
398    fn c_data(&mut self) -> Self::CDataType {
399        SLoadOntoUnitCommand {
400            unitId: self.unitId,
401            groupId: self.groupId,
402            options: self
403                .options
404                .iter()
405                .map(|&uco| UnitCommandOptions_Sys::from(uco))
406                .sum::<i32>() as libc::c_short,
407            timeOut: self.timeOut,
408            transporterUnitId: self.transporter_unit_id,
409        }
410    }
411}
412
413impl CData for SLoadOntoUnitCommand {}
414
415// Unit Load Units command data
416pub struct LoadUnitsUnitCommandData {
417    pub unitId: i32,
418    pub groupId: i32,
419    pub options: Vec<UnitCommandOptions>,
420    pub timeOut: i32,
421    pub to_load_unit_ids: Vec<i32>,
422}
423
424impl CommandData for LoadUnitsUnitCommandData {
425    type CDataType = SLoadUnitsUnitCommand;
426
427    fn c_data(&mut self) -> Self::CDataType {
428        SLoadUnitsUnitCommand {
429            unitId: self.unitId,
430            groupId: self.groupId,
431            options: self
432                .options
433                .iter()
434                .map(|&uco| UnitCommandOptions_Sys::from(uco))
435                .sum::<i32>() as libc::c_short,
436            timeOut: self.timeOut,
437            toLoadUnitIds: self.to_load_unit_ids.as_mut_ptr(),
438            toLoadUnitIds_size: self.to_load_unit_ids.len() as i32,
439        }
440    }
441}
442
443impl CData for SLoadUnitsUnitCommand {}
444
445// Unit Load Units in Area command data
446pub struct LoadUnitsAreaCommandData {
447    pub unitId: i32,
448    pub groupId: i32,
449    pub options: Vec<UnitCommandOptions>,
450    pub timeOut: i32,
451    pub position: [f32; 3],
452    pub radius: f32,
453}
454
455impl CommandData for LoadUnitsAreaCommandData {
456    type CDataType = SLoadUnitsAreaUnitCommand;
457
458    fn c_data(&mut self) -> Self::CDataType {
459        SLoadUnitsAreaUnitCommand {
460            unitId: self.unitId,
461            groupId: self.groupId,
462            options: self
463                .options
464                .iter()
465                .map(|&uco| UnitCommandOptions_Sys::from(uco))
466                .sum::<i32>() as libc::c_short,
467            timeOut: self.timeOut,
468            pos_posF3: self.position.as_mut_ptr(),
469            radius: self.radius,
470        }
471    }
472}
473
474impl CData for SLoadUnitsAreaUnitCommand {}
475
476// Move Unit command data
477pub struct MoveUnitCommandData {
478    pub unit_id: i32,
479    pub group_id: i32,
480    pub options: Vec<UnitCommandOptions>,
481    pub timeout: i32,
482    pub to_pos: [f32; 3],
483}
484
485impl CommandData for MoveUnitCommandData {
486    type CDataType = SMoveUnitCommand;
487
488    fn c_data(&mut self) -> Self::CDataType {
489        SMoveUnitCommand {
490            unitId: self.unit_id,
491            groupId: self.group_id,
492            options: self
493                .options
494                .iter()
495                .map(|&uco| UnitCommandOptions_Sys::from(uco))
496                .sum::<i32>() as libc::c_short,
497            timeOut: self.timeout,
498            toPos_posF3: self.to_pos.as_mut_ptr(),
499        }
500    }
501}
502
503impl CData for SMoveUnitCommand {}
504
505// Unit Patrol command data
506pub struct PatrolUnitCommandData {
507    pub unit_id: i32,
508    pub group_id: i32,
509    pub options: Vec<UnitCommandOptions>,
510    pub timeout: i32,
511    pub to_pos: [f32; 3],
512}
513
514impl CommandData for PatrolUnitCommandData {
515    type CDataType = SPatrolUnitCommand;
516
517    fn c_data(&mut self) -> Self::CDataType {
518        SPatrolUnitCommand {
519            unitId: self.unit_id,
520            groupId: self.group_id,
521            options: self
522                .options
523                .iter()
524                .map(|&uco| UnitCommandOptions_Sys::from(uco))
525                .sum::<i32>() as libc::c_short,
526            timeOut: self.timeout,
527            toPos_posF3: self.to_pos.as_mut_ptr(),
528        }
529    }
530}
531
532impl CData for SPatrolUnitCommand {}
533
534// Unit Reclaim Area command data
535pub struct ReclaimAreaUnitCommandData {
536    pub unit_id: i32,
537    pub group_id: i32,
538    pub options: Vec<UnitCommandOptions>,
539    pub timeout: i32,
540    pub position: [f32; 3],
541    pub radius: f32,
542}
543
544impl CommandData for ReclaimAreaUnitCommandData {
545    type CDataType = SReclaimAreaUnitCommand;
546
547    fn c_data(&mut self) -> Self::CDataType {
548        SReclaimAreaUnitCommand {
549            unitId: self.unit_id,
550            groupId: self.group_id,
551            options: self
552                .options
553                .iter()
554                .map(|&uco| UnitCommandOptions_Sys::from(uco))
555                .sum::<i32>() as libc::c_short,
556            timeOut: self.timeout,
557            pos_posF3: self.position.as_mut_ptr(),
558            radius: self.radius,
559        }
560    }
561}
562
563impl CData for SReclaimAreaUnitCommand {}
564
565// Unit Reclaim Feature command data
566pub struct ReclaimFeatureUnitCommandData {
567    pub unit_id: i32,
568    pub group_id: i32,
569    pub options: Vec<UnitCommandOptions>,
570    pub timeout: i32,
571    pub to_reclaim_feature_id: i32,
572}
573
574impl CommandData for ReclaimFeatureUnitCommandData {
575    type CDataType = SReclaimFeatureUnitCommand;
576
577    fn c_data(&mut self) -> Self::CDataType {
578        SReclaimFeatureUnitCommand {
579            unitId: self.unit_id,
580            groupId: self.group_id,
581            options: self
582                .options
583                .iter()
584                .map(|&uco| UnitCommandOptions_Sys::from(uco))
585                .sum::<i32>() as libc::c_short,
586            timeOut: self.timeout,
587            toReclaimFeatureId: self.to_reclaim_feature_id,
588        }
589    }
590}
591
592impl CData for SReclaimFeatureUnitCommand {}
593
594// Unit Reclaim Unit command data
595pub struct ReclaimUnitUnitCommandData {
596    pub unit_id: i32,
597    pub group_id: i32,
598    pub options: Vec<UnitCommandOptions>,
599    pub timeout: i32,
600    pub to_reclaim_unit_id: i32,
601}
602
603impl CommandData for ReclaimUnitUnitCommandData {
604    type CDataType = SReclaimUnitUnitCommand;
605
606    fn c_data(&mut self) -> Self::CDataType {
607        SReclaimUnitUnitCommand {
608            unitId: self.unit_id,
609            groupId: self.group_id,
610            options: self
611                .options
612                .iter()
613                .map(|&uco| UnitCommandOptions_Sys::from(uco))
614                .sum::<i32>() as libc::c_short,
615            timeOut: self.timeout,
616            toReclaimUnitId: self.to_reclaim_unit_id,
617        }
618    }
619}
620
621impl CData for SReclaimUnitUnitCommand {}
622
623// Unit Repair Unit command data
624pub struct RepairUnitCommandData {
625    pub unit_id: i32,
626    pub group_id: i32,
627    pub options: Vec<UnitCommandOptions>,
628    pub timeout: i32,
629    pub to_repair_unit_id: i32,
630}
631
632impl CommandData for RepairUnitCommandData {
633    type CDataType = SRepairUnitCommand;
634
635    fn c_data(&mut self) -> Self::CDataType {
636        SRepairUnitCommand {
637            unitId: self.unit_id,
638            groupId: self.group_id,
639            options: self
640                .options
641                .iter()
642                .map(|&uco| UnitCommandOptions_Sys::from(uco))
643                .sum::<i32>() as libc::c_short,
644            timeOut: self.timeout,
645            toRepairUnitId: self.to_repair_unit_id,
646        }
647    }
648}
649
650impl CData for SRepairUnitCommand {}
651
652// Unit Restore Area command data
653pub struct RestoreAreaUnitCommandData {
654    pub unit_id: i32,
655    pub group_id: i32,
656    pub options: Vec<UnitCommandOptions>,
657    pub timeout: i32,
658    pub position: [f32; 3],
659    pub radius: f32,
660}
661
662impl CommandData for RestoreAreaUnitCommandData {
663    type CDataType = SRestoreAreaUnitCommand;
664
665    fn c_data(&mut self) -> Self::CDataType {
666        SRestoreAreaUnitCommand {
667            unitId: self.unit_id,
668            groupId: self.group_id,
669            options: self
670                .options
671                .iter()
672                .map(|&uco| UnitCommandOptions_Sys::from(uco))
673                .sum::<i32>() as libc::c_short,
674            timeOut: self.timeout,
675            pos_posF3: self.position.as_mut_ptr(),
676            radius: self.radius,
677        }
678    }
679}
680
681impl CData for SRestoreAreaUnitCommand {}
682
683// Unit Resurrect command data
684pub struct ResurrectUnitCommandData {
685    pub unit_id: i32,
686    pub group_id: i32,
687    pub options: Vec<UnitCommandOptions>,
688    pub timeout: i32,
689    pub to_resurrect_feature_id: i32,
690}
691
692impl CommandData for ResurrectUnitCommandData {
693    type CDataType = SResurrectUnitCommand;
694
695    fn c_data(&mut self) -> Self::CDataType {
696        SResurrectUnitCommand {
697            unitId: self.unit_id,
698            groupId: self.group_id,
699            options: self
700                .options
701                .iter()
702                .map(|&uco| UnitCommandOptions_Sys::from(uco))
703                .sum::<i32>() as libc::c_short,
704            timeOut: self.timeout,
705            toResurrectFeatureId: self.to_resurrect_feature_id,
706        }
707    }
708}
709
710impl CData for SResurrectUnitCommand {}
711
712// Unit Resurrect Area command data
713pub struct ResurrectAreaUnitCommandData {
714    pub unit_id: i32,
715    pub group_id: i32,
716    pub options: Vec<UnitCommandOptions>,
717    pub timeout: i32,
718    pub position: [f32; 3],
719    pub radius: f32,
720}
721
722impl CommandData for ResurrectAreaUnitCommandData {
723    type CDataType = SResurrectAreaUnitCommand;
724
725    fn c_data(&mut self) -> Self::CDataType {
726        SResurrectAreaUnitCommand {
727            unitId: self.unit_id,
728            groupId: self.group_id,
729            options: self
730                .options
731                .iter()
732                .map(|&uco| UnitCommandOptions_Sys::from(uco))
733                .sum::<i32>() as libc::c_short,
734            timeOut: self.timeout,
735            pos_posF3: self.position.as_mut_ptr(),
736            radius: self.radius,
737        }
738    }
739}
740
741impl CData for SResurrectAreaUnitCommand {}
742
743// Unit Self Destroy command data
744pub struct SelfDestroyUnitCommandData {
745    pub unit_id: i32,
746    pub group_id: i32,
747    pub options: Vec<UnitCommandOptions>,
748    pub timeout: i32,
749}
750
751impl CommandData for SelfDestroyUnitCommandData {
752    type CDataType = SSelfDestroyUnitCommand;
753
754    fn c_data(&mut self) -> Self::CDataType {
755        SSelfDestroyUnitCommand {
756            unitId: self.unit_id,
757            groupId: self.group_id,
758            options: self
759                .options
760                .iter()
761                .map(|&uco| UnitCommandOptions_Sys::from(uco))
762                .sum::<i32>() as libc::c_short,
763            timeOut: self.timeout,
764        }
765    }
766}
767
768impl CData for SSelfDestroyUnitCommand {}
769
770// Unit Set Auto Repair Level command data
771pub struct SetAutoRepairLevelUnitCommandData {
772    pub unit_id: i32,
773    pub group_id: i32,
774    pub options: Vec<UnitCommandOptions>,
775    pub timeout: i32,
776    pub auto_repair_level: i32,
777}
778
779impl CommandData for SetAutoRepairLevelUnitCommandData {
780    type CDataType = SSetAutoRepairLevelUnitCommand;
781
782    fn c_data(&mut self) -> Self::CDataType {
783        SSetAutoRepairLevelUnitCommand {
784            unitId: self.unit_id,
785            groupId: self.group_id,
786            options: self
787                .options
788                .iter()
789                .map(|&uco| UnitCommandOptions_Sys::from(uco))
790                .sum::<i32>() as libc::c_short,
791            timeOut: self.timeout,
792            autoRepairLevel: self.auto_repair_level,
793        }
794    }
795}
796
797impl CData for SSetAutoRepairLevelUnitCommand {}
798
799// Unit Set Base command data
800pub struct SetBaseUnitCommandData {
801    pub unit_id: i32,
802    pub group_id: i32,
803    pub options: Vec<UnitCommandOptions>,
804    pub timeout: i32,
805    pub base_position: [f32; 3],
806}
807
808impl CommandData for SetBaseUnitCommandData {
809    type CDataType = SSetBaseUnitCommand;
810
811    fn c_data(&mut self) -> Self::CDataType {
812        SSetBaseUnitCommand {
813            unitId: self.unit_id,
814            groupId: self.group_id,
815            options: self
816                .options
817                .iter()
818                .map(|&uco| UnitCommandOptions_Sys::from(uco))
819                .sum::<i32>() as libc::c_short,
820            timeOut: self.timeout,
821            basePos_posF3: self.base_position.as_mut_ptr(),
822        }
823    }
824}
825
826impl CData for SSetBaseUnitCommand {}
827
828// Unit Set Fire State command data
829pub struct SetFireUnitCommandData {
830    pub unit_id: i32,
831    pub group_id: i32,
832    pub options: Vec<UnitCommandOptions>,
833    pub timeout: i32,
834    pub fire_state: FireState,
835}
836
837impl CommandData for SetFireUnitCommandData {
838    type CDataType = SSetFireStateUnitCommand;
839
840    fn c_data(&mut self) -> Self::CDataType {
841        SSetFireStateUnitCommand {
842            unitId: self.unit_id,
843            groupId: self.group_id,
844            options: self
845                .options
846                .iter()
847                .map(|&uco| UnitCommandOptions_Sys::from(uco))
848                .sum::<i32>() as libc::c_short,
849            timeOut: self.timeout,
850            fireState: self.fire_state.into(),
851        }
852    }
853}
854
855impl CData for SSetFireStateUnitCommand {}
856
857// Unit Set Idle Mode command data
858pub struct SetIdleModeCommandData {
859    pub unit_id: i32,
860    pub group_id: i32,
861    pub options: Vec<UnitCommandOptions>,
862    pub timeout: i32,
863    pub idle_mode: IdleMode,
864}
865
866impl CommandData for SetIdleModeCommandData {
867    type CDataType = SSetIdleModeUnitCommand;
868
869    fn c_data(&mut self) -> Self::CDataType {
870        SSetIdleModeUnitCommand {
871            unitId: self.unit_id,
872            groupId: self.group_id,
873            options: self
874                .options
875                .iter()
876                .map(|&uco| UnitCommandOptions_Sys::from(uco))
877                .sum::<i32>() as libc::c_short,
878            timeOut: self.timeout,
879            idleMode: self.idle_mode.into(),
880        }
881    }
882}
883
884impl CData for SSetIdleModeUnitCommand {}
885
886// Unit Set Move State command data
887pub struct SetMoveStateCommandData {
888    pub unit_id: i32,
889    pub group_id: i32,
890    pub options: Vec<UnitCommandOptions>,
891    pub timeout: i32,
892    pub move_state: MoveState,
893}
894
895impl CommandData for SetMoveStateCommandData {
896    type CDataType = SSetMoveStateUnitCommand;
897
898    fn c_data(&mut self) -> Self::CDataType {
899        SSetMoveStateUnitCommand {
900            unitId: self.unit_id,
901            groupId: self.group_id,
902            options: self
903                .options
904                .iter()
905                .map(|&uco| UnitCommandOptions_Sys::from(uco))
906                .sum::<i32>() as libc::c_short,
907            timeOut: self.timeout,
908            moveState: self.move_state.into(),
909        }
910    }
911}
912
913impl CData for SSetMoveStateUnitCommand {}
914
915// Unit Set On/Off command data
916pub struct SetUnitOnOffCommandData {
917    pub unit_id: i32,
918    pub group_id: i32,
919    pub options: Vec<UnitCommandOptions>,
920    pub timeout: i32,
921    pub on: bool,
922}
923
924impl CommandData for SetUnitOnOffCommandData {
925    type CDataType = SSetOnOffUnitCommand;
926
927    fn c_data(&mut self) -> Self::CDataType {
928        SSetOnOffUnitCommand {
929            unitId: self.unit_id,
930            groupId: self.group_id,
931            options: self
932                .options
933                .iter()
934                .map(|&uco| UnitCommandOptions_Sys::from(uco))
935                .sum::<i32>() as libc::c_short,
936            timeOut: self.timeout,
937            on: self.on,
938        }
939    }
940}
941
942impl CData for SSetOnOffUnitCommand {}
943
944// Unit Set Repeat command data
945pub struct SetUnitRepeatCommandData {
946    pub unit_id: i32,
947    pub group_id: i32,
948    pub options: Vec<UnitCommandOptions>,
949    pub timeout: i32,
950    pub repeat: bool,
951}
952
953impl CommandData for SetUnitRepeatCommandData {
954    type CDataType = SSetRepeatUnitCommand;
955
956    fn c_data(&mut self) -> Self::CDataType {
957        SSetRepeatUnitCommand {
958            unitId: self.unit_id,
959            groupId: self.group_id,
960            options: self
961                .options
962                .iter()
963                .map(|&uco| UnitCommandOptions_Sys::from(uco))
964                .sum::<i32>() as libc::c_short,
965            timeOut: self.timeout,
966            repeat: self.repeat,
967        }
968    }
969}
970
971impl CData for SSetRepeatUnitCommand {}
972
973// Unit Set Trajectory command data
974pub struct SetUnitTrajectoryCommandData {
975    pub unit_id: i32,
976    pub group_id: i32,
977    pub options: Vec<UnitCommandOptions>,
978    pub timeout: i32,
979    pub trajectory: Trajectory,
980}
981
982impl CommandData for SetUnitTrajectoryCommandData {
983    type CDataType = SSetTrajectoryUnitCommand;
984
985    fn c_data(&mut self) -> Self::CDataType {
986        SSetTrajectoryUnitCommand {
987            unitId: self.unit_id,
988            groupId: self.group_id,
989            options: self
990                .options
991                .iter()
992                .map(|&uco| UnitCommandOptions_Sys::from(uco))
993                .sum::<i32>() as libc::c_short,
994            timeOut: self.timeout,
995            trajectory: self.trajectory.into(),
996        }
997    }
998}
999
1000impl CData for SSetTrajectoryUnitCommand {}
1001
1002// Unit Stockpile command data
1003pub struct SetUnitStockpileCommandData {
1004    pub unit_id: i32,
1005    pub group_id: i32,
1006    pub options: Vec<UnitCommandOptions>,
1007    pub timeout: i32,
1008}
1009
1010impl CommandData for SetUnitStockpileCommandData {
1011    type CDataType = SStockpileUnitCommand;
1012
1013    fn c_data(&mut self) -> Self::CDataType {
1014        SStockpileUnitCommand {
1015            unitId: self.unit_id,
1016            groupId: self.group_id,
1017            options: self
1018                .options
1019                .iter()
1020                .map(|&uco| UnitCommandOptions_Sys::from(uco))
1021                .sum::<i32>() as libc::c_short,
1022            timeOut: self.timeout,
1023        }
1024    }
1025}
1026
1027impl CData for SStockpileUnitCommand {}
1028
1029// Unit Stop command data
1030pub struct SetUnitStopCommandData {
1031    pub unit_id: i32,
1032    pub group_id: i32,
1033    pub options: Vec<UnitCommandOptions>,
1034    pub timeout: i32,
1035}
1036
1037impl CommandData for SetUnitStopCommandData {
1038    type CDataType = SStopUnitCommand;
1039
1040    fn c_data(&mut self) -> Self::CDataType {
1041        SStopUnitCommand {
1042            unitId: self.unit_id,
1043            groupId: self.group_id,
1044            options: self
1045                .options
1046                .iter()
1047                .map(|&uco| UnitCommandOptions_Sys::from(uco))
1048                .sum::<i32>() as libc::c_short,
1049            timeOut: self.timeout,
1050        }
1051    }
1052}
1053
1054impl CData for SStopUnitCommand {}
1055
1056// Unit Unload command data
1057pub struct SetUnitUnloadCommandData {
1058    pub unit_id: i32,
1059    pub group_id: i32,
1060    pub options: Vec<UnitCommandOptions>,
1061    pub timeout: i32,
1062    pub position: [f32; 3],
1063    pub to_unload_unit_id: i32,
1064}
1065
1066impl CommandData for SetUnitUnloadCommandData {
1067    type CDataType = SUnloadUnitCommand;
1068
1069    fn c_data(&mut self) -> Self::CDataType {
1070        SUnloadUnitCommand {
1071            unitId: self.unit_id,
1072            groupId: self.group_id,
1073            options: self
1074                .options
1075                .iter()
1076                .map(|&uco| UnitCommandOptions_Sys::from(uco))
1077                .sum::<i32>() as libc::c_short,
1078            timeOut: self.timeout,
1079            toPos_posF3: self.position.as_mut_ptr(),
1080            toUnloadUnitId: self.to_unload_unit_id,
1081        }
1082    }
1083}
1084
1085impl CData for SUnloadUnitCommand {}
1086
1087// Unit Unload Area command data
1088pub struct SetUnitUnloadAreaCommandData {
1089    pub unit_id: i32,
1090    pub group_id: i32,
1091    pub options: Vec<UnitCommandOptions>,
1092    pub timeout: i32,
1093    pub position: [f32; 3],
1094    pub radius: f32,
1095}
1096
1097impl CommandData for SetUnitUnloadAreaCommandData {
1098    type CDataType = SUnloadUnitsAreaUnitCommand;
1099
1100    fn c_data(&mut self) -> Self::CDataType {
1101        SUnloadUnitsAreaUnitCommand {
1102            unitId: self.unit_id,
1103            groupId: self.group_id,
1104            options: self
1105                .options
1106                .iter()
1107                .map(|&uco| UnitCommandOptions_Sys::from(uco))
1108                .sum::<i32>() as libc::c_short,
1109            timeOut: self.timeout,
1110            toPos_posF3: self.position.as_mut_ptr(),
1111            radius: self.radius,
1112        }
1113    }
1114}
1115
1116impl CData for SUnloadUnitsAreaUnitCommand {}
1117
1118// Unit Wait command data
1119pub struct SetUnitWaitCommandData {
1120    pub unit_id: i32,
1121    pub group_id: i32,
1122    pub options: Vec<UnitCommandOptions>,
1123    pub timeout: i32,
1124}
1125
1126impl CommandData for SetUnitWaitCommandData {
1127    type CDataType = SWaitUnitCommand;
1128
1129    fn c_data(&mut self) -> Self::CDataType {
1130        SWaitUnitCommand {
1131            unitId: self.unit_id,
1132            groupId: self.group_id,
1133            options: self
1134                .options
1135                .iter()
1136                .map(|&uco| UnitCommandOptions_Sys::from(uco))
1137                .sum::<i32>() as libc::c_short,
1138            timeOut: self.timeout,
1139        }
1140    }
1141}
1142
1143impl CData for SWaitUnitCommand {}
1144
1145// Unit Wait Death command data
1146pub struct SetUnitWaitDeathCommandData {
1147    pub unit_id: i32,
1148    pub group_id: i32,
1149    pub options: Vec<UnitCommandOptions>,
1150    pub timeout: i32,
1151    pub to_die_unit: Unit,
1152}
1153
1154impl CommandData for SetUnitWaitDeathCommandData {
1155    type CDataType = SDeathWaitUnitCommand;
1156
1157    fn c_data(&mut self) -> Self::CDataType {
1158        SDeathWaitUnitCommand {
1159            unitId: self.unit_id,
1160            groupId: self.group_id,
1161            options: self
1162                .options
1163                .iter()
1164                .map(|&uco| UnitCommandOptions_Sys::from(uco))
1165                .sum::<i32>() as libc::c_short,
1166            timeOut: self.timeout,
1167            toDieUnitId: 0,
1168        }
1169    }
1170}
1171
1172impl CData for SDeathWaitUnitCommand {}
1173
1174// Unit Wait Gather command data
1175pub struct SetUnitWaitGatherCommandData {
1176    pub unit_id: i32,
1177    pub group_id: i32,
1178    pub options: Vec<UnitCommandOptions>,
1179    pub timeout: i32,
1180}
1181
1182impl CommandData for SetUnitWaitGatherCommandData {
1183    type CDataType = SGatherWaitUnitCommand;
1184
1185    fn c_data(&mut self) -> Self::CDataType {
1186        SGatherWaitUnitCommand {
1187            unitId: self.unit_id,
1188            groupId: self.group_id,
1189            options: self
1190                .options
1191                .iter()
1192                .map(|&uco| UnitCommandOptions_Sys::from(uco))
1193                .sum::<i32>() as libc::c_short,
1194            timeOut: self.timeout,
1195        }
1196    }
1197}
1198
1199impl CData for SGatherWaitUnitCommand {}
1200
1201// Unit Wait Squad command data
1202pub struct SetUnitWaitSquadCommandData {
1203    pub unit_id: i32,
1204    pub group_id: i32,
1205    pub options: Vec<UnitCommandOptions>,
1206    pub timeout: i32,
1207    pub num_units: i32,
1208}
1209
1210impl CommandData for SetUnitWaitSquadCommandData {
1211    type CDataType = SSquadWaitUnitCommand;
1212
1213    fn c_data(&mut self) -> Self::CDataType {
1214        SSquadWaitUnitCommand {
1215            unitId: self.unit_id,
1216            groupId: self.group_id,
1217            options: self
1218                .options
1219                .iter()
1220                .map(|&uco| UnitCommandOptions_Sys::from(uco))
1221                .sum::<i32>() as libc::c_short,
1222            timeOut: self.timeout,
1223            numUnits: self.num_units,
1224        }
1225    }
1226}
1227
1228impl CData for SSquadWaitUnitCommand {}
1229
1230// Unit Wait Time command data
1231pub struct SetUnitWaitTimeCommandData {
1232    pub unit_id: i32,
1233    pub group_id: i32,
1234    pub options: Vec<UnitCommandOptions>,
1235    pub timeout: i32,
1236    pub time: i32,
1237}
1238
1239impl CommandData for SetUnitWaitTimeCommandData {
1240    type CDataType = STimeWaitUnitCommand;
1241
1242    fn c_data(&mut self) -> Self::CDataType {
1243        STimeWaitUnitCommand {
1244            unitId: self.unit_id,
1245            groupId: self.group_id,
1246            options: self
1247                .options
1248                .iter()
1249                .map(|&uco| UnitCommandOptions_Sys::from(uco))
1250                .sum::<i32>() as libc::c_short,
1251            timeOut: self.timeout,
1252            time: self.time,
1253        }
1254    }
1255}
1256
1257impl CData for STimeWaitUnitCommand {}
spring_ai_rs/ai_interface/callback/command/command_data/unit.rs

spring_ai_rs/ai_interface/callback/command/command_data/
unit.rs
