Dandellion
/
mercury
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
mercury/src/azul.rs

798 lines
23 KiB
Rust
Raw Blame History

use std::{hash::Hash, ops::{Deref, DerefMut}};
use rand::prelude::*;
use rand::distributions::WeightedIndex;
//use smallvec::{SmallVec, smallvec};
//use alloc_counter::{AllocCounterSystem, no_alloc};
//#[global_allocator]
//static A: AllocCounterSystem = AllocCounterSystem;
extern crate byte_strings;
use ::byte_strings::concat_bytes;
pub fn size_of_stuff() {
println!("size of azul game: {}", std::mem::size_of::<Game>());
println!("size of azul tile: {}", std::mem::size_of::<Tile>());
println!("size of azul bag: {}", std::mem::size_of::<Bag>());
println!("size of azul market: {}", std::mem::size_of::<Market>());
println!("size of azul factories: {}", std::mem::size_of::<tinyvec::ArrayVec<[Factory; 9]>>());
println!("size of azul factory array: {}", std::mem::size_of::<[Factory; 9]>());
println!("size of azul factory: {}", std::mem::size_of::<Factory>());
println!("size of azul boards: {}", std::mem::size_of::<tinyvec::ArrayVec<[Board; 4]>>());
println!("size of azul board array: {}", std::mem::size_of::<[Board; 4]>());
println!("size of azul board: {}", std::mem::size_of::<Board>());
println!("size of azul option tile: {}", std::mem::size_of::<Option<Tile>>());
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum Tile {
// None,
Start,
Blue,
Yellow,
Red,
Black,
Teal
}
impl Default for Tile {
fn default() -> Self {
// Tile::None
Tile::Blue
}
}
impl IntoIterator for Tile {
type Item = Tile;
type IntoIter = TileIter;
fn into_iter(self) -> Self::IntoIter {
TileIter {
current: self
}
}
}
/*impl From<Option<Tile>> for Tile {
fn from(option: Option<Tile>) -> Tile {
match option {
Option::None => Tile::None,
Some(tile) => tile
}
}
}*/
pub struct TileIter {
current: Tile
}
impl Iterator for TileIter {
type Item = Tile;
fn next(&mut self) -> Option<Tile>{
match self.current {
Tile::Blue => {
let next = Tile::Yellow;
self.current = next;
Some(next)
},
Tile::Yellow => {
let next = Tile::Red;
self.current = next;
Some(next)
},
Tile::Red => {
let next = Tile::Black;
self.current = next;
Some(next)
},
Tile::Black => {
let next = Tile::Teal;
self.current = next;
Some(next)
},
_ => None
}
}
}
// factory, color, pattern line
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct GameMove (pub usize, pub Tile, pub usize);
impl Default for GameMove {
fn default() -> Self {
GameMove(0, Tile::Blue, 1)
}
}
impl IntoIterator for GameMove {
type Item = GameMove;
type IntoIter = GameMoveIter;
fn into_iter(self) -> Self::IntoIter {
GameMoveIter {
players: 4,
current: self
}
}
}
#[derive(Debug)]
pub struct GameMoveIter {
players: u8,
current: GameMove
}
impl GameMoveIter {
pub fn new(players: u8) -> Self {
GameMoveIter {
players: players,
current: GameMove::default()
}
}
}
fn get_n_factories(players: u8) -> Result<u8, &'static str> {
return match players {
2 => Ok(5),
3 => Ok(7),
4 => Ok(9),
_ => Err("Not a valid amount of players")
};
}
impl Iterator for GameMoveIter {
type Item = GameMove;
fn next(&mut self) -> Option<GameMove> {
let factory = self.current.0;
let tile = self.current.1;
let pattern = self.current.2;
let max_factories = match get_n_factories(self.players) {
Ok(n) => n,
Err(_) => return None
} as usize;
if factory == max_factories && tile == Tile::Teal && pattern == 0 {
return None
}
else if factory == max_factories && tile == Tile::Teal {
let next = GameMove(0, Tile::Blue, (pattern + 1) % 6);
self.current = next;
return Some(next)
}
else if factory == max_factories {
let next = GameMove(0, tile.into_iter().next().unwrap(), pattern);
self.current = next;
return Some(next)
}
else {
let next = GameMove(factory + 1, tile, pattern);
self.current = next;
return Some(next)
}
}
}
#[derive(Clone, Debug, Copy, PartialEq, Eq, Hash)]
struct Bag {
blue: u8,
yellow: u8,
red: u8,
black: u8,
teal: u8,
}
impl Default for Bag {
fn default() -> Self {
Bag {
blue: 20,
yellow: 20,
red: 20,
black: 20,
teal: 20,
}
}
}
impl Bag {
fn len(&self) -> u8 {
self.blue + self.yellow + self.red + self.black + self.teal
}
fn is_empty(&self) -> bool {
self.len() == 0
}
fn hash(&self) -> [u8; 5] {
[
self.blue,
self.yellow,
self.red,
self.black,
self.teal
]
}
}
/*#[derive(Clone, Debug, Copy, PartialEq, Eq, Hash)]
struct Bag (tinyvec::ArrayVec::<[Tile; 128]>);
impl Default for Bag {
fn default() -> Self {
let mut bag = tinyvec::ArrayVec::<[Tile; 128]>::new();
for _ in 0..20 {
bag.push(Tile::Blue);
};
for _ in 0..20 {
bag.push(Tile::Yellow);
};
for _ in 0..20 {
bag.push(Tile::Red);
};
for _ in 0..20 {
bag.push(Tile::Black);
};
for _ in 0..20 {
bag.push(Tile::Teal);
};
Bag(bag)
}
}
impl Deref for Bag {
type Target = tinyvec::ArrayVec<[Tile; 128]>;
fn deref(&self) -> &tinyvec::ArrayVec<[Tile; 128]> {
&self.0
}
}
impl DerefMut for Bag {
fn deref_mut(&mut self) -> &mut tinyvec::ArrayVec<[Tile; 128]> {
&mut self.0
}
}
impl From<tinyvec::ArrayVec<[Tile; 128]>> for Bag {
fn from(vector: tinyvec::ArrayVec<[Tile; 128]>) -> Bag {
Bag(vector)
}
}*/
#[derive(Default, Debug, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
struct Factory (tinyvec::ArrayVec<[Tile; 4]>);
impl Clone for Factory {
//#[no_alloc]
fn clone(&self) -> Self {
Factory(self.0.clone())
}
}
impl Deref for Factory {
type Target = tinyvec::ArrayVec<[Tile; 4]>;
fn deref(&self) -> &tinyvec::ArrayVec<[Tile; 4]> {
&self.0
}
}
impl DerefMut for Factory {
fn deref_mut(&mut self) -> &mut tinyvec::ArrayVec<[Tile; 4]> {
&mut self.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct Market (tinyvec::ArrayVec<[Tile; 28]>);
impl Default for Market {
fn default() -> Self {
// tiles * factories + start = 3 * 9 + 1 = 28
let mut market = tinyvec::ArrayVec::<[Tile; 28]>::new();
market.push(Tile::Start);
Market(market)
}
}
impl Deref for Market {
type Target = tinyvec::ArrayVec<[Tile; 28]>;
fn deref(&self) -> &tinyvec::ArrayVec<[Tile; 28]> {
&self.0
}
}
impl DerefMut for Market {
fn deref_mut(&mut self) -> &mut tinyvec::ArrayVec<[Tile; 28]> {
&mut self.0
}
}
type Patterns = [tinyvec::ArrayVec<[Tile; 5]>; 5];
type Row = [bool; 5];
type Wall = [Row; 5];
#[derive(Debug, Clone, Default, Copy, PartialEq, Eq, Hash)]
struct Board {
score: u8,
wall: Wall,
floor: tinyvec::ArrayVec<[Tile; 20]>,
patterns: Patterns,
}
impl Board {
fn wall_index(color: Tile, row: usize) -> Result<usize, &'static str> {
match row {
0 => {
match color {
Tile::Blue => Ok(0),
Tile::Yellow => Ok(1),
Tile::Red => Ok(2),
Tile::Black => Ok(3),
Tile::Teal => Ok(4),
_ => return Err("Not a valid tile on the wall")
}
},
1 => {
match color {
Tile::Blue => Ok(1),
Tile::Yellow => Ok(2),
Tile::Red => Ok(3),
Tile::Black => Ok(4),
Tile::Teal => Ok(0),
_ => return Err("Not a valid tile on the wall")
}
},
2 => {
match color {
Tile::Blue => Ok(2),
Tile::Yellow => Ok(3),
Tile::Red => Ok(4),
Tile::Black => Ok(0),
Tile::Teal => Ok(1),
_ => return Err("Not a valid tile on the wall")
}
},
3 => {
match color {
Tile::Blue => Ok(3),
Tile::Yellow => Ok(4),
Tile::Red => Ok(0),
Tile::Black => Ok(1),
Tile::Teal => Ok(2),
_ => return Err("Not a valid tile on the wall")
}
},
4 => {
match color {
Tile::Blue => Ok(4),
Tile::Yellow => Ok(0),
Tile::Red => Ok(1),
Tile::Black => Ok(2),
Tile::Teal => Ok(3),
_ => return Err("Not a valid tile on the wall")
}
},
_ => return Err("Not a valid row on the wall")
}
}
fn connected(&self, coordinate: (usize, usize)) -> u8 {
let wall = self.wall;
let mut sum = 0;
let mut active = false;
let mut count = 0;
for i in 0..5 {
if active == true && wall[coordinate.0][i] == false {
break;
} else if wall[coordinate.0][i] == false {
count = 0;
} else if (coordinate.0, i) == coordinate {
active = true;
count += 1;
} else {
count += 1;
}
}
sum += count;
let mut active = false;
let mut count = 0;
for i in 0..5 {
if active == true && wall[i][coordinate.1] == false {
break;
} else if wall[i][coordinate.1] == false {
count = 0;
} else if (i, coordinate.1) == coordinate {
active = true;
count += 1;
} else {
count += 1;
}
}
sum += count;
return sum
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct State {
player: u8,
box_top: Bag,
bag: Bag,
market: Market,
factories: tinyvec::ArrayVec<[Factory; 5]>, // TODO set to 9?
boards: tinyvec::ArrayVec<[Board; 2]> // TODO set to 4?
}
impl State {
pub fn new(players: u8) -> Result<State, &'static str> {
let n_factories = get_n_factories(players)?;
let mut factories = tinyvec::ArrayVec::<[Factory; 5]>::new();
for _ in 0..n_factories {
factories.push(Factory::default())
}
let mut boards = tinyvec::ArrayVec::<[Board; 2]>::new();
for _ in 0..players {
boards.push(Board::default());
}
let game = State {
player: 0,
box_top: Bag {
blue: 0,
yellow: 0,
red: 0,
black: 0,
teal: 0,
},
bag: Bag::default(),
market: Market::default(),
factories: factories,
boards: boards
};
Ok(game)
}
pub fn fill(&mut self, mut rng: StdRng) -> Result<(), &'static str> {
for factory in &self.factories {
if factory.len() != 0 {
return Err("Cannot fill, factories are not empty")
};
};
for factory in &mut self.factories {
for _ in 0..4 {
if self.bag.is_empty() && !self.box_top.is_empty() {
self.bag = self.box_top;
self.box_top = Bag { blue: 0, yellow: 0, red: 0, black: 0, teal: 0};
}
else if self.bag.is_empty() {
return Ok(())
}
else {
let choices = [Tile::Blue, Tile::Yellow, Tile::Red, Tile::Black, Tile::Teal];
let weights = [self.bag.blue, self.bag.yellow, self.bag.red, self.bag.black, self.bag.teal];
let dist = WeightedIndex::new(&weights).unwrap();
let tile = choices[dist.sample(&mut rng)];
match tile {
Tile::Start => {return Err("This should never happen")}
Tile::Blue => {self.bag.blue -= 1}
Tile::Yellow => {self.bag.yellow -= 1}
Tile::Red => {self.bag.red -= 1}
Tile::Black => {self.bag.black -= 1}
Tile::Teal => {self.bag.teal -= 1}
}
factory.push(tile)
}
}
factory.sort_unstable();
};
self.factories.sort_unstable();
Ok(())
}
fn score(&mut self) -> Result<(), &'static str> {
for board in &mut self.boards {
for row in 0..4 {
if board.patterns[row].len() == (row + 1) {
let color = board.patterns[row].remove(0);
let index = Board::wall_index(color, row)?;
board.wall[row][index] = true;
board.score += board.connected((row, index));
match color {
Tile::Start => {return Err("This should never happen")}
Tile::Blue => {self.box_top.blue += (row as u8 + 1)}
Tile::Yellow => {self.box_top.yellow += (row as u8 + 1)}
Tile::Red => {self.box_top.red += (row as u8 + 1)}
Tile::Black => {self.box_top.black += (row as u8 + 1)}
Tile::Teal => {self.box_top.teal += (row as u8 + 1)}
}
//self.box_top.extend_from_slice(board.patterns[row].as_slice());
board.patterns[row].clear();
}
}
let negative = match board.floor.len() {
0 => 0,
1 => 1,
2 => 2,
3 => 4,
4 => 6,
5 => 8,
6 => 11,
_ => 14
};
board.score -= negative;
}
Ok(())
}
pub fn do_move(&mut self, game_move: GameMove) -> Result<(), &'static str> {
let board = &mut self.boards[self.player as usize];
match game_move {
GameMove(_, Tile::Start, _) => return Err("You can't take the start tile specifically"),
GameMove(0, _, 0) => {
if self.market.contains(&game_move.1) {
let mut hand= self.market.clone();
hand.retain(|x| *x == Tile::Start || *x == game_move.1);
self.market.retain(|x| *x != Tile::Start && *x != game_move.1);
board.floor.extend_from_slice(hand.as_slice());
hand.clear();
}
else {
return Err("Market does not contain selected tile")
}
},
GameMove(0, _, 1..=6) => {
if self.market.len() == 0 {
return Err("Market is empty");
}
else if self.market.contains(&game_move.1) {
let target = &mut board.patterns[game_move.2 - 1];
if target.first().is_some() && target[0] != game_move.1 {
return Err("That pattern line already contains a different color")
}
let empty = game_move.2 - target.len();
if empty == 0 {
return Err("That pattern is full")
}
let mut hand = self.market.deref().clone();
hand.retain(|x| *x == Tile::Start || *x == game_move.1);
self.market.retain(|x| *x != Tile::Start && *x != game_move.1);
for tile in hand.drain(..) {
let empty = game_move.2 - target.len();
if tile == Tile::Start {
board.floor.push(tile);
}
else {
if empty >= 1 {
target.push(tile);
}
else {
board.floor.push(tile)
}
}
}
}
else {
return Err("Market does not contain selected tile")
}
},
GameMove(1..=9, _, _) => {
let board = &mut self.boards[self.player as usize];
if game_move.0 > self.factories.len() {
return Err("That factory is out of bounds");
}
let factory = self.factories[game_move.0 - 1].deref_mut();
if factory.contains(&game_move.1) {
let mut hand = factory.clone();
hand.retain(|x| *x == game_move.1);
factory.retain(|x| *x != game_move.1);
self.market.extend_from_slice(factory.as_slice());
factory.clear();
match game_move.2 {
0 => {
board.floor.extend_from_slice(hand.as_slice());
},
1..=9 => {
let target = &mut board.patterns[game_move.2 - 1];
if target.first().is_some() && target[0] != game_move.1 {
return Err("That pattern line already contains a different color")
}
let empty = game_move.2 - target.len();
if hand.len() <= empty {
target.extend_from_slice(hand.as_slice());
hand.clear();
}
else if empty != 0 {
for tile in hand.drain(..) {
let empty = game_move.2 - target.len();
if empty >= 1 {
target.push(tile);
}
else {
board.floor.push(tile)
}
}
}
else {
return Err("That pattern line is full")
}
},
_ => return Err("Not a valid destination")
}
}
else {
return Err("That tile is not in that factory")
}
},
GameMove(_,_,_) => return Err("Not a valid move")
}
/*
let mut empty = true;
for factory in &mut self.factories {
if factory.len() != 0 {
empty = false;
break;
}
}
if empty == true {
if self.market.len() != 0 {
empty = false;
}
}
if empty == true {
self.score()?;
}
else {
self.player = (self.player + 1) % self.boards.len();
}
*/
self.factories.sort_unstable();
self.market.sort();
for board in &mut self.boards {
board.floor.sort_unstable();
}
self.player = (self.player + 1) % self.boards.len() as u8;
Ok(())
}
pub fn hash(&self) -> [u8; 256]{
[
[self.player],
self.box_top.hash(),
self.bag.hash()
].concat()
}
}
//#[repr(align(16))]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Game {
pub state: State,
pub turn: u32,
}
impl Game {
pub fn new(players: u8) -> Result<Game, &'static str> {
let game = Game {
state: State::new(players)?,
turn: 0
};
Ok(game)
}
pub fn do_move(&mut self, game_move: GameMove) -> Result<(), &'static str> {
let result = self.state.do_move(game_move);
self.turn += 1;
result
}
}
impl Deref for Game {
type Target = State;
fn deref(&self) -> &Self::Target {
&self.state
}
}
impl DerefMut for Game {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.state
}
}
// Tests
pub fn complicated() -> Result<Game, &'static str> {
let mut game = Game::new(2)?;
let mut tiles = Tile::Blue;
for factory in &mut game.factories {
for _ in 0..4 {
factory.push(tiles);
tiles = tiles.into_iter().next().unwrap_or(Tile::Blue);
}
}
Ok(game)
}
pub fn some_game() -> Result<Game, &'static str> {
let mut game = Game::new(2)?;
let factories = &mut game.factories;
factories[0].push(Tile::Blue);
factories[0].push(Tile::Blue);
factories[0].push(Tile::Yellow);
factories[0].push(Tile::Black);
factories[1].push(Tile::Blue);
factories[1].push(Tile::Red);
factories[1].push(Tile::Red);
factories[1].push(Tile::Red);
factories[2].push(Tile::Blue);
factories[2].push(Tile::Red);
factories[2].push(Tile::Black);
factories[2].push(Tile::Teal);
factories[3].push(Tile::Blue);
factories[3].push(Tile::Red);
factories[3].push(Tile::Black);
factories[3].push(Tile::Teal);
factories[4].push(Tile::Yellow);
factories[4].push(Tile::Yellow);
factories[4].push(Tile::Black);
factories[4].push(Tile::Teal);
let bag = &mut game.bag;
bag.blue -= 5;
bag.yellow -= 3;
bag.black -= 4;
bag.red -= 5;
bag.teal -= 3;
Ok(game)
}
#[test]
fn connected() -> Result<(), String> {
let mut board = Board::default();
board.wall[0] = [false, false, false, false, false];
board.wall[1] = [true, false, true, false, false];
board.wall[2] = [true, false, true, false, false];
board.wall[3] = [true, false, false, false, false];
board.wall[4] = [true, true, true, false, false];
let coordinate = (4 as usize, Board::wall_index(Tile::Yellow, 4)?);
assert_eq!(coordinate, (4,0));
let score = board.connected(coordinate);
assert_eq!(score, 7);
Ok(())
}
#[test]
fn game_move_iter() {
let i = GameMove::default();
println!("Original: {:?}", i);
assert_eq!(i.into_iter().next().unwrap(), GameMove(1, Tile::Blue, 1));
//assert_eq!(i.into_iter().count(), 5)
}
#[test]
fn sizes() {
println!("size of azul game: {}", std::mem::size_of::<Game>());
}
Reference in New Issue View Git Blame Copy Permalink