Skip to main content

rpfm_lib/files/group_formations/versions/
v2.rs

1//---------------------------------------------------------------------------//
2// Copyright (c) 2017-2026 Ismael Gutiérrez González. All rights reserved.
3//
4// This file is part of the Rusted PackFile Manager (RPFM) project,
5// which can be found here: https://github.com/Frodo45127/rpfm.
6//
7// This file is licensed under the MIT license, which can be found here:
8// https://github.com/Frodo45127/rpfm/blob/master/LICENSE.
9//---------------------------------------------------------------------------//
10
11//! Shared data types for v2 (Rome 2 and later) group formations.
12//!
13//! Used by: Rome 2, Attila, Warhammer, Warhammer 2, Thrones of Britannia,
14//! Three Kingdoms, Troy, Pharaoh, Warhammer 3.
15
16use std::fmt::Display;
17
18use bitflags::bitflags;
19use serde_derive::{Serialize, Deserialize};
20
21use crate::error::{Result, RLibError};
22
23bitflags! {
24
25    #[derive(Default, PartialEq, Clone, Debug, Serialize, Deserialize)]
26    pub struct AIPurposeFlags: u32 {
27        const ATTACK                        = 0b0000_0000_0000_0000_0000_0000_0000_0001;
28        const DEFEND                        = 0b0000_0000_0000_0000_0000_0000_0000_0010;
29        const RIVER_ATTACK                  = 0b0000_0000_0000_0000_0000_0000_0000_0100;
30        const RIVER_DEFEND                  = 0b0000_0000_0000_0000_0000_0000_0000_1000;
31        const UK_4                          = 0b0000_0000_0000_0000_0000_0000_0001_0000;
32        const AMBUSH_DEFENCE_BLOCK          = 0b0000_0000_0000_0000_0000_0000_0010_0000;
33        const SETTLEMENT_ASSAULT            = 0b0000_0000_0000_0000_0000_0000_0100_0000;
34        const SETTLEMENT_AREA_DEFEND_NARROW = 0b0000_0000_0000_0000_0000_0000_1000_0000;
35        const SETTLEMENT_AREA_ATTACK_NARROW = 0b0000_0000_0000_0000_0000_0001_0000_0000;
36        const UK_9                          = 0b0000_0000_0000_0000_0000_0010_0000_0000;
37        const NAVAL_ATTACK                  = 0b0000_0000_0000_0000_0000_0100_0000_0000;
38        const NAVAL_DEFEND                  = 0b0000_0000_0000_0000_0000_1000_0000_0000;
39        const DEFAULT_DEPLOYMENT            = 0b0000_0000_0000_0000_0001_0000_0000_0000;
40        const NAVAL_DEFAULT_DEPLOYMENT      = 0b0000_0000_0000_0000_0010_0000_0000_0000;
41        const UK_14                         = 0b0000_0000_0000_0000_0100_0000_0000_0000;
42        const UK_15                         = 0b0000_0000_0000_0000_1000_0000_0000_0000;
43        const UK_16                         = 0b0000_0000_0000_0001_0000_0000_0000_0000;
44        const UK_17                         = 0b0000_0000_0000_0010_0000_0000_0000_0000;
45        const UK_18                         = 0b0000_0000_0000_0100_0000_0000_0000_0000;
46        const UK_19                         = 0b0000_0000_0000_1000_0000_0000_0000_0000;
47        const UK_20                         = 0b0000_0000_0001_0000_0000_0000_0000_0000;
48        const UK_21                         = 0b0000_0000_0010_0000_0000_0000_0000_0000;
49        const UK_22                         = 0b0000_0000_0100_0000_0000_0000_0000_0000;
50        const UK_23                         = 0b0000_0000_1000_0000_0000_0000_0000_0000;
51        const UK_24                         = 0b0000_0001_0000_0000_0000_0000_0000_0000;
52        const UK_25                         = 0b0000_0010_0000_0000_0000_0000_0000_0000;
53        const UK_26                         = 0b0000_0100_0000_0000_0000_0000_0000_0000;
54        const UK_27                         = 0b0000_1000_0000_0000_0000_0000_0000_0000;
55        const UK_28                         = 0b0001_0000_0000_0000_0000_0000_0000_0000;
56        const UK_29                         = 0b0010_0000_0000_0000_0000_0000_0000_0000;
57        const UK_30                         = 0b0100_0000_0000_0000_0000_0000_0000_0000;
58        const UK_31                         = 0b1000_0000_0000_0000_0000_0000_0000_0000;
59    }
60}
61
62/// Entity types for Rome 2 and later formations.
63///
64/// These are abstract unit class identifiers shared across Rome 2, Attila,
65/// Warhammer series, Three Kingdoms, Troy, and Pharaoh.
66#[derive(Default, Clone, Copy, PartialEq, Debug, Serialize, Deserialize)]
67#[repr(u32)]
68pub enum EntityType {
69    InfMel = 0,
70    InfSpr = 1,
71    InfPik = 2,
72    InfMis = 3,
73    #[default] Com = 4,
74    CavShk = 5,
75    CavMel = 6,
76    CavMis = 7,
77    Chariot = 8,
78    Elph = 9,
79    Spcl = 10,
80    ArtFld = 11,
81    ArtFix = 12,
82    ArtSiege = 13,
83    ShpMel = 14,
84    ShpMis = 15,
85    ShpArt = 16,
86    ShpTrn = 17,
87    ShpStk = 18,
88    ShpFir = 19,
89    Invalid = 20,
90    Uk21 = 21,
91    Uk22 = 22,
92    Uk23 = 23,
93    Uk24 = 24,
94}
95
96impl TryFrom<u32> for EntityType {
97    type Error = RLibError;
98    fn try_from(value: u32) -> Result<Self> {
99        match value {
100            _ if value == Self::InfMel as u32 => Ok(Self::InfMel),
101            _ if value == Self::InfSpr as u32 => Ok(Self::InfSpr),
102            _ if value == Self::InfPik as u32 => Ok(Self::InfPik),
103            _ if value == Self::InfMis as u32 => Ok(Self::InfMis),
104            _ if value == Self::Com as u32 => Ok(Self::Com),
105            _ if value == Self::CavShk as u32 => Ok(Self::CavShk),
106            _ if value == Self::CavMel as u32 => Ok(Self::CavMel),
107            _ if value == Self::CavMis as u32 => Ok(Self::CavMis),
108            _ if value == Self::Chariot as u32 => Ok(Self::Chariot),
109            _ if value == Self::Elph as u32 => Ok(Self::Elph),
110            _ if value == Self::Spcl as u32 => Ok(Self::Spcl),
111            _ if value == Self::ArtFld as u32 => Ok(Self::ArtFld),
112            _ if value == Self::ArtFix as u32 => Ok(Self::ArtFix),
113            _ if value == Self::ArtSiege as u32 => Ok(Self::ArtSiege),
114            _ if value == Self::ShpMel as u32 => Ok(Self::ShpMel),
115            _ if value == Self::ShpMis as u32 => Ok(Self::ShpMis),
116            _ if value == Self::ShpArt as u32 => Ok(Self::ShpArt),
117            _ if value == Self::ShpTrn as u32 => Ok(Self::ShpTrn),
118            _ if value == Self::ShpStk as u32 => Ok(Self::ShpStk),
119            _ if value == Self::ShpFir as u32 => Ok(Self::ShpFir),
120            _ if value == Self::Invalid as u32 => Ok(Self::Invalid),
121            _ if value == Self::Uk21 as u32 => Ok(Self::Uk21),
122            _ if value == Self::Uk22 as u32 => Ok(Self::Uk22),
123            _ if value == Self::Uk23 as u32 => Ok(Self::Uk23),
124            _ if value == Self::Uk24 as u32 => Ok(Self::Uk24),
125            _ => Err(RLibError::DecodingGroupFormationsUnknownEnumValue("EntityType(v2)".to_string(), value)),
126        }
127    }
128}
129
130impl From<EntityType> for u32 {
131    fn from(value: EntityType) -> u32 {
132        value as u32
133    }
134}
135
136impl Display for EntityType {
137    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
138        match self {
139            Self::InfMel => write!(f, "Missile Infantry"),
140            Self::InfSpr => write!(f, "Spear Infantry"),
141            Self::InfPik => write!(f, "Pike Infantry"),
142            Self::InfMis => write!(f, "Missile Infantry"),
143            Self::Com => write!(f, "Command"),
144            Self::CavShk => write!(f, "Shock Cavalry"),
145            Self::CavMel => write!(f, "Melee Cavalry"),
146            Self::CavMis => write!(f, "Missile Cavalry"),
147            Self::Chariot => write!(f, "Chariot"),
148            Self::Elph => write!(f, "Elephant"),
149            Self::Spcl => write!(f, "Special"),
150            Self::ArtFld => write!(f, "Field Artillery"),
151            Self::ArtFix => write!(f, "Fixed Artillery"),
152            Self::ArtSiege => write!(f, "Siege Artillery"),
153            Self::ShpMel => write!(f, "Melee Ship"),
154            Self::ShpMis => write!(f, "Missile Ship"),
155            Self::ShpArt => write!(f, "Artillery Ship"),
156            Self::ShpTrn => write!(f, "Transport Ship"),
157            Self::ShpStk => write!(f, "Ramming Ship"),
158            Self::ShpFir => write!(f, "Fire Ship"),
159            Self::Invalid => write!(f, "Invalid"),
160            Self::Uk21 => write!(f, "Uk21"),
161            Self::Uk22 => write!(f, "Uk22"),
162            Self::Uk23 => write!(f, "Uk23"),
163            Self::Uk24 => write!(f, "Uk24"),
164        }
165    }
166}