refactor is_winnable

card_game/src/lib.rs

@@ -321,18 +321,29 @@ impl<S> SessionStats<S> {
 	}
 }
 
-pub struct Session<G: Game> {
+#[derive(Clone)]
+pub struct Session<G: Game>
+where
+	G::Config: Clone,
+	G::Instruction: Clone,
+{
 	stats: SessionStats<G::Stats>,
 	config: G::Config,
 	state: SessionState<G>,
 }
 #[derive(Clone, Eq, Hash, PartialEq)]
-pub struct SessionState<G: Game> {
+pub struct SessionState<G: Game>
+where
+	G::Instruction: Clone,
+{
 	seed: G,
 	state: G,
 	history: Vec<G::Instruction>,
 }
-impl<G: Game + Clone> SessionState<G> {
+impl<G: Game + Clone> SessionState<G>
+where
+	G::Instruction: Clone,
+{
 	fn new(state: G) -> Self {
 		Self {
 			seed: state.clone(),
@@ -345,6 +356,7 @@ impl<G: Game> Session<G>
 where
 	G: Clone + Eq + core::hash::Hash,
 	G::Stats: Clone + Default,
+	G::Config: Clone,
 	G::Instruction: Clone + Eq + core::hash::Hash,
 {
 	pub fn new(state: G, config: G::Config) -> Self {
@@ -390,38 +402,28 @@ where
 		self.state.is_win()
 	}
 	pub fn is_winnable(&self) -> Option<Vec<G::Instruction>> {
-		let mut observed = std::collections::HashSet::new();
-		struct StateMachine<G, P, I> {
-			state: G,
-			possible_instructions_iter: P,
-			instruction: I,
-		}
-		let mut dummy_stats = self.stats.inner_stats.clone();
-		let mut state = self.state.state.clone();
-		let mut it = state.possible_instructions();
-		let mut path = Vec::new();
-		'outer: while !state.is_win() {
-			observed.insert(state.clone());
-			for instruction in &mut it {
-				let mut next_state = state.clone();
-				next_state.process_instruction(&mut dummy_stats, &self.config, instruction.clone());
-				if !observed.contains(&next_state) {
-					let possible_instructions_iter =
-						core::mem::replace(&mut it, next_state.possible_instructions());
-					let state = core::mem::replace(&mut state, next_state);
-					path.push(StateMachine {
-						state,
-						possible_instructions_iter,
-						instruction,
-					});
-					continue 'outer;
-				}
+		let mut state_moves = std::collections::HashMap::new();
+		let mut state = self.clone();
+		while !state.is_win() {
+			// Continue existing iterator if it exists
+			let it = state_moves
+				.entry(state.state().clone())
+				.or_insert_with(|| state.state().possible_instructions());
+
+			// Run one possible move
+			if let Some(instruction) = it.next() {
+				state.process_instruction(instruction);
+				continue;
+			}
+
+			// No more moves. If we can't undo we're done
+			if state.history().is_empty() {
+				return None;
+			} else {
+				state.undo();
 			}
-			let last_state = path.pop()?;
-			state = last_state.state;
-			it = last_state.possible_instructions_iter;
 		}
-		Some(path.into_iter().map(|state| state.instruction).collect())
+		Some(state.state.history)
 	}
 }
 impl<G: Game> Game for SessionState<G>