Berack96
8862941152
- added maze gen - refactored Generator - added config for maze gen - changed floor display to 3x instead of 2x
525 lines
22 KiB
Rust
525 lines
22 KiB
Rust
use super::{
|
|
cell::Cell,
|
|
config::Config,
|
|
entities::{
|
|
Direction::{self, Down, Left, Right, Up},
|
|
Position,
|
|
},
|
|
floor::Floor,
|
|
};
|
|
use rand::{Rng, SeedableRng};
|
|
use rand_pcg::Pcg32;
|
|
use std::{
|
|
collections::{HashMap, HashSet, VecDeque},
|
|
fmt::Display,
|
|
ops::Range,
|
|
};
|
|
|
|
// todo!() enemies vec configuration?
|
|
|
|
/// Generatore del gioco che può creare dei piani del dungeon.
|
|
/// Idealmente questo generatore si comporta come il pattern Factory.
|
|
/// Per far si che funzioni ha bisongo di un seed per la generazione del piano
|
|
/// verrà utilizzato poi dal piano stesso per eventuali altri calcoli.
|
|
/// Inoltre ad esso viene passato una struttura di config che permette
|
|
/// di scegliere meglio come poter generare il piano.
|
|
pub struct Generator<'a> {
|
|
pub rng: Pcg32,
|
|
pub level: usize,
|
|
config: &'a Config,
|
|
size: usize,
|
|
}
|
|
|
|
impl<'a> Generator<'a> {
|
|
/// Costruttore standard di un generatore, esso avrà tutte le caratteristiche indicate nella configurazione
|
|
pub fn new(floor_seed: u64, floor_level: usize, config: &'a Config) -> Self {
|
|
let min_floor = config.maze_generation.floor_size.clone().next().unwrap();
|
|
let max_room = config.maze_generation.room_size.clone().last().unwrap();
|
|
assert!(min_floor > max_room, "Floor size should be > than room");
|
|
|
|
let mut rand_pcg = Pcg32::seed_from_u64(floor_seed);
|
|
let mut floor_size = rand_pcg.gen_range(config.maze_generation.floor_size.clone());
|
|
if floor_size % 2 == 0 {
|
|
floor_size = floor_size.max(2) - 1
|
|
}
|
|
|
|
Self {
|
|
rng: rand_pcg,
|
|
level: floor_level,
|
|
size: floor_size,
|
|
config,
|
|
}
|
|
}
|
|
/// Crea un nuovo labirinto a partire dalle configurazioni passate in input.\
|
|
/// Questo metodo creerà un piano avente delle stanze collegate tra di loro tramite dei
|
|
/// corridoi; inoltre in esse verranno inseriti degli effetti.
|
|
pub fn build_floor(mut self) -> Floor {
|
|
let attempts = self.config.maze_generation.room_placing_attempts;
|
|
let room_size = self.config.maze_generation.room_size.clone();
|
|
let mut grid = MazeGenerator::new(self.size, room_size, &mut self.rng)
|
|
.generate_rooms(attempts)
|
|
.generate_labyrinth(80)
|
|
.connect_regions()
|
|
.remove_dead_ends(0)
|
|
.finalize(Cell::Wall, Cell::Empty);
|
|
|
|
self.rand_place(&mut grid, Cell::Entance);
|
|
self.rand_place_effects(&mut grid);
|
|
Floor::new(self.level, self.rng, vec![], grid)
|
|
}
|
|
/// piazza gli effetti della confgurazione in modo casuale su tutto il piano.\
|
|
/// essi vengono piazzati solamente sulle celle Empty
|
|
fn rand_place_effects(&mut self, grid: &mut Vec<Vec<Cell>>) {
|
|
let total = self.config.effects_total;
|
|
let original = &self.config.effects;
|
|
let effects = Self::vec_filter(original, |val| val.floors.contains(&self.level));
|
|
|
|
for _ in 0..total {
|
|
let index = self.rng.gen_range(0..effects.len());
|
|
let effect = effects[index].effect.clone();
|
|
let cell = Cell::Special(effect);
|
|
self.rand_place(grid, cell);
|
|
}
|
|
}
|
|
/// piazza una cella in un punto casuale del piano.\
|
|
/// il metodo contiuna a provare a piazzare la cella finche non trova una cella Empty.
|
|
fn rand_place(&mut self, grid: &mut Vec<Vec<Cell>>, cell: Cell) -> (usize, usize) {
|
|
loop {
|
|
let x = self.rng.gen_range(0..self.size.clone());
|
|
let y = self.rng.gen_range(0..self.size);
|
|
if let Cell::Empty = grid[x][y] {
|
|
grid[x][y] = cell;
|
|
return (x, y);
|
|
}
|
|
}
|
|
}
|
|
/// crea una vista del vettore passato in input dopo aver applicato la funzione di filtro
|
|
fn vec_filter<T: Clone>(original: &Vec<T>, filter: impl Fn(&T) -> bool) -> Vec<T> {
|
|
original
|
|
.clone()
|
|
.into_iter()
|
|
.filter_map(|val| filter(&val).then(|| val))
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
/// Utile per la generazione del labirinto.\
|
|
/// L'algoritmo per la generazione del labirinto si può trovare ovunque online, ma in generale è:\
|
|
/// - Piazza delle stanze a caso nella zona.\
|
|
/// - Riempi tutto il resto con un labirinto.\
|
|
/// - Fai dei fori nei vari muri per connettere le stanze e il labirinto.\
|
|
/// - Rimuovi alcuni dead-end del labirinto e fai dei fori in esso.\
|
|
/// \
|
|
/// La fonte degli algoritmi la si può trovare all'articolo:
|
|
/// https://journal.stuffwithstuff.com/2014/12/21/rooms-and-mazes/
|
|
/// E la sua implementazione la si può trovare al link di github:
|
|
/// https://github.com/munificent/hauberk/blob/db360d9efa714efb6d937c31953ef849c7394a39/lib/src/content/dungeon.dart#L74
|
|
pub struct MazeGenerator<'a> {
|
|
size: usize,
|
|
rooms_size: Range<usize>,
|
|
rng: &'a mut Pcg32,
|
|
rooms: Vec<Room>,
|
|
regions: Vec<Vec<Option<usize>>>,
|
|
current_region: usize,
|
|
}
|
|
|
|
impl Display for MazeGenerator<'_> {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
let str = (0..self.size)
|
|
.into_iter()
|
|
.flat_map(|y| {
|
|
(0..self.size)
|
|
.into_iter()
|
|
.map(move |x| {
|
|
if let Some(num) = self.regions[x][y] {
|
|
format!("{num:2} ")
|
|
} else {
|
|
"███".to_string()
|
|
}
|
|
})
|
|
.chain(std::iter::once("\n".to_string()))
|
|
})
|
|
.collect::<String>();
|
|
write!(f, "{}", str)
|
|
}
|
|
}
|
|
|
|
impl<'a> MazeGenerator<'a> {
|
|
/// Crea un nuovo generatore di stanze a partire dai parametri passati.\
|
|
/// *size* è consigliato che sia un numero dispari, altrimenti alcune zone avranno doppi muri.\
|
|
/// *rooms_size* è consigliato un range come numero maggiore al massimo la metà di size.\
|
|
/// Nota che le stanze generate avranno sempre dimensione dispari per poter generare il labirinto correttamente.\
|
|
/// *rng* indica un generatore di numeri casuali ripetibili, in modo da avere risultati consistenti.
|
|
pub fn new(size: usize, rooms_size: Range<usize>, rng: &'a mut Pcg32) -> Self {
|
|
Self {
|
|
size,
|
|
rooms_size,
|
|
rng,
|
|
rooms: vec![],
|
|
regions: vec![vec![None; size]; size],
|
|
current_region: 0,
|
|
}
|
|
}
|
|
/// Crea il labirinto formato da muri e spazi vuoti passati in input.\
|
|
/// I due parametri passati devono implementare il trait Clone, dato che
|
|
/// quando viene creata la matrice, essi verranno messi all'interno di essa.
|
|
pub fn finalize<T: Clone>(&self, wall: T, empty: T) -> Vec<Vec<T>> {
|
|
self.regions
|
|
.iter()
|
|
.map(|col| {
|
|
col.iter()
|
|
.map(|cell| match cell {
|
|
Some(_) => empty.clone(),
|
|
None => wall.clone(),
|
|
})
|
|
.collect::<Vec<_>>()
|
|
})
|
|
.collect::<Vec<_>>()
|
|
}
|
|
|
|
/// Rimuove tutti i pezzi di labirinto che non vanno da nessuna parte, o che non sono collegati.\
|
|
/// Per fare ciò cerca tutte le celle vuote che hanno una sola cella vuota collegata.
|
|
/// Dopodichè le rimuove e prende quelle rimenenti finchè non ce rimangono più.\
|
|
/// Nel caso si può decidere di lasciare qualche zona che non va a collegarsi da nessuna parte
|
|
/// mettendo un numero > 0 nel cutoff.\
|
|
/// Questo indicherà che nel labirinto ci saranno al massimo N corridioi senza uscita.
|
|
pub fn remove_dead_ends(mut self, cutoff: usize) -> Self {
|
|
let mut dead_ends = (0..self.size)
|
|
.into_iter()
|
|
.flat_map(|x| {
|
|
(0..self.size)
|
|
.into_iter()
|
|
.map(move |y| Position(x, y))
|
|
.filter(|pos| self.get(pos).is_some())
|
|
.filter(|pos| self.has_near_none(pos, 3))
|
|
})
|
|
.collect::<VecDeque<_>>();
|
|
|
|
while let Some(pos) = dead_ends.pop_front() {
|
|
if dead_ends.len() < cutoff {
|
|
break;
|
|
}
|
|
|
|
self.set(&pos, None);
|
|
dead_ends.extend(
|
|
self.get_near(&pos)
|
|
.filter(|pos| self.get(pos).is_some())
|
|
.filter(|pos| self.has_near_none(pos, 3)),
|
|
);
|
|
}
|
|
|
|
self
|
|
}
|
|
/// Permette di connettere tutte le zone in modo da avere un grafo collegato invece che sparso.\
|
|
/// Il labirinto, quando vengono create le stanze, non avrà i corridoi e le stanze collegate.\
|
|
/// Questa funzione serve per fare proprio quello, ovvero il collegamento fra di essi.\
|
|
/// Il labirinto si può vedere come un grafo nel quale ci sono delle regioni (stanze e corridoi) scollegate
|
|
/// fra di loro, e l'unico modo per metterle assieme è quello di preare degli archi (rompere i muri).\
|
|
pub fn connect_regions(mut self) -> Self {
|
|
let mut connectors = self.get_regions_connectors();
|
|
let mut merged = MergeSets::new(1, self.current_region);
|
|
let mut keys = connectors.keys().map(|pos| pos.clone()).collect::<Vec<_>>();
|
|
keys.sort(); // for repeatability
|
|
|
|
while !merged.has_only_one() {
|
|
let rand_index = self.rng.gen_range(0..keys.len());
|
|
let pos = &keys[rand_index];
|
|
if let Some(regions) = connectors.remove(pos) {
|
|
self.set(pos, Some(0));
|
|
self.current_region += 1;
|
|
|
|
merged.merge(regions.into_iter());
|
|
|
|
connectors.remove(&Position(pos.0 + 1, pos.1));
|
|
connectors.remove(&Position(pos.0, pos.1 + 1));
|
|
connectors.remove(&Position(pos.0.saturating_sub(1), pos.1));
|
|
connectors.remove(&Position(pos.0, pos.1.saturating_sub(1)));
|
|
}
|
|
}
|
|
self
|
|
}
|
|
/// Permette di ricevere una mappa che contiene tutte le posizioni None del labirinto che hanno
|
|
/// due o più regioni tra le celle vicine.\
|
|
/// Ciò indica che, nel caso in cui vengano messe a Some(_) le regioni adiacenti ora sono collegate formando
|
|
/// una sola grande regione, e quindi collegando parti separate del grafo.\
|
|
/// La lista di punti in cui ciò è possibile contiene tutti i punti esterni delle stanze interne del labirinto.\
|
|
/// Questa operazione è l'equivalente dell'operazione dei grafi al link: https://en.wikipedia.org/wiki/Spanning_tree
|
|
fn get_regions_connectors(&self) -> HashMap<Position, HashSet<usize>> {
|
|
self.rooms
|
|
.iter()
|
|
.flat_map(|room| room.get_bounding_points())
|
|
.collect::<HashSet<_>>()
|
|
.into_iter()
|
|
.filter(|pos| self.get(pos).is_none())
|
|
.filter_map(|pos| {
|
|
let regions = self
|
|
.get_near(&pos)
|
|
.filter_map(|pos| self.get(&pos))
|
|
.collect::<HashSet<_>>();
|
|
|
|
if regions.len() >= 2 {
|
|
Some((pos, regions))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect()
|
|
}
|
|
/// Riempie tutti gli spazi vuoti della griglia con un labirinto.\
|
|
/// Questo algoritmo lascerà spazi con muri tra i vari cammini e non cercherà
|
|
/// di connettersi con altri corridoi (per fare ciò esiste il metodo connect_regions).\
|
|
/// Il parametro da passare indica la percentuale (0..=100) di quanto deve continuare ad
|
|
/// andare dritto quando crea il labirinto.\
|
|
/// Con percentuali alte si avranno molti corridoi lunghi, con percentuali basse si avranno
|
|
/// molte svolte.
|
|
pub fn generate_labyrinth(mut self, mut straight_percentage: usize) -> Self {
|
|
straight_percentage = straight_percentage.min(100); // cap at 100
|
|
|
|
for x in (1..self.size).step_by(2) {
|
|
for y in (1..self.size).step_by(2) {
|
|
let pos = Position(x, y);
|
|
if self.get(&pos).is_none() && self.has_near_none(&pos, 4) {
|
|
self.grow_maze(pos, straight_percentage);
|
|
}
|
|
}
|
|
}
|
|
self
|
|
}
|
|
/// Crea il labirinto nelle zone vuote a partire dalla posizione indicata.\
|
|
/// Questo metodo è messo privato dato che la posizione di partenza deve essere dispari e
|
|
/// deve avere tutti e quattro le celle vicine settate a None.\
|
|
/// L'algoritmo utilizzato è un backtracking iterativo modificato in modo da generare corridioi
|
|
/// un pochino più lunghi e lo si può trovare sulla pagina:\
|
|
/// https://en.wikipedia.org/wiki/Maze_generation_algorithm#Iterative_implementation_(with_stack)\
|
|
/// Il parametro straight_percentage indica quanto "scava" i corridoi del labirinto
|
|
/// senza girare, e quindi creando lunghi segmenti.
|
|
fn grow_maze(&mut self, start: Position, straight_percentage: usize) {
|
|
self.current_region += 1;
|
|
self.set(&start, Some(self.current_region));
|
|
|
|
let mut prev_direction = Direction::None;
|
|
let mut cells = vec![];
|
|
cells.push(start);
|
|
|
|
while let Some(mut pos) = cells.pop() {
|
|
let directions = self.get_empty_cells_directions(&pos);
|
|
prev_direction = if !directions.is_empty() {
|
|
// Based on how "windy" passages are, try to prefer carving in the same direction.
|
|
let same_direction = self.rng.gen_range(0..=100) < straight_percentage;
|
|
let current = if directions.contains(&prev_direction) && same_direction {
|
|
prev_direction
|
|
} else {
|
|
let rand = self.rng.gen_range(0..directions.len());
|
|
directions[rand]
|
|
};
|
|
|
|
// save for back-tracking
|
|
let prev = pos.clone();
|
|
cells.push(prev);
|
|
|
|
// move two times
|
|
self.set(current.move_from(&mut pos), Some(self.current_region));
|
|
self.set(current.move_from(&mut pos), Some(self.current_region));
|
|
cells.push(pos);
|
|
current
|
|
} else {
|
|
Direction::None
|
|
}
|
|
}
|
|
}
|
|
/// Ritorna tutte le direzioni da cui ci si può spostare da una cella.\
|
|
/// Questo metodo controlla che dalla posizione *pos* si possa andare in una direzione
|
|
/// almeno per due passi. In caso positivo, la direzione viene inserita nel risultato.\
|
|
/// Questo metodo viene usato esclusivamente da grow_maze
|
|
fn get_empty_cells_directions(&self, pos: &Position) -> Vec<Direction> {
|
|
[Up, Left, Down, Right]
|
|
.into_iter()
|
|
.filter(|dir| {
|
|
let mut pos = pos.clone();
|
|
dir.move_from(&mut pos);
|
|
dir.move_from(&mut pos);
|
|
pos.0 < self.size && pos.1 < self.size && self.has_near_none(&pos, 4)
|
|
})
|
|
.collect()
|
|
}
|
|
/// Aggiunge delle stanze in modo casuale all'interno della rappresentazione del labirinto.\
|
|
/// Questo metodo non controlla altro che le stanze già inserite per evitare di avere collisioni fra di esse.\
|
|
/// Nel caso in cui questo metodo venga chiamato dopo la generazione del labirinto, e le stanze venissero
|
|
/// inserite senza collisioni con quelle precedenti, il labirinto sottostante sarebbe sovrascritto.\
|
|
/// Il parametro attempts indica dopo quanti inserimenti falliti si deve fermare.
|
|
pub fn generate_rooms(mut self, mut attempts: u32) -> Self {
|
|
while attempts > 0 {
|
|
let room = Room::rand(self.rng, self.size, self.rooms_size.clone());
|
|
if self.rooms.iter().any(|other| room.collide(other)) {
|
|
attempts -= 1;
|
|
} else {
|
|
self.current_region += 1;
|
|
room.get_area_points()
|
|
.for_each(|p| self.set(&p, Some(self.current_region)));
|
|
self.rooms.push(room);
|
|
}
|
|
}
|
|
self
|
|
}
|
|
/// Ritorna un iteratore di posizioni vicine alla posizione indicata.\
|
|
/// Viene ritornato un iteratore in modo che si possa decidere cosa farlo diventare.\
|
|
/// Nel caso una posizione sia fuori dal campo, essa viene scartata e non
|
|
/// sarà compresa al'interno dell'iterazione.
|
|
fn get_near(&'a self, pos: &'a Position) -> impl Iterator<Item = Position> + 'a {
|
|
[Up, Left, Down, Right]
|
|
.into_iter()
|
|
.map(|dir| *dir.move_from(&mut pos.clone()))
|
|
.filter(|pos| pos.0 < self.size && pos.1 < self.size)
|
|
}
|
|
/// Indica se alla posizione passata la cella ha un tot dei vicini None.\
|
|
/// Se infatti si passasse a total 2, significa che questo metodo restituirà
|
|
/// true solamente se la cella alla posizione pos ha esattamente 2 vicini None.
|
|
fn has_near_none(&self, pos: &Position, total: usize) -> bool {
|
|
let total = total.min(4);
|
|
self.get_near(pos)
|
|
.filter(|pos| self.get(pos).is_none())
|
|
.fold(0, |count, _| count + 1)
|
|
== total
|
|
}
|
|
/// Metodo per l'assegnamento di un valore alla posizione indicata.\
|
|
/// Nel caso si voglia mettere un muro, assegnare None, altrimenti inserire Some(region) per
|
|
/// indicare a quale regione quella cella appartiene.
|
|
fn set(&mut self, pos: &Position, val: Option<usize>) {
|
|
self.regions[pos.0][pos.1] = val;
|
|
}
|
|
/// Permette di prendere il valore contenuto nella cella.\
|
|
/// Nel caso None si indica un muro, mentre in Some(region) si indica la regione quella cella appartiene.
|
|
fn get(&self, pos: &Position) -> Option<usize> {
|
|
self.regions[pos.0][pos.1]
|
|
}
|
|
}
|
|
|
|
/// Struttura ausiliaria usata per contenere le posizioni.\
|
|
/// Vengono implementate alcuni metodi comodi per essi, quali la collisione
|
|
/// o la generazione dei punti dei lati.\
|
|
/// La stanza viene rappresentata come un rettangolo, la quale area indica l'interno,
|
|
/// mentre i lati non hanno dimensione.\
|
|
/// I punti quindi salvati sono il minimo e il massimo di un rettangolo ed indicano il
|
|
/// punto più in basso da dove inizia l'area e quello più in alto.
|
|
#[derive(Clone, Copy)]
|
|
struct Room {
|
|
lo: Position,
|
|
hi: Position,
|
|
}
|
|
impl Room {
|
|
/// Crea una stanza random a partire da un massimo valore dei punti raggiungibile
|
|
/// e un range che indica il minimo e il massimo della grandezza di una stanza.
|
|
pub fn rand(rng: &mut impl Rng, max: usize, range: Range<usize>) -> Self {
|
|
let x = Self::rand_odd(rng, 0..max);
|
|
let y = Self::rand_odd(rng, 0..max);
|
|
|
|
// removing one since the odd + odd = even => odd-1 + odd = odd
|
|
let x_size = Self::rand_odd(rng, range.clone()) - 1;
|
|
let y_size = Self::rand_odd(rng, range) - 1;
|
|
|
|
let x_bottom = if x < x_size { 1 } else { x - x_size };
|
|
let y_bottom = if y < y_size { 1 } else { y - y_size };
|
|
|
|
let x_top = (x_bottom + x_size).min(max - 2);
|
|
let y_top = (y_bottom + y_size).min(max - 2);
|
|
|
|
Self {
|
|
lo: Position(x_bottom, y_bottom),
|
|
hi: Position(x_top, y_top),
|
|
}
|
|
}
|
|
/// Genera tutti i punti di tutti i lati all'esterno della stanza, insomma i punti dei muri.\
|
|
/// Gli unici punti non generati dall'iteratore ritornato sono quelli degli angoli.\
|
|
/// Es. dato lo(1,1) e hi(2,2) => (1,0), (1,3), (2,0), (2,3), (0,1), (3,1), (0,2), (3,2)\
|
|
/// -XXXX-\
|
|
/// -X██X-\
|
|
/// -X██X-\
|
|
/// -XXXX-\
|
|
pub fn get_bounding_points<'a>(&'a self) -> impl Iterator<Item = Position> + 'a {
|
|
let x_range = self.lo.0..=self.hi.0;
|
|
let y_range = self.lo.1..=self.hi.1;
|
|
|
|
let lo_x = self.lo.0 - 1;
|
|
let lo_y = self.lo.1 - 1;
|
|
let hi_x = self.hi.0 + 1;
|
|
let hi_y = self.hi.1 + 1;
|
|
|
|
let x_range = x_range.flat_map(move |x| vec![Position(x, lo_y), Position(x, hi_y)]);
|
|
let y_range = y_range.flat_map(move |y| vec![Position(lo_x, y), Position(hi_x, y)]);
|
|
x_range.chain(y_range)
|
|
}
|
|
/// Genera tutti i punti all'interno del rettangolo indicato dalla stanza.\
|
|
/// I lati si possono vedere come i muri e l'area come l'interno.\
|
|
/// Cosí facendo, i punti sui lati non verranno generati.
|
|
pub fn get_area_points<'a>(&'a self) -> impl Iterator<Item = Position> + 'a {
|
|
(self.lo.0..=self.hi.0).into_iter().flat_map(|x| {
|
|
(self.lo.1..=self.hi.1)
|
|
.into_iter()
|
|
.map(move |y| Position(x, y))
|
|
})
|
|
}
|
|
/// Indica se la stanza creata è in collisione con un'altra passata in input.\
|
|
/// Più precisamente una collisione avviene se l'area di una stanza si sovrappone con l'altra.
|
|
/// Il codice risultante deriva dal seguente link:\
|
|
/// https://stackoverflow.com/questions/306316/determine-if-two-rectangles-overlap-each-other
|
|
pub fn collide(&self, other: &Self) -> bool {
|
|
self.lo.0 <= other.hi.0
|
|
&& self.hi.0 >= other.lo.0
|
|
&& self.lo.1 <= other.hi.1
|
|
&& self.hi.1 >= other.lo.1
|
|
}
|
|
/// Genera un numero dispari a partire dal range inserito.\
|
|
/// Questo metodo è utile per il piazzamento della stanza in punti dispari in modo che
|
|
/// il labirinto si possa mettere tra i vari muri.
|
|
fn rand_odd(rng: &mut impl Rng, range: Range<usize>) -> usize {
|
|
let mut rand = rng.gen_range(range);
|
|
if rand % 2 == 0 {
|
|
rand = rand.saturating_sub(1).max(1);
|
|
}
|
|
rand
|
|
}
|
|
}
|
|
|
|
/// Struttura usata per unire due o più regioni in modo veloce.\
|
|
/// Questo codice è un'implementazione grezza e non ottimizzata di algoritmi UnionFind.\
|
|
#[derive(Debug)]
|
|
struct MergeSets {
|
|
sets: Vec<usize>,
|
|
current: usize,
|
|
start: usize,
|
|
len: usize,
|
|
}
|
|
impl MergeSets {
|
|
/// Crea la struttura UnionFind in modo da avere dei sets numerati da start a total.\
|
|
/// In questo modo possono esistere 4 insiemi, ma a partire dal numero 3 => 3,4,5,6
|
|
pub fn new(start: usize, total: usize) -> Self {
|
|
Self {
|
|
sets: (start..=total).into_iter().collect(),
|
|
current: total + 1,
|
|
start,
|
|
len: total - start,
|
|
}
|
|
}
|
|
/// Indica se tutti i sets sono stati uniti oppure no.\
|
|
/// Infatti se sono tutti uniti allora ritorna true, altrimenti false.
|
|
pub fn has_only_one(&self) -> bool {
|
|
self.len == self.sets.len()
|
|
}
|
|
/// Unisce uno o più regioni indicate dall'iteratore.\
|
|
/// Questo metodo ha complessità pari ad O(n).
|
|
pub fn merge(&mut self, regions: impl Iterator<Item = usize>) {
|
|
let regions = regions
|
|
.map(|reg| self.sets[reg - self.start])
|
|
.collect::<HashSet<_>>();
|
|
self.len = self
|
|
.sets
|
|
.iter_mut()
|
|
.filter(|set| regions.contains(set))
|
|
.fold(0, |count, set| {
|
|
*set = self.current;
|
|
count + 1
|
|
});
|
|
self.current += 1;
|
|
}
|
|
}
|