boseiju/ability_tree/terminals/
card_state.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 CardState {
7    Attached {
8        #[cfg(feature = "spanned_tree")]
9        span: crate::ability_tree::span::TreeSpan,
10    },
11    Attacking {
12        #[cfg(feature = "spanned_tree")]
13        span: crate::ability_tree::span::TreeSpan,
14    },
15    Blocking {
16        #[cfg(feature = "spanned_tree")]
17        span: crate::ability_tree::span::TreeSpan,
18    },
19    Blocked {
20        #[cfg(feature = "spanned_tree")]
21        span: crate::ability_tree::span::TreeSpan,
22    },
23    Enchanted {
24        #[cfg(feature = "spanned_tree")]
25        span: crate::ability_tree::span::TreeSpan,
26    },
27    Equipped {
28        #[cfg(feature = "spanned_tree")]
29        span: crate::ability_tree::span::TreeSpan,
30    },
31    Exiled {
32        #[cfg(feature = "spanned_tree")]
33        span: crate::ability_tree::span::TreeSpan,
34    },
35    Revealed {
36        #[cfg(feature = "spanned_tree")]
37        span: crate::ability_tree::span::TreeSpan,
38    },
39    Tapped {
40        #[cfg(feature = "spanned_tree")]
41        span: crate::ability_tree::span::TreeSpan,
42    },
43    Untapped {
44        #[cfg(feature = "spanned_tree")]
45        span: crate::ability_tree::span::TreeSpan,
46    },
47}
48
49#[cfg(feature = "spanned_tree")]
50impl CardState {
51    pub fn span(&self) -> crate::ability_tree::span::TreeSpan {
52        match self {
53            Self::Attached { span } => *span,
54            Self::Attacking { span } => *span,
55            Self::Blocking { span } => *span,
56            Self::Blocked { span } => *span,
57            Self::Enchanted { span } => *span,
58            Self::Equipped { span } => *span,
59            Self::Exiled { span } => *span,
60            Self::Revealed { span } => *span,
61            Self::Tapped { span } => *span,
62            Self::Untapped { span } => *span,
63        }
64    }
65}
66
67impl std::fmt::Display for CardState {
68    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
69        match self {
70            CardState::Attached { .. } => write!(f, "attached"),
71            CardState::Attacking { .. } => write!(f, "attacking"),
72            CardState::Blocking { .. } => write!(f, "blocking"),
73            CardState::Blocked { .. } => write!(f, "blocked"),
74            CardState::Enchanted { .. } => write!(f, "enchanted"),
75            CardState::Equipped { .. } => write!(f, "equipped"),
76            CardState::Exiled { .. } => write!(f, "exiled"),
77            CardState::Revealed { .. } => write!(f, "exiled"),
78            CardState::Tapped { .. } => write!(f, "tapped"),
79            CardState::Untapped { .. } => write!(f, "untapped"),
80        }
81    }
82}
83
84#[cfg(feature = "lexer")]
85impl IntoToken for CardState {
86    fn try_from_span(span: &crate::lexer::Span) -> Option<Self> {
87        match span.text {
88            "attached" => Some(CardState::Attached {
89                #[cfg(feature = "spanned_tree")]
90                span: span.into(),
91            }),
92            "attacking" => Some(CardState::Attacking {
93                #[cfg(feature = "spanned_tree")]
94                span: span.into(),
95            }),
96            "blocking" => Some(CardState::Blocking {
97                #[cfg(feature = "spanned_tree")]
98                span: span.into(),
99            }),
100            "blocked" => Some(CardState::Blocked {
101                #[cfg(feature = "spanned_tree")]
102                span: span.into(),
103            }),
104            "enchanted" => Some(CardState::Enchanted {
105                #[cfg(feature = "spanned_tree")]
106                span: span.into(),
107            }),
108            "equipped" => Some(CardState::Equipped {
109                #[cfg(feature = "spanned_tree")]
110                span: span.into(),
111            }),
112            "exiled" => Some(CardState::Exiled {
113                #[cfg(feature = "spanned_tree")]
114                span: span.into(),
115            }),
116            "revealed" => Some(CardState::Revealed {
117                #[cfg(feature = "spanned_tree")]
118                span: span.into(),
119            }),
120            "tapped" => Some(CardState::Tapped {
121                #[cfg(feature = "spanned_tree")]
122                span: span.into(),
123            }),
124            "untapped" => Some(CardState::Untapped {
125                #[cfg(feature = "spanned_tree")]
126                span: span.into(),
127            }),
128            _ => None,
129        }
130    }
131}