489 lines
15 KiB
Rust
489 lines
15 KiB
Rust
use crate::utils;
|
|
use std::collections::HashMap;
|
|
use std::collections::HashSet;
|
|
use std::collections::VecDeque;
|
|
use std::fmt::Display;
|
|
|
|
const HEALTH: i32 = 200;
|
|
|
|
pub fn task1() {
|
|
let input = utils::read_file("input/day15.txt");
|
|
let mut game = Game::from_input(&input.lines().collect(), 3, 3);
|
|
println!("{}", game);
|
|
let mut round = 0;
|
|
while game.round() {
|
|
round += 1;
|
|
// println!("{}", game);
|
|
// println!("round was {}", round);
|
|
}
|
|
println!("Final full round was {}", round);
|
|
println!(
|
|
"Result: {}",
|
|
game.units.iter().map(|it| it.health).sum::<i32>() * round
|
|
);
|
|
}
|
|
|
|
pub fn task2() {
|
|
let input = utils::read_file("input/day15.txt");
|
|
let input = input.lines().collect();
|
|
let mut highest_fail = 3;
|
|
let mut lowest_win = None::<i32>;
|
|
while lowest_win.is_none() || lowest_win.unwrap() - 1 > highest_fail {
|
|
let attack = match lowest_win {
|
|
Some(upper) => highest_fail + (upper - highest_fail) / 2,
|
|
None => 2 * highest_fail,
|
|
};
|
|
let mut game = Game::from_input(&input, 3, attack);
|
|
let initial_elve_count = game
|
|
.units
|
|
.iter()
|
|
.filter(|unit| unit.warrior_type == WarriorType::Elve)
|
|
.count();
|
|
let mut round = 0;
|
|
while game.round() {
|
|
round += 1;
|
|
}
|
|
if game
|
|
.units
|
|
.iter()
|
|
.filter(|unit| unit.warrior_type == WarriorType::Elve)
|
|
.count()
|
|
== initial_elve_count
|
|
{
|
|
lowest_win = Some(attack);
|
|
} else {
|
|
highest_fail = attack;
|
|
}
|
|
println!(
|
|
"Result: {}",
|
|
game.units.iter().map(|it| it.health).sum::<i32>() * round
|
|
);
|
|
}
|
|
println!("Searching stopped with lowest win {:?}", lowest_win); // 7169 too low
|
|
}
|
|
|
|
#[derive(Clone, PartialEq)]
|
|
enum Tile {
|
|
Empty,
|
|
Wall,
|
|
}
|
|
|
|
#[derive(Clone, Copy, PartialEq, Debug)]
|
|
enum WarriorType {
|
|
Elve,
|
|
Goblin,
|
|
}
|
|
|
|
impl WarriorType {
|
|
fn enemy_type(&self) -> Self {
|
|
use self::WarriorType::*;
|
|
match self {
|
|
Elve => Goblin,
|
|
Goblin => Elve,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
|
struct Position(usize, usize);
|
|
|
|
impl Position {
|
|
fn neighbors(&self, width: usize, height: usize) -> Vec<Position> {
|
|
vec![
|
|
(self.0 as isize, self.1 as isize - 1),
|
|
(self.0 as isize - 1, self.1 as isize),
|
|
(self.0 as isize + 1, self.1 as isize),
|
|
(self.0 as isize, self.1 as isize + 1),
|
|
]
|
|
.into_iter()
|
|
.filter(|p| p.0 > 0 && p.0 < width as isize - 1 && p.1 > 0 && p.1 < height as isize - 1)
|
|
.map(|it| Position(it.0 as usize, it.1 as usize))
|
|
.collect()
|
|
}
|
|
|
|
fn manhattan_distance(&self, other: &Self) -> usize {
|
|
let a = if self.0 > other.0 {
|
|
self.0 - other.0
|
|
} else {
|
|
other.0 - self.0
|
|
};
|
|
let b = if self.1 > other.1 {
|
|
self.1 - other.1
|
|
} else {
|
|
other.1 - self.1
|
|
};
|
|
a + b
|
|
}
|
|
}
|
|
|
|
impl PartialOrd for Position {
|
|
fn partial_cmp(&self, other: &Self) -> std::option::Option<std::cmp::Ordering> {
|
|
if self.1 == other.1 {
|
|
Some(self.0.cmp(&other.0))
|
|
} else {
|
|
Some(self.1.cmp(&other.1))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Ord for Position {
|
|
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
|
|
if self.1 == other.1 {
|
|
self.0.cmp(&other.0)
|
|
} else {
|
|
self.1.cmp(&other.1)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Warrior {
|
|
warrior_type: WarriorType,
|
|
position: Position,
|
|
health: i32,
|
|
attack: i32,
|
|
}
|
|
|
|
struct Game {
|
|
units: Vec<Warrior>,
|
|
/// [x, y]
|
|
tiles: Vec<Vec<Tile>>,
|
|
width: usize,
|
|
height: usize,
|
|
}
|
|
|
|
impl Game {
|
|
fn closest_fighting_position(
|
|
&self,
|
|
from: Position,
|
|
target_type: WarriorType,
|
|
) -> Option<Position> {
|
|
let mut map = Map::from_game(self, from);
|
|
|
|
for unit in self.units.iter() {
|
|
if unit.warrior_type == target_type {
|
|
for neighbor in unit.position.neighbors(self.width, self.height) {
|
|
if map.fields[neighbor.0][neighbor.1] == MapTile::Empty {
|
|
map.fields[neighbor.0][neighbor.1] = MapTile::TargetNonOccupied;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
map.find_closest_target(from)
|
|
}
|
|
|
|
fn next_position(&self, from: Position, to: Position) -> Option<Position> {
|
|
if from == to {
|
|
return Some(from);
|
|
}
|
|
// let input = vec![
|
|
// (1, Position(from.0, from.1 - 1)),
|
|
// (2, Position(from.0 - 1, from.1)),
|
|
// (3, Position(from.0 + 1, from.1)),
|
|
// (4, Position(from.0, from.1 + 1)),
|
|
// ];
|
|
// if let Some((_, best)) = input
|
|
// .iter()
|
|
// .filter_map(|(delta, start)| {
|
|
// let map = Map::from_game(&self, from);
|
|
// if let Some(path) = map.shortest_path(*start, to) {
|
|
// Some((delta + path.len() * 10, *path.first().unwrap_or(start)))
|
|
// } else {
|
|
// None
|
|
// }
|
|
// })
|
|
// .min_by_key(|(d, _)| *d)
|
|
// {
|
|
// Some(best)
|
|
// } else {
|
|
// None
|
|
// }
|
|
let map = Map::from_game(self, from);
|
|
map.shortest_path(from, to)
|
|
.map(|path| *path.get(1).unwrap_or(&from))
|
|
}
|
|
|
|
/// Returns true if a full round was played, false if the round aborted because all
|
|
/// enemies of one party are dead
|
|
fn round(&mut self) -> bool {
|
|
self.units.sort_unstable_by_key(|it| it.position);
|
|
|
|
let mut curr = 0;
|
|
while curr < self.units.len() {
|
|
if !self
|
|
.units
|
|
.iter()
|
|
.any(|warrior| warrior.warrior_type == self.units[curr].warrior_type.enemy_type())
|
|
{
|
|
println!("There are no enemies anymore!");
|
|
return false;
|
|
}
|
|
|
|
// movement phase
|
|
if let Some(next_target_position) = self.closest_fighting_position(
|
|
self.units[curr].position,
|
|
self.units[curr].warrior_type.enemy_type(),
|
|
) {
|
|
if self.units[curr].position != next_target_position {
|
|
if let Some(next_position) =
|
|
self.next_position(self.units[curr].position, next_target_position)
|
|
{
|
|
// println!(
|
|
// "{:?} moves to {:?} via {:?}",
|
|
// self.units[curr].position, next_target_position, next_position
|
|
// );
|
|
self.units[curr].position = next_position;
|
|
} else {
|
|
panic!("We have a reachable target but no path to it! {:?} wants to go to {:?}", self.units[curr], next_target_position);
|
|
}
|
|
}
|
|
}
|
|
|
|
// attack phase
|
|
let neighbors = self.units[curr].position.neighbors(self.width, self.height);
|
|
let mut close_enemies: Vec<usize> = self
|
|
.units
|
|
.iter()
|
|
.enumerate()
|
|
.filter(|(_, it)| it.warrior_type == self.units[curr].warrior_type.enemy_type())
|
|
.filter(|(_, it)| neighbors.contains(&it.position))
|
|
.map(|(i, _)| i)
|
|
.collect();
|
|
close_enemies.sort_unstable_by(|a, b| {
|
|
let a = &self.units[*a];
|
|
let b = &self.units[*b];
|
|
if a.health == b.health {
|
|
a.position.cmp(&b.position)
|
|
} else {
|
|
a.health.cmp(&b.health)
|
|
}
|
|
});
|
|
if let Some(closest_index) = close_enemies.first() {
|
|
if self.units[*closest_index]
|
|
.position
|
|
.manhattan_distance(&self.units[curr].position)
|
|
> 1
|
|
{
|
|
panic!("Distance WTF")
|
|
}
|
|
let attack = self.units[curr].attack;
|
|
let enemy = &mut self.units[*closest_index];
|
|
enemy.health -= attack;
|
|
if enemy.health <= 0 {
|
|
let enemy = self.units.remove(*closest_index);
|
|
if *closest_index < curr {
|
|
curr -= 1;
|
|
}
|
|
self.tiles[enemy.position.0][enemy.position.1] = Tile::Empty;
|
|
}
|
|
}
|
|
curr += 1;
|
|
}
|
|
true
|
|
}
|
|
|
|
fn from_input(input: &Vec<&str>, goblin_attack: i32, elve_attack: i32) -> Self {
|
|
use self::Tile::*;
|
|
use self::WarriorType::*;
|
|
let width = input[0].len();
|
|
let height = input.len();
|
|
let mut inner_vec = Vec::new();
|
|
inner_vec.resize(height, Empty);
|
|
let mut tiles = Vec::new();
|
|
tiles.resize(width, inner_vec);
|
|
|
|
let mut units = Vec::new();
|
|
for (y, line) in input.iter().enumerate() {
|
|
for (x, c) in line.chars().enumerate() {
|
|
tiles[x][y] = match c {
|
|
'.' => Empty,
|
|
'#' => Wall,
|
|
'E' => {
|
|
units.push(Warrior {
|
|
warrior_type: Elve,
|
|
position: Position(x, y),
|
|
health: HEALTH,
|
|
attack: elve_attack,
|
|
});
|
|
Empty
|
|
}
|
|
'G' => {
|
|
units.push(Warrior {
|
|
warrior_type: Goblin,
|
|
position: Position(x, y),
|
|
health: HEALTH,
|
|
attack: goblin_attack,
|
|
});
|
|
Empty
|
|
}
|
|
c => panic!("Unexpected input character '{}'", c),
|
|
}
|
|
}
|
|
}
|
|
|
|
Game {
|
|
units,
|
|
tiles,
|
|
width,
|
|
height,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for Game {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
|
|
use self::Tile::*;
|
|
for y in 0..self.height {
|
|
let mut line = String::with_capacity(self.width);
|
|
for x in 0..self.width {
|
|
if let Some(warrior) = self.units.iter().find(|it| it.position == Position(x, y)) {
|
|
line.push(match warrior.warrior_type {
|
|
WarriorType::Elve => 'E',
|
|
WarriorType::Goblin => 'G',
|
|
});
|
|
} else {
|
|
line.push(match &self.tiles[x][y] {
|
|
Empty => '.',
|
|
Wall => '#',
|
|
});
|
|
}
|
|
}
|
|
f.write_str(&line)?;
|
|
f.write_str("\n")?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Map {
|
|
fields: Vec<Vec<MapTile>>,
|
|
width: usize,
|
|
height: usize,
|
|
}
|
|
|
|
#[derive(PartialEq, Debug)]
|
|
enum MapTile {
|
|
Empty,
|
|
TargetNonOccupied,
|
|
Occupied,
|
|
}
|
|
|
|
impl Display for Map {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
|
|
use self::MapTile::*;
|
|
for y in 0..self.height {
|
|
let mut line = String::with_capacity(self.width);
|
|
for x in 0..self.width {
|
|
line.push(match &self.fields[x][y] {
|
|
Empty => '.',
|
|
Occupied => 'X',
|
|
TargetNonOccupied => 'o',
|
|
});
|
|
}
|
|
f.write_str(&line)?;
|
|
f.write_str("\n")?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Map {
|
|
fn from_game(game: &Game, clear: Position) -> Self {
|
|
let mut fields = Vec::with_capacity(game.width);
|
|
for x in 0..game.width {
|
|
let mut new = Vec::with_capacity(game.height);
|
|
for y in 0..game.height {
|
|
new.push(match &game.tiles[x][y] {
|
|
Tile::Empty => MapTile::Empty,
|
|
Tile::Wall => MapTile::Occupied,
|
|
});
|
|
}
|
|
fields.push(new);
|
|
}
|
|
for warrior in game.units.iter() {
|
|
fields[warrior.position.0][warrior.position.1] = MapTile::Occupied;
|
|
}
|
|
fields[clear.0][clear.1] = MapTile::Empty;
|
|
Map {
|
|
fields,
|
|
width: game.width,
|
|
height: game.height,
|
|
}
|
|
}
|
|
|
|
fn shortest_path(&self, from: Position, to: Position) -> Option<Vec<Position>> {
|
|
if to == from {
|
|
return Some(vec![]);
|
|
}
|
|
if self.fields[from.0][from.1] != MapTile::Empty {
|
|
return None;
|
|
}
|
|
let mut open: VecDeque<(Option<Position>, Position)> = VecDeque::new();
|
|
open.push_back((None, from));
|
|
let mut predecessors: HashMap<Position, Option<Position>> = HashMap::new();
|
|
|
|
while let Some((predecessor, curr_pos)) = open.pop_front() {
|
|
predecessors.insert(curr_pos, predecessor);
|
|
if curr_pos == to {
|
|
break;
|
|
}
|
|
if self.fields[curr_pos.0][curr_pos.1] != MapTile::Empty {
|
|
continue;
|
|
}
|
|
for pos in curr_pos.neighbors(self.width, self.height) {
|
|
if !predecessors.contains_key(&pos) && !open.iter().any(|it| it.1 == pos) {
|
|
open.push_back((Some(curr_pos), pos));
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(Some(_)) = predecessors.get(&to) {
|
|
let mut result: Vec<Position> = Vec::new();
|
|
let mut current = to;
|
|
result.push(current);
|
|
while let Some(Some(predecessor)) = predecessors.get(¤t) {
|
|
result.push(*predecessor);
|
|
current = *predecessor;
|
|
}
|
|
result.reverse();
|
|
Some(result)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn find_closest_target(&self, from: Position) -> Option<Position> {
|
|
let mut open: VecDeque<(usize, Position)> = VecDeque::new();
|
|
open.push_back((0, from));
|
|
let mut visited: HashSet<Position> = HashSet::new();
|
|
let mut current_found_distance = usize::max_value();
|
|
let mut candidates: Vec<Position> = Vec::new();
|
|
|
|
while let Some((curr_dist, curr_pos)) = open.pop_front() {
|
|
if curr_dist > current_found_distance {
|
|
break;
|
|
}
|
|
if self.fields[curr_pos.0][curr_pos.1] == MapTile::TargetNonOccupied {
|
|
candidates.push(curr_pos);
|
|
current_found_distance = curr_dist;
|
|
// all others would have a higher distance and therefore are not relevant
|
|
continue;
|
|
}
|
|
if self.fields[curr_pos.0][curr_pos.1] == MapTile::Occupied {
|
|
continue;
|
|
}
|
|
for pos in curr_pos.neighbors(self.width, self.height) {
|
|
if !visited.contains(&pos) && !open.iter().any(|it| it.1 == pos) {
|
|
open.push_back((curr_dist + 1, pos));
|
|
}
|
|
}
|
|
visited.insert(curr_pos);
|
|
}
|
|
|
|
candidates.sort_unstable();
|
|
candidates.first().copied()
|
|
}
|
|
}
|