Compiler Explorer

Source code

use std::collections::HashMap;

#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
struct Pos {
    row: i8,
    col: i8
}

impl std::ops::Add for Pos {
    type Output = Pos;

fn add(self, other: Pos) -> Pos {
        Pos::new(self.row + other.row, self.col + other.col)
    }
}

impl std::ops::Sub for Pos {
    type Output = Pos;

fn sub(self, other: Pos) -> Pos {
        Pos::new(self.row - other.row, self.col - other.col)
    }
}

impl Pos {
    fn new(row: i8, col: i8) -> Pos {
        Pos { row, col }
    }
    
    fn get_index(self, width: i8) -> usize {
        (self.row*width + self.col) as usize
    }
    
    fn length_sq(self) -> i32 {
        let r = self.row as i32;
        let c = self.col as i32;
        r*r + c*c
    }
    
    pub fn adjacent_positions(self, width: i8, height: i8) -> AdjacencyIterator {
        AdjacencyIterator {
            pos: self,
            count: 0,
            width: width,
            height: height,
        }
    }
}

struct AdjacencyIterator {
    pos: Pos,
    width: i8,
    height: i8,
    count: usize,
}

impl Iterator for AdjacencyIterator {
    type Item = Pos;

fn next(&mut self) -> Option<Pos> {
        // NWES; reading order
        let offsets = [Pos::new(-1, 0), Pos::new(0, -1), Pos::new(0, 1), Pos::new(1, 0)];
        
        // Probably a clever way to do this
        let mut result: Option<Pos> = None;
        while result.is_none() && self.count < offsets.len() {
            let p = self.pos + offsets[self.count];
            if p.row >= 0 && p.row < self.height && p.col >= 0 && p.col < self.width {
                result = Some(p);
            }
            self.count += 1;
        }

result
    }
}

struct Unit {
    pos: Pos,
    team: i32
}

impl Unit {
    fn is_enemy(&self, other: &Unit) -> bool {
        self.team != other.team
    }
    
    fn new(pos: Pos, team: i32) -> Unit {
        Unit { pos, team }
    }
}

fn main() {
    const WIDTH : i8 = 8;
    const HEIGHT : i8 = 10;
    const SIZE : usize = WIDTH as usize * HEIGHT as usize;
    
    let mut units : Vec<Unit> = vec![Unit::new(Pos::new(7,3),0), Unit::new(Pos::new(2,4),1)];
    let mut walls : Vec<bool> = vec![false; SIZE];
    let mut occupied : Vec<bool> = vec![false; SIZE];
    
    let dude = &units[0];
    
    let slot = units 
        .iter()
        .filter(|unit| unit.is_enemy(&dude)) // ignore non-enemies
        .flat_map(|unit| unit.pos.adjacent_positions(WIDTH,HEIGHT)) // iterate adjacent positions
        .filter(|pos| { 
            let idx = pos.get_index(WIDTH);
            !walls[idx] && !occupied[idx]
        }) // ignore walls or occupied spaces
        .min_by_key(|pos| (dude.pos - *pos).length_sq()); // pick closest slot

println!("{:?}", slot);
}