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
|
use std::path::Path;
use rayon::prelude::*;
use steam_powered_wyrm::game;
use steam_powered_wyrm::json;
use steam_powered_wyrm::strategy::{choose_move_with_normalized_perf, ScoreConfig};
fn main() {
let initial_state = game::GameBoard::new(
json::read_state_from_json_file(&Path::new(&format!("./tests/example-state.json")))
.unwrap(),
);
let depth = 1000;
let configs = ScoreConfigTrials {
max_health_weight: vec![50., 150.],
total_health_weight: vec![5., 20.],
points_weight: vec![1.],
victory_weight: vec![3000., 3500., 4000., 4500., 5000., 5500., 6000., 7000.],
snowball_weight: vec![10.],
bomb_weight: vec![0.],
explore_exploit_weight: vec![10., 500.],
}
.reify();
eprintln!("{} configs being tested", configs.len());
let mut victories = vec![0; configs.len()];
for i in 0..configs.len() {
eprintln!("Progress: {} of {}", i, configs.len());
let outcomes: Vec<(usize, game::SimulationOutcome)> = (i + 1..configs.len())
.collect::<Vec<usize>>()
.par_iter()
.map(|j| {
let mut state = initial_state.clone();
while state.outcome == game::SimulationOutcome::Continue {
let commands = [
choose_move_with_normalized_perf(&state, &configs[i], 0, depth),
choose_move_with_normalized_perf(&state, &configs[*j], 1, depth),
];
state.simulate(commands);
}
(*j, state.outcome)
})
.collect();
for (j, outcome) in outcomes {
match outcome {
game::SimulationOutcome::PlayerWon(0) => victories[i] += 1,
game::SimulationOutcome::PlayerWon(1) => victories[j] += 1,
_ => {}
};
}
}
println!("victories, max_health_weight, total_health_weight, points_weight, victory_weight, snowball_weight, bomb_weight, explore_exploit_weight");
for (config, victories) in configs.into_iter().zip(victories.iter()) {
println!(
"{}, {}, {}, {}, {}, {}, {}, {}",
victories,
config.max_health_weight,
config.total_health_weight,
config.points_weight,
config.victory_weight,
config.snowball_weight,
config.bomb_weight,
config.explore_exploit_weight
);
}
}
pub struct ScoreConfigTrials {
pub max_health_weight: Vec<f32>,
pub total_health_weight: Vec<f32>,
pub points_weight: Vec<f32>,
pub victory_weight: Vec<f32>,
pub snowball_weight: Vec<f32>,
pub bomb_weight: Vec<f32>,
pub explore_exploit_weight: Vec<f32>,
}
impl ScoreConfigTrials {
fn reify(self) -> Vec<ScoreConfig> {
let mut result = Vec::new();
for max_health_weight in &self.max_health_weight {
for total_health_weight in &self.total_health_weight {
for points_weight in &self.points_weight {
for victory_weight in &self.victory_weight {
for snowball_weight in &self.snowball_weight {
for bomb_weight in &self.bomb_weight {
for explore_exploit_weight in &self.explore_exploit_weight {
result.push(ScoreConfig {
max_health_weight: *max_health_weight,
total_health_weight: *total_health_weight,
points_weight: *points_weight,
victory_weight: *victory_weight,
snowball_weight: *snowball_weight,
bomb_weight: *bomb_weight,
explore_exploit_weight: *explore_exploit_weight,
});
}
}
}
}
}
}
}
result
}
}
|