boseiju/lexer/tokens/intermediates/
player_action.rs

1#[derive(idris_derive::Idris)]
2#[derive(serde::Serialize, serde::Deserialize)]
3#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
4pub enum PlayerAction {
5    Add {
6        #[cfg(feature = "spanned_tree")]
7        span: crate::ability_tree::span::TreeSpan,
8    },
9    Attach {
10        #[cfg(feature = "spanned_tree")]
11        span: crate::ability_tree::span::TreeSpan,
12    },
13    Change {
14        #[cfg(feature = "spanned_tree")]
15        span: crate::ability_tree::span::TreeSpan,
16    },
17    Choose {
18        #[cfg(feature = "spanned_tree")]
19        span: crate::ability_tree::span::TreeSpan,
20    },
21    Distribute {
22        #[cfg(feature = "spanned_tree")]
23        span: crate::ability_tree::span::TreeSpan,
24    },
25    Draw {
26        #[cfg(feature = "spanned_tree")]
27        span: crate::ability_tree::span::TreeSpan,
28    },
29    LookAt {
30        #[cfg(feature = "spanned_tree")]
31        span: crate::ability_tree::span::TreeSpan,
32    },
33    Lose {
34        #[cfg(feature = "spanned_tree")]
35        span: crate::ability_tree::span::TreeSpan,
36    },
37    Pay {
38        #[cfg(feature = "spanned_tree")]
39        span: crate::ability_tree::span::TreeSpan,
40    },
41    Prevent {
42        #[cfg(feature = "spanned_tree")]
43        span: crate::ability_tree::span::TreeSpan,
44    },
45    Put {
46        #[cfg(feature = "spanned_tree")]
47        span: crate::ability_tree::span::TreeSpan,
48    },
49    Return {
50        #[cfg(feature = "spanned_tree")]
51        span: crate::ability_tree::span::TreeSpan,
52    },
53    Remove {
54        #[cfg(feature = "spanned_tree")]
55        span: crate::ability_tree::span::TreeSpan,
56    },
57    Roll {
58        #[cfg(feature = "spanned_tree")]
59        span: crate::ability_tree::span::TreeSpan,
60    },
61    Search {
62        #[cfg(feature = "spanned_tree")]
63        span: crate::ability_tree::span::TreeSpan,
64    },
65    Shuffle {
66        #[cfg(feature = "spanned_tree")]
67        span: crate::ability_tree::span::TreeSpan,
68    },
69    Spend {
70        #[cfg(feature = "spanned_tree")]
71        span: crate::ability_tree::span::TreeSpan,
72    },
73}
74
75#[cfg(feature = "spanned_tree")]
76impl PlayerAction {
77    pub fn span(&self) -> crate::ability_tree::span::TreeSpan {
78        match self {
79            Self::Add { span } => *span,
80            Self::Attach { span } => *span,
81            Self::Change { span } => *span,
82            Self::Choose { span } => *span,
83            Self::Distribute { span } => *span,
84            Self::Draw { span } => *span,
85            Self::LookAt { span } => *span,
86            Self::Lose { span } => *span,
87            Self::Pay { span } => *span,
88            Self::Prevent { span } => *span,
89            Self::Put { span } => *span,
90            Self::Return { span } => *span,
91            Self::Remove { span } => *span,
92            Self::Roll { span } => *span,
93            Self::Search { span } => *span,
94            Self::Shuffle { span } => *span,
95            Self::Spend { span } => *span,
96        }
97    }
98}
99
100impl PlayerAction {
101    pub fn try_from_span(span: &crate::lexer::Span) -> Option<Self> {
102        match span.text {
103            "add" | "adds" => Some(Self::Add {
104                #[cfg(feature = "spanned_tree")]
105                span: span.into(),
106            }),
107            "attach" | "attaches" => Some(Self::Attach {
108                #[cfg(feature = "spanned_tree")]
109                span: span.into(),
110            }),
111            "change" | "changes" => Some(Self::Change {
112                #[cfg(feature = "spanned_tree")]
113                span: span.into(),
114            }),
115            "choose" | "chooses" | "choice" => Some(Self::Choose {
116                #[cfg(feature = "spanned_tree")]
117                span: span.into(),
118            }),
119            "distribute" => Some(Self::Distribute {
120                #[cfg(feature = "spanned_tree")]
121                span: span.into(),
122            }),
123            "draw" | "draws" => Some(Self::Draw {
124                #[cfg(feature = "spanned_tree")]
125                span: span.into(),
126            }),
127            "look at" | "looks at" => Some(Self::LookAt {
128                #[cfg(feature = "spanned_tree")]
129                span: span.into(),
130            }),
131            "lose" | "loses" => Some(Self::LookAt {
132                #[cfg(feature = "spanned_tree")]
133                span: span.into(),
134            }),
135            "pay" | "pays" | "paying" => Some(Self::Pay {
136                #[cfg(feature = "spanned_tree")]
137                span: span.into(),
138            }),
139            "prevent" | "prevented" => Some(Self::Prevent {
140                #[cfg(feature = "spanned_tree")]
141                span: span.into(),
142            }),
143            "return" | "returns" => Some(Self::Return {
144                #[cfg(feature = "spanned_tree")]
145                span: span.into(),
146            }),
147            "remove" | "removing" => Some(Self::Remove {
148                #[cfg(feature = "spanned_tree")]
149                span: span.into(),
150            }),
151            "roll" | "rolls" => Some(Self::Roll {
152                #[cfg(feature = "spanned_tree")]
153                span: span.into(),
154            }),
155            "search" | "searchs" => Some(Self::Search {
156                #[cfg(feature = "spanned_tree")]
157                span: span.into(),
158            }),
159            "shuffle" | "shuffles" => Some(Self::Shuffle {
160                #[cfg(feature = "spanned_tree")]
161                span: span.into(),
162            }),
163            "spend" | "spends" => Some(Self::Spend {
164                #[cfg(feature = "spanned_tree")]
165                span: span.into(),
166            }),
167            _ => None,
168        }
169    }
170}