2024-02-06 06:46:23 +00:00
|
|
|
use rand::{seq::SliceRandom, Rng};
|
|
|
|
|
|
|
|
use crate::ruleset::{Card, Setup};
|
|
|
|
|
|
|
|
pub struct Deal {
|
|
|
|
pub slots: Vec<Vec<Card>>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Deal {
|
|
|
|
pub fn deal(setup: &Setup, rng: &mut impl Rng) -> Deal {
|
|
|
|
loop {
|
|
|
|
if let Some(d) = Self::deal1(setup, rng) {
|
|
|
|
return d
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fn deal1(setup: &Setup, rng: &mut impl Rng) -> Option<Deal> {
|
|
|
|
// don't use the middle slot
|
|
|
|
let n_slots = (setup.ruleset.n_slots - 1) as usize;
|
2024-02-08 02:36:08 +00:00
|
|
|
let aux_slot = n_slots;
|
2024-02-06 06:46:23 +00:00
|
|
|
let n_usable_cards = setup.ruleset.usable_n_cards();
|
|
|
|
let tower_height = n_usable_cards as usize / n_slots;
|
|
|
|
|
2024-02-08 02:36:08 +00:00
|
|
|
let mut slots: Vec<Vec<Card>> = vec![vec![]; n_slots+1];
|
2024-02-06 06:46:23 +00:00
|
|
|
|
|
|
|
let split_point =
|
|
|
|
if setup.ruleset.n_arcana == 0 { 0 }
|
|
|
|
else { rng.gen_range(0..setup.ruleset.n_arcana) };
|
|
|
|
|
|
|
|
let n_wells = setup.ruleset.n_suits + 2;
|
|
|
|
|
|
|
|
let mut virtual_wells: Vec<Vec<Card>> = vec![vec![]; n_wells as usize + 2];
|
|
|
|
|
|
|
|
// rely on the order of the deck
|
|
|
|
for r in 1..setup.ruleset.n_cards_per_suit { // skip aces
|
|
|
|
for s in 0..setup.ruleset.n_suits {
|
|
|
|
virtual_wells[s as usize].push(Card(setup.ruleset.n_cards_per_suit * s + r));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let first_arcana = setup.ruleset.n_suits * setup.ruleset.n_cards_per_suit;
|
|
|
|
for r in 0..split_point {
|
|
|
|
virtual_wells[setup.ruleset.n_suits as usize].push(Card(r+first_arcana))
|
|
|
|
}
|
|
|
|
for r in (split_point..setup.ruleset.n_arcana).rev() {
|
|
|
|
virtual_wells[setup.ruleset.n_suits as usize + 1].push(Card(r+first_arcana))
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut pops = vec![];
|
|
|
|
for (well, contents) in virtual_wells.iter().enumerate() {
|
|
|
|
for _ in 0..contents.len() {
|
|
|
|
pops.push(well);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pops.shuffle(rng);
|
|
|
|
|
2024-02-08 02:36:08 +00:00
|
|
|
fn find_home(card: Card, exclude: Option<usize>, setup: &Setup, slots: &mut [Vec<Card>], aux_slot: usize, tower_height: usize, rng: &mut impl Rng) {
|
|
|
|
let mut acceptors = vec![];
|
|
|
|
let mut not_full = vec![];
|
|
|
|
for s in 0..slots.len() {
|
|
|
|
let not_too_tall = slots[s].len() < if s == aux_slot { 1 } else { tower_height };
|
|
|
|
if Some(s) != exclude {
|
|
|
|
if not_too_tall && accepts(setup, slots[s].last().cloned(), card) {
|
|
|
|
acceptors.push(s)
|
|
|
|
}
|
|
|
|
if not_too_tall {
|
2024-02-06 06:46:23 +00:00
|
|
|
not_full.push(s);
|
|
|
|
}
|
|
|
|
}
|
2024-02-08 02:36:08 +00:00
|
|
|
}
|
2024-02-06 06:46:23 +00:00
|
|
|
|
2024-02-08 02:36:08 +00:00
|
|
|
acceptors.shuffle(rng);
|
|
|
|
not_full.shuffle(rng);
|
|
|
|
if rng.gen_bool(0.5) && acceptors.len() > 0 {
|
|
|
|
let a = acceptors.first().unwrap();
|
|
|
|
slots[*a].push(card);
|
|
|
|
} else if let Some(a) = not_full.first() {
|
|
|
|
slots[*a].push(card);
|
|
|
|
} else if let Some(e) = exclude {
|
|
|
|
slots[e].push(card)
|
|
|
|
} else {
|
|
|
|
panic!("should not ever happen")
|
2024-02-06 06:46:23 +00:00
|
|
|
}
|
2024-02-08 02:36:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
while let Some(w) = pops.pop() {
|
2024-02-06 06:46:23 +00:00
|
|
|
let card = virtual_wells[w].pop().expect("card must be present");
|
2024-02-08 02:36:08 +00:00
|
|
|
find_home(card, None, setup, &mut slots, aux_slot, tower_height, rng);
|
2024-02-06 06:46:23 +00:00
|
|
|
|
|
|
|
// move any card that is on an acceptor to a random slot
|
2024-02-08 02:36:08 +00:00
|
|
|
for _ in 0..15 {
|
2024-02-06 06:46:23 +00:00
|
|
|
let mut sources: Vec<usize> = (0..slots.len()).collect();
|
|
|
|
sources.shuffle(rng);
|
|
|
|
for src in sources {
|
|
|
|
let mut iter = slots[src].iter().rev();
|
|
|
|
let top = iter.next().cloned();
|
|
|
|
let second_to_top = iter.next().cloned();
|
|
|
|
|
|
|
|
if let Some(t) = top {
|
|
|
|
if accepts(&setup, second_to_top, t) {
|
|
|
|
slots[src].pop();
|
2024-02-08 02:36:08 +00:00
|
|
|
find_home(t, Some(src), setup, &mut slots, aux_slot, tower_height, rng);
|
2024-02-06 06:46:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-08 02:36:08 +00:00
|
|
|
if let Some(top) = slots[n_slots].pop() {
|
|
|
|
assert!(slots[n_slots].len() == 0);
|
|
|
|
find_home(top, Some(n_slots), setup, &mut slots, aux_slot, tower_height, rng);
|
|
|
|
assert!(slots[n_slots].len() == 0);
|
|
|
|
}
|
|
|
|
|
2024-02-06 06:46:23 +00:00
|
|
|
let mut instantly_accepted = vec![];
|
|
|
|
for &a in &setup.deck.aces {
|
|
|
|
instantly_accepted.push(Card(a.0 + 1)) // twos
|
|
|
|
}
|
|
|
|
instantly_accepted.push(Card(first_arcana));
|
|
|
|
instantly_accepted.push(Card(first_arcana + setup.ruleset.n_arcana - 1));
|
|
|
|
|
2024-02-08 02:36:08 +00:00
|
|
|
for s in 0..n_slots {
|
2024-02-06 06:46:23 +00:00
|
|
|
let mut iter = slots[s].iter().rev();
|
|
|
|
let last = iter.next().cloned();
|
|
|
|
let second_to_last = iter.next().cloned();
|
|
|
|
|
|
|
|
if let Some(last) = last {
|
|
|
|
if instantly_accepted.contains(&last) {
|
|
|
|
if let Some(c) = second_to_last {
|
|
|
|
if instantly_accepted.contains(&c) {
|
|
|
|
return None
|
|
|
|
}
|
|
|
|
|
|
|
|
let n = slots[s].len();
|
|
|
|
(slots[s][n-2],slots[s][n-1]) = (last, c);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-08 02:36:08 +00:00
|
|
|
|
|
|
|
for s in 0..n_slots {
|
|
|
|
assert!(slots[s].len() == tower_height)
|
|
|
|
}
|
|
|
|
|
|
|
|
slots.pop(); // get rid of aux slot
|
|
|
|
|
2024-02-06 06:46:23 +00:00
|
|
|
return Some(Deal { slots });
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
fn accepts(setup: &Setup, prev: Option<Card>, next: Card) -> bool {
|
|
|
|
let prev = prev.map(|p| setup.deck.cards[p.0 as usize]);
|
|
|
|
let next = setup.deck.cards[next.0 as usize];
|
|
|
|
if let Some(p) = prev {
|
|
|
|
return p.suit == next.suit && (p.rank + 1 == next.rank || p.rank == next.rank + 1);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|