rubot 0.3.0

A generic game bot written in Rust
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277

//! tests where the Bot completely analyses the tree and should select the best action
use super::*;

/// Who would have ever imagined that a length of 0 can cause problems.
/// I obviously did not, that's why I had to add this test.
#[test]
fn empty() {
    #[rustfmt::skip]
    let empty = Node::root();

    assert_eq!(Bot::new(true).select(&empty, ToCompletion), None);
}

/// Tests if the trivial case works
#[test]
fn depth_one() {
    #[rustfmt::skip]
    let depth_one = Node::root().with_children(&[
        Node::new(true, 0),
        Node::new(true, 2),
        Node::new(true, 1),
    ]);

    // Some(1) to love
    assert_eq!(Bot::new(true).select(&depth_one, ToCompletion), Some(1));
}

/// Tests if terminating nodes get ignored in case another branch is longer
#[test]
fn different_depths() {
    #[rustfmt::skip]
    let different_depths = Node::root().with_children(&[
        Node::new(false, 0).with_children(&[
            Node::new(true, 0),
        ]),
        Node::new(false, 1),
    ]);

    // Some(1) to love
    assert_eq!(
        Bot::new(true).select(&different_depths, ToCompletion),
        Some(1)
    );
}

/// This test tries to catch errors where alpha values are not removed after each depth,
/// which can cause a beta cutoff at [1][0][0], causing the returned fitness to be 4 instead of 2.
#[test]
fn alpha_reuse() {
    #[rustfmt::skip]
    let alpha_reuse = Node::root().with_children(&[
        Node::new(false, 0).with_children(&[
            Node::new(false, 5).with_children(&[
                Node::new(true, 3),
            ]),
        ]),
        Node::new(false, 1).with_children(&[
            Node::new(false, 6).with_children(&[
                Node::new(true, 4),
                Node::new(true, 2),
            ]),
        ]),
    ]);

    assert_eq!(Bot::new(true).select(&alpha_reuse, ToCompletion), Some(0));
}

/// Removing a branch which seems to terminate can be dangerous in case no deeper nodes are
/// visited due to a cutoff. This test checks this by having a beta cutoff at [2][0]. In case the branch
/// gets stored as having a fitness of 4, instead of only having a fitness of **at most** 4,
/// [2] ends up getting preferred over [1], even though the actual fitness values are 2 and 3 respectively.
///
/// Note: [0] is a deep branch with only bad options to prevent another bug from interfering. <3
#[test]
fn premature_termination() {
    #[rustfmt::skip]
    let premature_termination = Node::root().with_children(&[
        Node::new(false, 0).with_children(&[
            Node::new(false, 0).with_children(&[
                Node::new(false, 0).with_children(&[
                    Node::new(false, 0),
                ]),
            ]),
        ]),
        Node::new(false, 0).with_children(&[
            Node::new(true, 5).with_children(&[
                Node::new(true, 5).with_children(&[
                    Node::new(true, 3),
                ]),
            ]),
        ]),
        Node::new(false, 0).with_children(&[
            Node::new(false, 4),
            Node::new(false, 2).with_children(&[
                Node::new(false, 2),
            ]),
        ]),
    ]);

    assert_eq!(
        Bot::new(true).select(&premature_termination, ToCompletion),
        Some(1)
    );
}

/// The world is weird.
#[test]
fn fuzz_one() {
    #[rustfmt::skip]
    let fuzz_one = Node::root().with_children(&[
        // fitness: 3
        Node::new(true, 0).with_children(&[
            Node::new(false, 0).with_children(&[
                Node::new(false, 1),
            ]),
            Node::new(true, 0),
        ]),
        // fitness: 0
        Node::new(false, 0).with_children(&[
            Node::new(false, 0).with_children(&[
                Node::new(true, 2).with_children(&[
                    Node::new(true, 3).with_children(&[
                        Node::new(true, 0),
                    ]),
                ]),
            ]),
        ]),
        // fitness: 0
        Node::new(true, 0),
    ]);

    assert_eq!(Bot::new(true).select(&fuzz_one, ToCompletion), Some(0));
}

/// error due to incorrect interpretation of the cutoff
/// in [1][0][1]
#[test]
fn fuzz_two() {
    #[rustfmt::skip]
    let fuzz_two = Node::root().with_children(&[
        // fitness 32
        Node::new(true, 74).with_children(&[
            Node::new(true, 2).with_children(&[
                Node::new(false, 1).with_children(&[
                    Node::new(false, -119),
                ]),
                Node::new(true, 42),
            ]),
        ]),
        // fitness 0
        Node::new(true, 0).with_children(&[
            Node::new(false, 0).with_children(&[
                Node::new(true, -1),
                Node::new(true, 42),
            ]),
            Node::new(true, 0),
        ]),
    ]);

    assert_eq!(Bot::new(true).select(&fuzz_two, ToCompletion), Some(0));
}

#[test]
fn fuzz_three() {
    #[rustfmt::skip]
    let fuzz_three = Node::root().with_children(&[
        // fitness 3
        Node::new(false, 1).with_children(&[
            Node::new(false, 2).with_children(&[
                Node::new(true, 10).with_children(&[
                    Node::new(true, 3),
                    Node::new(true, 10).with_children(&[
                        Node::new(true, 0),
                    ]),
                ]),
            ]),
        ]),
        // fitness 8
        Node::new(true, 8).with_children(&[
            Node::new(true, 2),
            Node::new(false, 0).with_children(&[
                Node::new(true, 8),
                Node::new(true, 10),
            ]),
        ]),
    ]);

    assert_eq!(Bot::new(true).select(&fuzz_three, ToCompletion), Some(1));
}

#[test]
fn fuzz_four() {
    #[rustfmt::skip]
    let fuzz_four = Node::root().with_children(&[
        Node::new(true, 0).with_children(&[
            Node::new(true, 32).with_children(&[
                Node::new(false, 127),
            ]),
        ]),
        Node::new(false, 0).with_children(&[
            Node::new(false, 0),
        ])
    ]);

    assert_eq!(Bot::new(true).select(&fuzz_four, ToCompletion), Some(0));
}

/// There was a time where we handled bounds wrong. We used `alpha` and `beta`
/// for upper and lower limits, but did not check this correctly in all cases.
#[test]
fn fuzz_five() {
    #[rustfmt::skip]
    let fuzz_five = Node::root().with_children(&[
        Node::new(true, -26).with_children(&[
            Node::new(true, 0),
        ]),
        Node::new(false, 32).with_children(&[
            Node::new(true, 127).with_children(&[
                Node::new(false, 127),
            ])
        ])
    ]);

    assert_eq!(Bot::new(true).select(&fuzz_five, ToCompletion), Some(1));
}

/// Tests for a bug which caused [0] to always return Terminated(Worse(1)), as [0][1][1]
/// causes an alpha beta cutoff, returning Worse(1). This replaced Equal(1)
/// because I accidentally wrote `old_fitness <= new_fitness` instead of
/// `old_fitness < new_fitness`.
#[test]
fn subtree_cutoff() {
    let subtree_cutoff = Node::root().with_children(&[
        Node::new(true, -63).with_children(&[
            // Branch::Equal(one)
            Node::new(true, 1),
            Node::new(false, -2).with_children(&[
                Node::new(false, 10).with_children(&[Node::new(true, -63)]),
                Node::new(true, 1),
            ]),
        ]),
        Node::new(false, -2),
    ]);

    assert_eq!(
        Bot::new(true).select(&subtree_cutoff, ToCompletion),
        Some(0)
    );
}

// In case all actions are worse than the lower bound, return the action taking the
// most steps to get there.
#[test]
fn with_my_dying_breath() {
    #[rustfmt::skip]
    let tree = Node::root().with_children(&[
        Node::new(true, 0).with_children(&[
            Node::new(true, i8::MIN),
        ]),
        Node::new(true, i8::MIN),
    ]);
    assert_eq!(Bot::new(true).select(&tree, ToCompletion), Some(0));

    #[rustfmt::skip]
    let tree = Node::root().with_children(&[
        Node::new(true, 0).with_children(&[
            Node::new(true, i8::MIN),
        ]),
        Node::new(true, 0).with_children(&[
            Node::new(true, 0).with_children(&[
                Node::new(true, i8::MIN),
            ]),
        ]),
        Node::new(true, i8::MIN),
    ]);
    assert_eq!(Bot::new(true).select(&tree, ToCompletion), Some(1));
}