1use crate::file::Eu4Deserializer;
2use crate::{de::*, Eu4Error};
3use crate::{CountryTag, Eu4Date, ProvinceId};
4use jomini::binary::TokenResolver;
5use jomini::JominiDeserialize;
6use serde::{Deserialize, Serialize};
7use std::collections::HashMap;
8
9#[derive(Debug, Clone, JominiDeserialize, Serialize)]
10pub struct Meta {
11 pub campaign_id: String,
12 pub save_game: String,
13 pub player: CountryTag,
14 pub displayed_country_name: String,
15 pub campaign_length: i32,
16 pub date: Eu4Date,
17 #[jomini(default)]
18 pub is_ironman: bool,
19 #[jomini(default, alias = "multi_player")]
20 #[serde(alias = "multi_player")]
21 pub multiplayer: bool,
22 pub not_observer: bool,
23 #[jomini(default)]
24 pub dlc_enabled: Vec<String>,
25 #[jomini(default)]
26 pub mod_enabled: Vec<String>,
27 #[jomini(default)]
28 pub mods_enabled_names: Vec<ModName>,
29 #[jomini(take_last)]
30 pub checksum: String,
31 pub savegame_version: SavegameVersion,
32 #[jomini(default)]
33 pub is_random_new_world: bool,
34}
35
36#[derive(Debug, Clone, Deserialize, Serialize)]
37pub struct ModName {
38 pub filename: String,
39 pub name: String,
40}
41
42#[derive(Debug, Clone)]
43#[cfg_attr(feature = "serialize", derive(Serialize))]
44pub struct Eu4Save {
45 #[cfg_attr(feature = "serialize", serde(flatten))]
46 pub meta: Meta,
47
48 #[cfg_attr(feature = "serialize", serde(flatten))]
49 pub game: GameState,
50}
51
52impl Eu4Save {
53 pub fn from_deserializer<R>(deser: &Eu4Deserializer, resolver: &R) -> Result<Self, Eu4Error>
54 where
55 R: TokenResolver,
56 {
57 let meta = deser.build(resolver)?;
58 let game = deser.build(resolver)?;
59 Ok(Eu4Save { meta, game })
60 }
61}
62
63#[derive(Debug, Clone, JominiDeserialize)]
64#[cfg_attr(feature = "serialize", derive(Serialize))]
65pub struct GameState {
66 #[jomini(default)]
67 pub players_countries: Vec<String>,
68 pub current_age: String,
69 pub start_date: Eu4Date,
70 pub map_area_data: HashMap<String, MapAreaDatum>,
71 pub military_hegemon: Option<Hegemon>,
72 pub naval_hegemon: Option<Hegemon>,
73 pub economic_hegemon: Option<Hegemon>,
74 #[jomini(default, deserialize_with = "deserialize_vec_pair")]
75 pub religions: Vec<(String, ReligionGameState)>,
76 pub religion_instance_data: HashMap<String, ReligionInstanceDatum>,
77 pub empire: Option<HRE>,
78 #[jomini(default, deserialize_with = "deserialize_vec_pair")]
79 pub countries: Vec<(CountryTag, Country)>,
80 pub provinces: HashMap<ProvinceId, Province>,
81 pub income_statistics: LedgerData,
82 pub nation_size_statistics: LedgerData,
83 pub score_statistics: LedgerData,
84 pub inflation_statistics: LedgerData,
85 #[jomini(duplicated, alias = "active_war")]
86 pub active_wars: Vec<ActiveWar>,
87 #[jomini(duplicated, alias = "previous_war")]
88 pub previous_wars: Vec<PreviousWar>,
89 #[jomini(default)]
90 pub achievement_ok: bool,
91 #[jomini(default)]
92 pub achievement: Vec<i32>,
93 #[jomini(default)]
94 pub completed_achievements: Vec<i32>,
95 #[jomini(alias = "gameplaysettings")]
96 pub gameplay_settings: GameplaySettings,
97 pub diplomacy: Diplomacy,
98}
99
100#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
101pub struct SavegameVersion {
102 pub first: u16,
103 pub second: u16,
104 pub third: u16,
105 #[serde(alias = "forth")]
106 pub fourth: u16,
107 pub name: String,
108}
109
110#[derive(Debug, Clone, Deserialize)]
111#[cfg_attr(feature = "serialize", derive(Serialize))]
112pub struct GameplaySettings {
113 #[serde(alias = "setgameplayoptions")]
114 pub options: GameplayOptions,
115}
116
117#[derive(Debug, Clone, JominiDeserialize)]
118#[cfg_attr(feature = "serialize", derive(Serialize))]
119pub struct MapAreaDatum {
120 pub state: Option<MapAreaState>,
121 #[jomini(default, duplicated, alias = "investments")]
122 pub investments: Vec<TradeCompanyInvestment>,
123}
124
125#[derive(Debug, Clone, JominiDeserialize)]
126#[cfg_attr(feature = "serialize", derive(Serialize))]
127pub struct MapAreaState {
128 pub area: String,
129 #[jomini(duplicated, alias = "country_state")]
130 pub country_states: Vec<CountryState>,
131}
132
133#[derive(Debug, Clone, JominiDeserialize)]
134#[cfg_attr(feature = "serialize", derive(Serialize))]
135pub struct TradeCompanyInvestment {
136 pub tag: CountryTag,
137 #[jomini(default)]
138 pub investments: Vec<String>,
139}
140
141#[derive(Debug, Clone, JominiDeserialize)]
142#[cfg_attr(feature = "serialize", derive(Serialize))]
143pub struct CountryState {
144 #[jomini(default)]
145 pub prosperity: f32,
146 pub country: CountryTag,
147}
148
149#[derive(Debug, Clone, Deserialize)]
150#[cfg_attr(feature = "serialize", derive(Serialize))]
151pub struct Hegemon {
152 pub country: CountryTag,
153 pub progress: f32,
154}
155
156#[derive(Debug, Clone, Deserialize)]
157#[cfg_attr(feature = "serialize", derive(Serialize))]
158pub struct ReligionGameState {
159 #[serde(default)]
160 pub amount_of_provinces: i32,
161}
162
163#[derive(Debug, Clone, Deserialize)]
164#[cfg_attr(feature = "serialize", derive(Serialize))]
165pub struct ReligionInstanceDatum {
166 #[serde(default)]
167 pub defender: Option<CountryTag>,
168 #[serde(default)]
169 pub defender_date: Option<Eu4Date>,
170 #[serde(default)]
171 pub papacy: Option<Papacy>,
172}
173
174#[derive(Debug, Clone, Deserialize)]
175#[cfg_attr(feature = "serialize", derive(Serialize))]
176pub struct Papacy {
177 pub controller: CountryTag,
178}
179
180#[derive(Debug, Clone, JominiDeserialize)]
181#[cfg_attr(feature = "serialize", derive(Serialize))]
182pub struct HRE {
183 pub emperor: Option<CountryTag>,
184 #[jomini(duplicated, alias = "passed_reform")]
185 pub passed_reforms: Vec<String>,
186 #[jomini(default)]
187 pub electors: Vec<CountryTag>,
188}
189
190#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)]
191pub enum TaxManpowerModifier {
192 Historical,
193 Random,
194 Equal,
195}
196
197#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq)]
198pub enum GameDifficulty {
199 VeryEasy,
200 Easy,
201 Normal,
202 Hard,
203 VeryHard,
204}
205
206#[derive(Debug, Clone, Serialize)]
207pub struct GameplayOptions {
208 pub difficulty: GameDifficulty,
209 pub tax_manpower_modifier: TaxManpowerModifier,
210}
211
212#[derive(Debug, Clone, JominiDeserialize)]
213#[cfg_attr(feature = "serialize", derive(Serialize))]
214pub struct LedgerData {
215 #[jomini(duplicated, alias = "ledger_data")]
216 pub ledger: Vec<LedgerDatum>,
217}
218
219#[derive(Debug, Clone, Deserialize)]
220#[cfg_attr(feature = "serialize", derive(Serialize))]
221pub struct LedgerDatum {
222 pub name: CountryTag,
223 #[serde(default, deserialize_with = "deserialize_vec_pair")]
224 pub data: Vec<(u16, i32)>,
225}
226
227#[derive(Debug, Clone, JominiDeserialize, Default)]
228#[cfg_attr(feature = "serialize", derive(Serialize))]
229pub struct Province {
230 #[jomini(default, deserialize_with = "deserialize_vec_pair")]
231 pub flags: Vec<(String, Eu4Date)>,
232 pub name: String,
233 pub owner: Option<CountryTag>,
234 pub controller: Option<CountryTag>,
235 pub previous_controller: Option<CountryTag>,
236 #[jomini(default)]
237 pub cores: Vec<CountryTag>,
238 #[jomini(default)]
239 pub claims: Vec<CountryTag>,
240 pub institutions: Vec<f32>,
241 pub trade: Option<String>,
242 pub original_culture: Option<String>,
243 pub culture: Option<String>,
244 pub religion: Option<String>,
245 pub original_religion: Option<String>,
246 pub trade_goods: Option<String>,
247 #[jomini(default, deserialize_with = "deserialize_alternating_key_values")]
248 pub country_improve_count: HashMap<CountryTag, i32>,
249 #[jomini(default)]
250 pub latent_trade_goods: Vec<String>,
251 #[jomini(default)]
252 pub devastation: f32,
253 #[jomini(default)]
254 pub base_tax: f32,
255 #[jomini(default)]
256 pub base_production: f32,
257 #[jomini(default)]
258 pub base_manpower: f32,
259 pub capital: Option<String>,
260 #[jomini(default)]
261 pub local_autonomy: f32,
262 #[jomini(default)]
263 pub is_city: bool,
264 #[jomini(default, deserialize_with = "deserialize_token_bool")]
265 pub active_trade_company: bool,
266 #[jomini(default)]
267 pub center_of_trade: u8,
268 #[jomini(default)]
269 pub trade_power: f32,
270 #[jomini(default, deserialize_with = "deserialize_token_bool")]
271 pub hre: bool,
272 #[jomini(default, deserialize_with = "deserialize_yes_map")]
273 pub buildings: HashMap<String, bool>,
274 #[jomini(default)]
275 pub building_builders: HashMap<String, CountryTag>,
276 #[jomini(default, duplicated, alias = "modifier")]
277 pub modifiers: Vec<Modifier>,
278 #[jomini(default)]
279 pub history: ProvinceHistory,
280 #[jomini(default = "default_true")]
281 pub ub: bool,
282 #[jomini(alias = "colonysize")]
283 pub colony_size: Option<f32>,
284 pub change_culture_construction: Option<ChangeCultureConstruction>,
285}
286
287#[derive(Debug, Clone, Deserialize)]
288#[cfg_attr(feature = "serialize", derive(Serialize))]
289pub struct Modifier {
290 pub modifier: String,
291 pub date: Eu4Date,
292}
293
294#[derive(Debug, Clone, Default)]
295#[cfg_attr(feature = "serialize", derive(Serialize))]
296pub struct ProvinceHistory {
297 pub owner: Option<CountryTag>,
298 pub base_tax: Option<f32>,
299 pub base_production: Option<f32>,
300 pub base_manpower: Option<f32>,
301 pub religion: Option<String>,
302 pub other: HashMap<String, ProvinceEventValue>,
303 pub events: Vec<(Eu4Date, ProvinceEvents)>,
304}
305
306#[derive(Debug, Clone)]
307#[cfg_attr(feature = "serialize", derive(Serialize))]
308pub struct ProvinceEvents(pub Vec<ProvinceEvent>);
309
310#[derive(Debug, Clone, Deserialize)]
311#[cfg_attr(feature = "serialize", derive(Serialize))]
312pub enum ProvinceEvent {
313 Owner(CountryTag),
314 Controller(ControllerEvent),
315 BaseTax(f32),
316 BaseProduction(f32),
317 BaseManpower(f32),
318 Religion(String),
319 KV((String, ProvinceEventValue)),
320}
321
322#[derive(Debug, Clone, Deserialize)]
323#[cfg_attr(feature = "serialize", derive(Serialize))]
324pub struct ControllerEvent {
325 pub tag: CountryTag,
326}
327
328#[derive(Debug, Clone)]
329#[cfg_attr(feature = "serialize", derive(Serialize))]
330pub enum ProvinceEventValue {
331 String(String),
332 Float(f32),
333 Int(i32),
334 Bool(bool),
335 Object,
336 Array,
337}
338
339#[derive(Debug, Clone, Deserialize)]
340#[cfg_attr(feature = "serialize", derive(Serialize))]
341pub struct ChangeCultureConstruction {
342 pub start_date: Eu4Date,
343 pub total: u32,
344 pub original_total: u32,
345 #[serde(default)]
346 pub progress: f32,
347 pub date: Eu4Date,
348 pub power: f32,
349 pub envoy: i32,
350 pub country: CountryTag,
351 pub culture: String,
352}
353
354#[derive(Debug, Clone, JominiDeserialize, Default)]
355#[cfg_attr(feature = "serialize", derive(Serialize))]
356pub struct Country {
357 #[jomini(default, deserialize_with = "deserialize_token_bool")]
358 pub human: bool,
359 #[jomini(default)]
360 pub was_player: bool,
361 #[jomini(default)]
362 pub has_switched_nation: bool,
363 #[jomini(default)]
364 pub is_great_power: bool,
365 #[jomini(default)]
366 pub history: CountryHistory,
367 #[jomini(duplicated)]
368 pub previous_country_tags: Vec<CountryTag>,
369 pub name: Option<String>,
370 pub government_rank: i32,
371 pub continent: Vec<i32>,
372 pub institutions: Vec<i32>,
373 pub capital: ProvinceId,
374 pub original_capital: Option<ProvinceId>,
375 pub trade_port: ProvinceId,
376 #[jomini(default)]
377 pub base_tax: f32,
378 #[jomini(default)]
379 pub development: f32,
380 #[jomini(default)]
381 pub prestige: f32,
382 #[jomini(default)]
383 pub stability: f32,
384 #[jomini(default)]
385 pub treasury: f32,
386 #[jomini(default)]
387 pub inflation: f32,
388 #[jomini(default)]
389 pub corruption: f32,
390 #[jomini(default)]
391 pub raw_development: f32,
392 pub capped_development: f32,
393 pub realm_development: f32,
394 pub isolationism: i32,
395 #[jomini(default)]
396 pub manpower: f32,
397 #[jomini(default)]
398 pub max_manpower: f32,
399 #[jomini(default)]
400 pub sailors: f32,
401 #[jomini(default)]
402 pub max_sailors: f32,
403 #[jomini(default, alias = "overextension_percentage")]
404 pub overextension: f32,
405 #[jomini(default)]
406 pub innovativeness: f32,
407 #[jomini(default)]
408 pub religious_unity: f32,
409 #[jomini(default)]
410 pub church: Option<CountryChurch>,
411 pub initialized_rivals: bool,
412 pub national_focus: Option<String>,
413 pub recalculate_strategy: bool,
414 pub colors: CountryColors,
415 pub dirty_colony: bool,
416 pub primary_culture: Option<String>,
417 pub dominant_culture: Option<String>,
418 #[jomini(duplicated, alias = "accepted_culture")]
419 pub accepted_cultures: Vec<String>,
420 pub religion: Option<String>,
421 pub dominant_religion: Option<String>,
422 pub technology_group: Option<String>,
423 pub unit_type: Option<String>,
424 pub tribute_type: Option<i32>,
425 pub technology: CountryTechnology,
426 pub ledger: CountryLedger,
427 #[jomini(duplicated, alias = "loan")]
428 pub loans: Vec<Loan>,
429 #[jomini(duplicated, alias = "estate")]
430 pub estates: Vec<Estate>,
431 #[jomini(default)]
432 pub subjects: Vec<CountryTag>,
433 #[jomini(default, deserialize_with = "deserialize_vec_pair")]
434 pub flags: Vec<(String, Eu4Date)>,
435 pub highest_possible_fort: Option<i32>,
436 pub transfer_home_bonus: f32,
437 #[jomini(duplicated, alias = "enemy")]
438 pub enemies: Vec<String>,
439 #[jomini(default)]
440 pub current_power_projection: f32,
441 #[jomini(default)]
442 pub great_power_score: f32,
443 #[jomini(default)]
444 pub total_war_worth: u32,
445 #[jomini(duplicated, alias = "army")]
446 pub armies: Vec<Army>,
447 #[jomini(duplicated, alias = "navy")]
448 pub navies: Vec<Navy>,
449 pub custom_nation_points: Option<f32>,
450 #[jomini(default)]
451 pub num_of_cities: i32,
452 #[jomini(default)]
453 pub num_of_total_ports: i32,
454 #[jomini(default)]
455 pub completed_missions: Vec<String>,
456 #[jomini(default, deserialize_with = "deserialize_vec_pair")]
457 pub active_idea_groups: Vec<(String, u8)>,
458 #[jomini(default, deserialize_with = "deserialize_vec_pair")]
459 pub adm_spent_indexed: Vec<(i32, i32)>,
460 #[jomini(default, deserialize_with = "deserialize_vec_pair")]
461 pub dip_spent_indexed: Vec<(i32, i32)>,
462 #[jomini(default, deserialize_with = "deserialize_vec_pair")]
463 pub mil_spent_indexed: Vec<(i32, i32)>,
464 #[jomini(default)]
465 pub losses: WarParticipantLosses,
466 pub decision_seed: i32,
467 #[jomini(duplicated, alias = "mercenary_company")]
468 pub mercenary_companries: Vec<MercenaryCompany>,
469 pub monarch: Option<ObjId>,
470 pub heir: Option<ObjId>,
471 #[jomini(duplicated, alias = "leader")]
472 pub leaders: Vec<ObjId>,
473 #[jomini(duplicated, alias = "previous_monarch")]
474 pub previous_monarchs: Vec<ObjId>,
475 pub government: Option<CountryGovernment>,
476}
477
478#[derive(Debug, Clone, JominiDeserialize, Default)]
479#[cfg_attr(feature = "serialize", derive(Serialize))]
480pub struct CountryGovernment {
481 pub government: String,
482 pub reform_stack: CountryGovernmentReforms,
483}
484
485#[derive(Debug, Clone, Deserialize, Default)]
486#[cfg_attr(feature = "serialize", derive(Serialize))]
487pub struct CountryGovernmentReforms {
488 pub reforms: Vec<String>,
489 #[serde(default)]
490 pub history: Vec<String>,
491}
492
493#[derive(Debug, Clone, Deserialize, Default)]
494#[cfg_attr(feature = "serialize", derive(Serialize))]
495pub struct CountryLedger {
496 #[serde(default)]
497 pub income: Vec<f32>,
498 #[serde(default)]
499 pub expense: Vec<f32>,
500 pub lastmonthincome: Option<f32>,
501 #[serde(default)]
502 pub lastmonthincometable: Vec<f32>,
503 #[serde(default)]
504 pub lastmonthexpensetable: Vec<f32>,
505 #[serde(default)]
506 pub totalexpensetable: Vec<f32>,
507 #[serde(default)]
508 pub lastyearincome: Vec<f32>,
509 #[serde(default)]
510 pub lastyearexpense: Vec<f32>,
511}
512
513#[derive(Debug, Clone, Default)]
514#[cfg_attr(feature = "serialize", derive(Serialize))]
515pub struct CountryHistory {
516 pub government: Option<String>,
517 pub technology_group: Option<String>,
518 pub primary_culture: Option<String>,
519 pub religion: Option<String>,
520 pub add_government_reform: Vec<String>,
521 pub events: Vec<(Eu4Date, CountryEvents)>,
522}
523
524#[derive(Debug, Clone)]
525#[cfg_attr(feature = "serialize", derive(Serialize))]
526pub struct CountryEvents(pub Vec<CountryEvent>);
527
528#[derive(Debug, Clone, Deserialize)]
529#[cfg_attr(feature = "serialize", derive(Serialize))]
530pub enum CountryEvent {
531 Monarch(Monarch),
532 Heir(Monarch),
533 MonarchHeir(Monarch),
534 MonarchConsort(Monarch),
535 Queen(Monarch),
536 Union(u32),
537 Capital(u32),
538 ChangedCountryNameFrom(String),
539 ChangedCountryAdjectiveFrom(String),
540 ChangedCountryMapColorFrom(Vec<u8>),
541 ChangedTagFrom(CountryTag),
542 Leader(Leader),
543 RemoveAcceptedCulture(String),
544 Religion(String),
545}
546
547impl CountryEvent {
548 pub fn as_monarch(&self) -> Option<&Monarch> {
549 match &self {
550 CountryEvent::Monarch(x)
551 | CountryEvent::Heir(x)
552 | CountryEvent::MonarchHeir(x)
553 | CountryEvent::MonarchConsort(x)
554 | CountryEvent::Queen(x) => Some(x),
555 _ => None,
556 }
557 }
558
559 pub fn as_leader(&self) -> Option<&Leader> {
560 self.as_monarch().and_then(|x| x.leader.as_ref()).or({
561 if let CountryEvent::Leader(x) = &self {
562 Some(x)
563 } else {
564 None
565 }
566 })
567 }
568}
569
570#[derive(Debug, Clone, Deserialize, Serialize)]
571pub struct Monarch {
572 pub id: ObjId,
573 pub name: String,
574 pub country: CountryTag,
575 #[serde(alias = "DIP")]
576 pub dip: u16,
577 #[serde(alias = "ADM")]
578 pub adm: u16,
579 #[serde(alias = "MIL")]
580 pub mil: u16,
581 #[serde(default, deserialize_with = "deserialize_token_bool")]
582 pub regent: bool,
583 #[serde(default)]
584 pub culture: Option<String>,
585 #[serde(default)]
586 pub religion: Option<String>,
587 pub birth_date: Eu4Date,
588 #[serde(default, deserialize_with = "deserialize_vec_pair")]
589 pub personalities: Vec<(String, String)>,
590 pub leader_id: Option<ObjId>,
591 pub leader: Option<Leader>,
592}
593
594#[derive(Debug, Clone, Serialize)]
595pub enum LeaderKind {
596 Admiral,
597 General,
598 Explorer,
599 Conquistador,
600}
601
602#[derive(Debug, Clone, Deserialize, Serialize)]
603pub struct Leader {
604 pub name: String,
605 #[serde(alias = "type")]
606 pub kind: LeaderKind,
607 #[serde(default)]
608 pub manuever: u16,
609 #[serde(default)]
610 pub shock: u16,
611 #[serde(default)]
612 pub fire: u16,
613 #[serde(default)]
614 pub siege: u16,
615 pub monarch_id: Option<ObjId>,
616 pub personality: Option<String>,
617
618 pub activation: Option<Eu4Date>,
621 pub id: Option<ObjId>,
622}
623
624#[derive(Debug, Clone, Deserialize, Serialize)]
625pub struct MercenaryCompany {
626 pub id: ObjId,
627 pub tag: String,
628 pub manpower: Option<f32>,
629 pub starting_manpower: Option<f32>,
630 pub leader: Option<Leader>,
631 pub unit: Option<ObjId>,
632 pub hiring_date: Option<Eu4Date>,
633 pub disband_date: Option<Eu4Date>,
634}
635
636#[derive(Debug, Clone, Deserialize, Default)]
637#[cfg_attr(feature = "serialize", derive(Serialize))]
638pub struct CountryColors {
639 pub revolutionary_colors: Option<Vec<u8>>,
640 #[serde(default, deserialize_with = "deserialize_vec_overflow_byte")]
641 pub map_color: Vec<u8>,
642 #[serde(default, deserialize_with = "deserialize_vec_overflow_byte")]
643 pub country_color: Vec<u8>,
644}
645
646#[derive(Debug, Clone, JominiDeserialize)]
647#[cfg_attr(feature = "serialize", derive(Serialize))]
648pub struct CountryChurch {
649 pub power: f32,
650 #[jomini(duplicated, alias = "aspect")]
651 pub aspects: Vec<String>,
652}
653
654#[derive(Debug, Clone, Deserialize)]
655#[cfg_attr(feature = "serialize", derive(Serialize))]
656pub struct Loan {
657 pub id: ObjId,
658 pub lender: String,
659 pub interest: f32,
660 #[serde(default)]
661 pub fixed_interest: bool,
662 pub amount: i32,
663 pub expiry_date: Eu4Date,
664 #[serde(default)]
665 pub spawned: bool,
666}
667
668#[derive(Debug, Clone, Deserialize, Default)]
669#[cfg_attr(feature = "serialize", derive(Serialize))]
670pub struct Estate {
671 #[serde(alias = "type")]
672 pub _type: String,
673 pub loyalty: f32,
674 #[serde(default)]
675 pub territory: f32,
676 #[serde(default)]
677 pub provinces: Vec<ProvinceId>,
678 #[serde(default)]
679 pub active_influences: Vec<i32>,
680}
681
682#[derive(Debug, Clone, Deserialize, Serialize, Default)]
683pub struct CountryTechnology {
684 pub adm_tech: u8,
685 pub dip_tech: u8,
686 pub mil_tech: u8,
687}
688
689#[derive(Debug, Clone, JominiDeserialize)]
690#[cfg_attr(feature = "serialize", derive(Serialize))]
691pub struct Army {
692 pub id: ObjId,
693 pub name: String,
694 pub location: ProvinceId,
695 #[jomini(duplicated, alias = "regiment")]
696 pub regiments: Vec<Regiment>,
697 pub movement_progress_last_updated: Eu4Date,
698 pub graphical_culture: String,
699 #[jomini(default)]
700 pub main_army: bool,
701 #[jomini(default)]
702 pub is_invading: bool,
703 #[jomini(default)]
704 pub visible_to_ai: bool,
705}
706
707#[derive(Debug, Clone, JominiDeserialize)]
708#[cfg_attr(feature = "serialize", derive(Serialize))]
709pub struct Navy {
710 pub id: ObjId,
711 pub name: String,
712 pub location: ProvinceId,
713 pub previous: Option<ProvinceId>,
714 pub previous_war: Option<i32>,
715 #[jomini(duplicated, alias = "ship")]
716 pub ships: Vec<Ship>,
717 pub movement_progress_last_updated: Eu4Date,
718 pub graphical_culture: String,
719 pub active_fraction_last_month: f32,
720 #[jomini(default)]
721 pub attrition: bool,
722 #[jomini(default)]
723 pub visible_to_ai: bool,
724}
725
726#[derive(Debug, Clone, Deserialize, Default)]
727#[cfg_attr(feature = "serialize", derive(Serialize))]
728pub struct Ship {
729 pub id: ObjId,
730 pub name: String,
731 pub home: ProvinceId,
732 #[serde(alias = "type")]
733 pub _type: String,
734 pub morale: f32,
735 #[serde(default = "default_strength")]
736 pub strength: f32,
737}
738
739#[derive(Debug, Clone, Deserialize, Serialize, Default)]
740pub struct ObjId {
741 pub id: u32,
742 #[serde(alias = "type")]
743 pub _type: u32,
744}
745
746#[derive(Debug, Clone, Deserialize, Default)]
747#[cfg_attr(feature = "serialize", derive(Serialize))]
748pub struct Regiment {
749 pub id: ObjId,
750 pub name: String,
751 pub home: ProvinceId,
752 #[serde(alias = "type")]
753 pub _type: String,
754 pub morale: f32,
755 #[serde(default)]
756 pub drill: f32,
757 #[serde(default = "default_strength")]
758 pub strength: f32,
759}
760
761fn default_strength() -> f32 {
762 1.0
763}
764
765#[derive(Debug, Clone, JominiDeserialize)]
766#[cfg_attr(feature = "serialize", derive(Serialize))]
767pub struct ActiveWar {
768 pub name: String,
769 pub history: WarHistory,
770 #[jomini(duplicated, default)]
771 pub participants: Vec<WarParticipant>,
772 pub original_attacker: CountryTag,
773 pub original_defender: CountryTag,
774}
775
776#[derive(Debug, Clone, JominiDeserialize)]
777#[cfg_attr(feature = "serialize", derive(Serialize))]
778pub struct PreviousWar {
779 pub name: String,
780 pub history: WarHistory,
781 #[jomini(duplicated, default)]
782 pub participants: Vec<WarParticipant>,
783 pub original_attacker: CountryTag,
784 pub original_defender: CountryTag,
785}
786
787#[derive(Debug, Clone, Deserialize)]
788#[cfg_attr(feature = "serialize", derive(Serialize))]
789pub struct WarParticipant {
790 pub value: f32,
791 pub tag: CountryTag,
792 #[serde(default)]
793 pub losses: WarParticipantLosses,
794}
795
796#[derive(Debug, Clone, Deserialize, Default)]
797#[cfg_attr(feature = "serialize", derive(Serialize))]
798pub struct WarParticipantLosses {
799 #[serde(default)]
800 pub members: Vec<u32>,
801}
802
803#[derive(Debug, Clone, Deserialize, Default)]
804#[cfg_attr(feature = "serialize", derive(Serialize))]
805pub struct WarGoal {
806 #[serde(alias = "type")]
807 pub _type: String,
808 pub casus_belli: String,
809}
810
811#[derive(Debug, Clone, Default)]
812#[cfg_attr(feature = "serialize", derive(Serialize))]
813pub struct WarHistory {
814 pub name: Option<String>,
815 pub war_goal: Option<WarGoal>,
816 pub succession: Option<String>,
817 pub events: Vec<(Eu4Date, WarEvents)>,
818}
819
820#[derive(Debug, Clone)]
821#[cfg_attr(feature = "serialize", derive(Serialize))]
822pub struct WarEvents(pub Vec<WarEvent>);
823
824#[derive(Debug, Clone, Deserialize)]
825#[cfg_attr(feature = "serialize", derive(Serialize))]
826pub enum WarEvent {
827 AddAttacker(CountryTag),
828 AddDefender(CountryTag),
829 RemoveAttacker(CountryTag),
830 RemoveDefender(CountryTag),
831 Battle(Battle),
832}
833
834#[derive(Debug, Clone, Deserialize)]
835#[cfg_attr(feature = "serialize", derive(Serialize))]
836pub struct Battle {
837 pub name: String,
838 pub location: ProvinceId,
839 #[serde(alias = "result", deserialize_with = "deserialize_token_bool")]
840 pub attacker_won: bool,
841 pub attacker: BattleSide,
842 pub defender: BattleSide,
843 #[serde(default)]
844 pub winner_alliance: f32,
845 #[serde(default)]
846 pub loser_alliance: f32,
847}
848
849#[derive(Debug, Clone, Deserialize)]
850#[cfg_attr(feature = "serialize", derive(Serialize))]
851pub struct BattleSide {
852 #[serde(default)]
853 pub cavalry: u32,
854 #[serde(default)]
855 pub infantry: u32,
856 #[serde(default)]
857 pub artillery: u32,
858 #[serde(default)]
859 pub heavy_ship: u32,
860 #[serde(default)]
861 pub light_ship: u32,
862 #[serde(default)]
863 pub galley: u32,
864 #[serde(default)]
865 pub transport: u32,
866 pub losses: u32,
867 pub country: CountryTag,
868
869 #[serde(deserialize_with = "empty_string_is_none")]
870 pub commander: Option<String>,
871}
872
873fn default_true() -> bool {
874 true
875}
876
877#[derive(Debug, Clone, JominiDeserialize)]
878#[cfg_attr(feature = "serialize", derive(Serialize))]
879pub struct Diplomacy {
880 #[jomini(duplicated, default, alias = "dependency")]
881 pub dependencies: Vec<DiplomacyDependency>,
882
883 #[jomini(duplicated, default, alias = "alliance")]
884 pub alliances: Vec<DiplomacyRelationship>,
885
886 #[jomini(duplicated, default, alias = "royal_marriage")]
887 pub royal_marriages: Vec<DiplomacyRelationship>,
888
889 #[jomini(duplicated, default, alias = "warning")]
890 pub warnings: Vec<DiplomacyRelationship>,
891
892 #[jomini(duplicated, default, alias = "subsidies")]
893 pub subsidies: Vec<DiplomacySubsidy>,
894
895 #[jomini(duplicated, default, alias = "guarantee")]
896 pub guarantees: Vec<DiplomacyRelationship>,
897
898 #[jomini(duplicated, default, alias = "transfer_trade_power")]
899 pub transfer_trade_powers: Vec<DiplomacyTransferTradePower>,
900
901 #[jomini(duplicated, default, alias = "war_reparations")]
902 pub war_reparations: Vec<DiplomacyRelationship>,
903
904 #[jomini(duplicated, default, alias = "steer_trade")]
905 pub steer_trades: Vec<DiplomacyRelationship>,
906
907 #[jomini(duplicated, default, alias = "condottieri")]
908 pub condottieris: Vec<DiplomacyCondottieri>,
909}
910
911#[derive(Debug, Clone, JominiDeserialize, Serialize)]
912pub struct DiplomacyDependency {
913 pub first: CountryTag,
914 pub second: CountryTag,
915 #[jomini(default)]
916 pub start_date: Option<Eu4Date>,
917 #[jomini(default)]
918 pub end_date: Option<Eu4Date>,
919 pub subject_type: String,
920}
921
922#[derive(Debug, Clone, JominiDeserialize, Serialize)]
923pub struct DiplomacyRelationship {
924 pub first: CountryTag,
925 pub second: CountryTag,
926 #[jomini(default)]
927 pub start_date: Option<Eu4Date>,
928 #[jomini(default)]
929 pub end_date: Option<Eu4Date>,
930 #[jomini(default)]
931 pub is_enforced: bool,
932}
933
934#[derive(Debug, Clone, JominiDeserialize, Serialize)]
935pub struct DiplomacySubsidy {
936 pub first: CountryTag,
937 pub second: CountryTag,
938 #[jomini(default)]
939 pub start_date: Option<Eu4Date>,
940 #[jomini(default)]
941 pub amount: f32,
942 #[jomini(default)]
943 pub duration: u16,
944}
945
946#[derive(Debug, Clone, JominiDeserialize, Serialize)]
947pub struct DiplomacyTransferTradePower {
948 pub first: CountryTag,
949 pub second: CountryTag,
950 #[jomini(default)]
951 pub start_date: Option<Eu4Date>,
952 #[jomini(default)]
953 pub is_enforced: bool,
954 #[jomini(default)]
955 pub amount: f32,
956}
957
958#[derive(Debug, Clone, JominiDeserialize, Serialize)]
959pub struct DiplomacyCondottieri {
960 pub first: CountryTag,
961 pub second: CountryTag,
962 #[jomini(default)]
963 pub start_date: Option<Eu4Date>,
964 pub unit: ObjId,
965 #[jomini(default)]
966 pub amount: f32,
967 #[jomini(default)]
968 pub participation: f32,
969}