store tile vacancy in grid

src/marble_engine/board.rs

@@ -26,7 +26,7 @@ impl Board {
 			rows.push(tiles);
 		}
 		for line in &mut rows {
-			line.resize(width, Tile::Blank);
+			line.resize(width, Tile::default());
 		}
 
 		Board::new(rows)
@@ -44,7 +44,7 @@ impl Board {
 	}
 
 	pub fn new_empty(width: usize, height: usize) -> Self {
-		let rows = vec![vec![Tile::Blank; width]; height];
+		let rows = vec![vec![Tile::default(); width]; height];
 		Self {
 			rows,
 			width,
@@ -65,7 +65,7 @@ impl Board {
 		for row in &self.rows {
 			for tile in row {
 				match tile {
-					Tile::Blank | Tile::Block => (),
+					Tile::Open(OpenTile::Blank, _) | Tile::Block => (),
 					_ => sum += 1,
 				}
 			}
@@ -104,7 +104,7 @@ impl Board {
 	pub fn get_blank_mut(&mut self, p: Pos) -> Option<&mut Tile> {
 		if self.in_bounds(p) {
 			let tile = &mut self.rows[p.y as usize][p.x as usize];
-			if tile == &Tile::Blank {
+			if let Tile::Open(OpenTile::Blank, _) = tile{
 				return Some(tile);
 			}
 		}
@@ -147,7 +147,7 @@ impl Board {
 		if p.x < 0 {
 			let len = p.x.unsigned_abs() as usize;
 			for row in &mut self.rows {
-				let mut new_row = vec![Tile::Blank; len];
+				let mut new_row = vec![Tile::default(); len];
 				new_row.append(row);
 				*row = new_row;
 			}
@@ -156,21 +156,21 @@ impl Board {
 		} else if p.x as usize >= self.width {
 			let new_width = p.x as usize + 1;
 			for row in &mut self.rows {
-				row.resize(new_width, Tile::Blank);
+				row.resize(new_width, Tile::default());
 			}
 			self.width = new_width;
 		}
 
 		if p.y < 0 {
 			let len = p.y.unsigned_abs() as usize;
-			let mut new_rows = vec![vec![Tile::Blank; self.width]; len];
+			let mut new_rows = vec![vec![Tile::default(); self.width]; len];
 			new_rows.append(&mut self.rows);
 			self.rows = new_rows;
 			offset_y = len;
 			self.height += len;
 		} else if p.y as usize >= self.height {
 			let new_height = p.y as usize + 1;
-			self.rows.resize(new_height, vec![Tile::Blank; self.width]);
+			self.rows.resize(new_height, vec![Tile::default(); self.width]);
 			self.height = new_height;
 		}
 		(offset_x as PosInt, offset_y as PosInt)

src/marble_engine/tile.rs

@@ -2,21 +2,31 @@ use crate::marble_engine::Pos;
 
 pub type MarbleValue = u32;
 
-#[derive(Debug, Default, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Tile {
-	#[default]
-	Blank,
+	Open(OpenTile, MarbleTarget),
 	Block,
-	Marble {
-		value: MarbleValue,
-		dir: Direction,
-	},
-	Digit(u8),
+	Marble { value: MarbleValue, dir: Direction },
 	Mirror(MirrorType),
 	Arrow(Direction),
 	Powerable(PTile, bool),
 }
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum MarbleTarget {
+	Free,
+	ClaimedIndirect,
+	Claimed,
+	BlockedIndirect,
+	Blocked,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum OpenTile {
+	Blank,
+	Digit(u8),
+}
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum PTile {
 	Trigger,
@@ -66,6 +76,12 @@ pub enum Direction {
 	Right,
 }
 
+impl Default for Tile {
+	fn default() -> Self {
+		Tile::Open(OpenTile::Blank, MarbleTarget::Free)
+	}
+}
+
 impl Tile {
 	pub const fn from_char(c: char) -> Tile {
 		match c {
@@ -95,19 +111,18 @@ impl Tile {
 			'D' => Tile::Powerable(PTile::Math(MathOp::Div), false),
 			'R' => Tile::Powerable(PTile::Math(MathOp::Rem), false),
 			'B' => Tile::Powerable(PTile::Bag, false),
-			d @ '0'..='9' => Tile::Digit(d as u8 - b'0'),
+			d @ '0'..='9' => Tile::Open(OpenTile::Digit(d as u8 - b'0'), MarbleTarget::Free),
 			'#' => Tile::Block,
-			' ' => Tile::Blank,
-			_ => Tile::Blank,
+			_ => Tile::Open(OpenTile::Blank, MarbleTarget::Free),
 		}
 	}
 
 	pub fn to_char(self) -> char {
 		match self {
-			Tile::Blank => ' ',
+			Tile::Open(OpenTile::Blank, _) => ' ',
 			Tile::Block => '#',
 			Tile::Marble { value: _, dir: _ } => 'o',
-			Tile::Digit(n) => (b'0' + n) as char,
+			Tile::Open(OpenTile::Digit(n), _) => (b'0' + n) as char,
 			Tile::Mirror(dir) => match dir {
 				MirrorType::Forward => '/',
 				MirrorType::Back => '\\',
@@ -146,23 +161,23 @@ impl Tile {
 	}
 
 	pub fn is_blank(&self) -> bool {
-		matches!(self, Tile::Blank)
+		matches!(self, Tile::Open(OpenTile::Blank, _))
 	}
 
 	pub fn read_value(&self) -> MarbleValue {
 		match self {
 			Tile::Marble { value, dir: _ } => *value,
-			Tile::Digit(d) => *d as MarbleValue,
+			Tile::Open(OpenTile::Digit(d), _) => *d as MarbleValue,
 			_ => 0,
 		}
 	}
 
 	pub fn texture(&self) -> String {
 		match self {
-			Tile::Blank => "",
+			Tile::Open(OpenTile::Blank, _) => "",
 			Tile::Block => "block",
 			Tile::Marble { value: _, dir: _ } => "marble",
-			Tile::Digit(n) => return format!("tile_digit_{n}"),
+			Tile::Open(OpenTile::Digit(n), _) => return format!("tile_digit_{n}"),
 			Tile::Mirror(mirror) => mirror.texture_name(),
 			Tile::Arrow(dir) => dir.arrow_tile_texture_name(),
 			Tile::Powerable(tile, state) => {