tiger_lib/ck3/data/
regions.rs

1use crate::block::Block;
2use crate::db::{Db, DbKind};
3use crate::everything::Everything;
4use crate::game::GameFlags;
5use crate::item::{Item, ItemLoader};
6use crate::report::{ErrorKey, err, fatal};
7use crate::token::Token;
8use crate::validate::validate_color;
9use crate::validator::Validator;
10
11#[derive(Clone, Debug)]
12pub struct Region {
13    generates_modifiers: bool,
14}
15
16inventory::submit! {
17    ItemLoader::Normal(GameFlags::Ck3, Item::Region, Region::add)
18}
19
20impl Region {
21    pub fn add(db: &mut Db, key: Token, block: Block) {
22        let generates_modifiers = block.get_field_bool("generate_modifiers").unwrap_or(false);
23        let region = Self { generates_modifiers };
24        db.add(Item::Region, key, block, Box::new(region));
25    }
26}
27
28impl DbKind for Region {
29    fn has_property(
30        &self,
31        _key: &Token,
32        _block: &Block,
33        property: &str,
34        _data: &Everything,
35    ) -> bool {
36        if property == "generates_modifiers" { self.generates_modifiers } else { false }
37    }
38
39    fn validate(&self, key: &Token, block: &Block, data: &Everything) {
40        let mut vd = Validator::new(block, data);
41        // TODO: figure out when a region needs to be localized.
42        // Probably when it's tooltipped for geographical_region or when the gui code does GetName
43        data.mark_used(Item::Localization, key.as_str());
44
45        if block.field_value_is("generate_modifiers", "yes") {
46            let modif = format!("{key}_development_growth");
47            data.verify_exists_implied(Item::ModifierFormat, &modif, key);
48            let modif = format!("{key}_development_growth_factor");
49            data.verify_exists_implied(Item::ModifierFormat, &modif, key);
50        }
51
52        vd.field_bool("generate_modifiers");
53        vd.field_bool("graphical");
54        vd.field_validated_block("color", validate_color);
55        vd.field_bool("should_remember_counties_order");
56        vd.field_validated_list("counties", |token, data| {
57            if !token.starts_with("c_") {
58                let msg = "only counties can be listed in the counties field";
59                err(ErrorKey::Validation).msg(msg).loc(token).push();
60            }
61            data.verify_exists(Item::Title, token);
62        });
63        vd.field_validated_list("duchies", |token, data| {
64            if !token.starts_with("d_") {
65                let msg = "only duchies can be listed in the duchies field";
66                err(ErrorKey::Validation).msg(msg).loc(token).push();
67            }
68            data.verify_exists(Item::Title, token);
69        });
70        vd.field_validated_list("kingdoms", |token, data| {
71            if !token.starts_with("k_") {
72                let msg = "only kingdoms can be listed in the kingdoms field";
73                err(ErrorKey::Validation).msg(msg).loc(token).push();
74            }
75            data.verify_exists(Item::Title, token);
76        });
77        vd.field_list_items("provinces", Item::Province);
78        vd.field_validated_list("regions", |token, data| {
79            if !data.item_exists(Item::Region, token.as_str()) {
80                let msg =
81                    format!("{} {} not defined in {}", Item::Region, token, Item::Region.path());
82                let info = "this will cause a crash";
83                fatal(ErrorKey::Crash).strong().msg(msg).info(info).loc(token).push();
84            }
85        });
86    }
87}