weasel 0.11.0

A customizable battle system for turn-based games.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! This module contains implementations for components that do nothing.
//! Such rules are useful if you don't need to implement any logic for a particular module.

use crate::actor::ActorRules;
use crate::battle::BattleRules;
use crate::character::CharacterRules;
use crate::fight::FightRules;
use crate::round::RoundsRules;
use crate::rules::entropy::FixedAverage;
use crate::space::SpaceRules;
use crate::team::TeamRules;
use crate::user::UserRules;
use crate::util::Id;
#[cfg(feature = "serialization")]
use serde::{Deserialize, Serialize};

/// An empty statistic.
#[derive(Hash, Eq, PartialEq, Debug)]
#[cfg_attr(feature = "serialization", derive(Serialize, Deserialize))]
pub struct EmptyStat {
    /// The id of this statistic.
    pub id: u32,
}

impl Id for EmptyStat {
    type Id = u32;
    fn id(&self) -> &u32 {
        &self.id
    }
}

/// An empty ability that does not contain any data.
pub type EmptyAbility = EmptyStat;

/// An empty status that does nothing.
pub type EmptyStatus = EmptyStat;

/// An empty power having no data nor behavior.
pub type EmptyPower = EmptyStat;

/// Minimalistic implementation of team rules, doing no-op for everything.
#[derive(Default)]
pub struct EmptyTeamRules {}

impl<R: BattleRules> TeamRules<R> for EmptyTeamRules {
    type Id = u32;
    type Power = EmptyPower;
    type PowersSeed = ();
    type Invocation = ();
    type PowersAlteration = ();
    type ObjectivesSeed = ();
    type Objectives = ();
}

/// Minimalistic implementation of character rules, doing no-op for everything.
#[derive(Default)]
pub struct EmptyCharacterRules {}

impl<R: BattleRules> CharacterRules<R> for EmptyCharacterRules {
    type CreatureId = u32;
    type ObjectId = u32;
    type Statistic = EmptyStat;
    type StatisticsSeed = ();
    type StatisticsAlteration = ();
    type Status = EmptyStatus;
    type StatusesAlteration = ();
}

/// Minimalistic implementation of actor rules, doing no-op for everything.
#[derive(Default)]
pub struct EmptyActorRules {}

impl<R: BattleRules> ActorRules<R> for EmptyActorRules {
    type Ability = EmptyAbility;
    type AbilitiesSeed = ();
    type Activation = ();
    type AbilitiesAlteration = ();
}

/// Minimalistic implementation of space rules, doing no-op for everything.
#[derive(Default)]
pub struct EmptySpaceRules {}

impl<R: BattleRules> SpaceRules<R> for EmptySpaceRules {
    type Position = ();
    type SpaceSeed = ();
    type SpaceModel = ();
    type SpaceAlteration = ();

    fn generate_model(&self, _seed: &Option<Self::SpaceSeed>) -> Self::SpaceModel {}
}

/// Minimalistic implementation of rounds rules, doing no-op for everything.
#[derive(Default)]
pub struct EmptyRoundsRules {}

impl<R: BattleRules> RoundsRules<R> for EmptyRoundsRules {
    type RoundsSeed = ();
    type RoundsModel = ();

    fn generate_model(&self, _: &Option<Self::RoundsSeed>) -> Self::RoundsModel {}
}

/// Minimalistic implementation of fight rules, doing no-op for everything.
#[derive(Default)]
pub struct EmptyFightRules {}

impl<R: BattleRules> FightRules<R> for EmptyFightRules {
    type Impact = ();
    type Potency = ();
}

/// Minimalistic implementation of user rules, doing no-op for everything.
#[derive(Default)]
pub struct EmptyUserRules {}

impl<R: BattleRules> UserRules<R> for EmptyUserRules {
    type UserMetricId = u16;
    #[cfg(feature = "serialization")]
    type UserEventPackage = ();
}

/// Entropy rules that do not have randomness. They just return the average value.
pub type EmptyEntropyRules = FixedAverage<i32>;