boseiju/ability_tree/terminals/
phase.rs

1use crate::lexer::IntoToken;
2
3#[derive(idris_derive::Idris)]
4#[derive(serde::Serialize, serde::Deserialize)]
5#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
6pub enum Phase {
7    Beginning {
8        #[cfg(feature = "spanned_tree")]
9        span: crate::ability_tree::span::TreeSpan,
10    },
11    PrecombatMain {
12        #[cfg(feature = "spanned_tree")]
13        span: crate::ability_tree::span::TreeSpan,
14    },
15    Combat {
16        #[cfg(feature = "spanned_tree")]
17        span: crate::ability_tree::span::TreeSpan,
18    },
19    PostcombatMain {
20        #[cfg(feature = "spanned_tree")]
21        span: crate::ability_tree::span::TreeSpan,
22    },
23    End {
24        #[cfg(feature = "spanned_tree")]
25        span: crate::ability_tree::span::TreeSpan,
26    },
27    Current {
28        #[cfg(feature = "spanned_tree")]
29        span: crate::ability_tree::span::TreeSpan,
30    },
31}
32
33#[cfg(feature = "spanned_tree")]
34impl Phase {
35    pub fn span(&self) -> crate::ability_tree::span::TreeSpan {
36        match self {
37            Self::Beginning { span } => *span,
38            Self::PrecombatMain { span } => *span,
39            Self::Combat { span } => *span,
40            Self::PostcombatMain { span } => *span,
41            Self::End { span } => *span,
42            Self::Current { span } => *span,
43        }
44    }
45}
46
47impl std::fmt::Display for Phase {
48    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
49        match self {
50            Phase::Beginning { .. } => write!(f, "beginning phase"),
51            Phase::PrecombatMain { .. } => write!(f, "precombat main phase"),
52            Phase::Combat { .. } => write!(f, "combat phase"),
53            Phase::PostcombatMain { .. } => write!(f, "postcombat main phase"),
54            Phase::End { .. } => write!(f, "end phase"),
55            Phase::Current { .. } => write!(f, "this phase"),
56        }
57    }
58}
59
60#[cfg(feature = "lexer")]
61impl IntoToken for Phase {
62    fn try_from_span(span: &crate::lexer::Span) -> Option<Self> {
63        match span.text {
64            "beginning phase" => Some(Phase::Beginning {
65                #[cfg(feature = "spanned_tree")]
66                span: span.into(),
67            }),
68            "precombat main phase" => Some(Phase::PrecombatMain {
69                #[cfg(feature = "spanned_tree")]
70                span: span.into(),
71            }),
72            "combat phase" | "combat" => Some(Phase::Combat {
73                #[cfg(feature = "spanned_tree")]
74                span: span.into(),
75            }),
76            "postcombat main phase" => Some(Phase::PostcombatMain {
77                #[cfg(feature = "spanned_tree")]
78                span: span.into(),
79            }),
80            "end phase" => Some(Phase::End {
81                #[cfg(feature = "spanned_tree")]
82                span: span.into(),
83            }),
84            "end of turn" => Some(Phase::End {
85                #[cfg(feature = "spanned_tree")]
86                span: span.into(),
87            }),
88            "this phase" => Some(Phase::Current {
89                #[cfg(feature = "spanned_tree")]
90                span: span.into(),
91            }),
92            _ => None,
93        }
94    }
95}