yeah

src/main.rs

@@ -319,18 +319,18 @@ fn hands(state: &GameState) -> [Vec<u8>; 4] {
     hand
 }
 
-fn search(node: &mut Node) -> (Vec<usize>, &mut Node) {
+fn search<'a>(node: &'a mut Node, hands: &mut [Vec<u8>; 4]) -> (Vec<usize>, &'a mut Node) {
     let mut cur: &mut Node = node;
     let mut seen: Vec<usize> = vec![];
     loop {
         cur.visited += 1;
         if cur.state.played.count_ones() == 52 {
             // abort
+	    // no need to do anything with hands
             return (seen, cur);
         }
         let mut score: f64 = -10000.0;
         let mut idx: usize = 100000;
-        let hands = hands(&cur.state);
         let mut outin: [bool; 4] = [true; 4];
         for i in hands[usize::from(cur.state.player)].iter() {
             outin[usize::from(i / 13)] = false;
@@ -349,6 +349,13 @@ fn search(node: &mut Node) -> (Vec<usize>, &mut Node) {
             match &cur.outcomes[usize::from(*i)] {
                 None => {
                     seen.push((*i).into());
+		    let mut new : Vec<u8> = vec![];
+		    for k in &hands[usize::from(cur.state.player)] {
+			if *k != (*i) {
+			    new.push(*k)
+			}
+		    }
+		    hands[usize::from(cur.state.player)] = new;
                     return (seen, cur);
                 }
                 Some(x) => {
@@ -365,7 +372,16 @@ fn search(node: &mut Node) -> (Vec<usize>, &mut Node) {
             None => panic!("This will not happen. SEARCH PANIC KW!#"),
             Some(x) => {
                 seen.push(idx);
-                cur = x;
+                
+		let mut new : Vec<u8> = vec![];
+		for i in &hands[usize::from(cur.state.player)] {
+		    if usize::from(*i) != idx {
+			new.push(*i)
+		    }
+		}
+
+		hands[usize::from(cur.state.player)] = new;
+		cur = x; //lol
             }
         }
         //cur.outcomes[idx].clone().unwrap();
@@ -387,7 +403,7 @@ fn propagate(node: &mut Node, path: Vec<usize>, value: i8) {
         }
     }
 }
-fn simulate(state: &GameState) -> i8 {
+fn simulate(state: &GameState, hands: &mut [Vec<u8>; 4]) -> i8 {
     let mut cur: GameState = state.clone();
     loop {
         let tricks0: u8 = cur.tricksWonBy0;
@@ -400,7 +416,7 @@ fn simulate(state: &GameState) -> i8 {
         }
         let card: Card;
         // ok. find action
-        let hands = hands(&cur);
+        //let hands = hands(&cur);
 
         let mut outin: [u8; 4] = [0; 4];
         for i in hands[usize::from(cur.player)].iter() {
@@ -429,7 +445,16 @@ fn simulate(state: &GameState) -> i8 {
                 continue;
             }
             if random::<u8>() % n == 0 {
+
                 p = numToCard(*i);
+		let mut new : Vec<u8> = vec![];
+		for k in &hands[usize::from(cur.player)] {
+		    if *k != *i {
+			new.push(*k)
+		    }
+		}
+		hands[usize::from(cur.player)] = new;
+
                 break;
             } else {
                 n -= 1;
@@ -492,7 +517,8 @@ fn main() {
             continue;
         }
         for _ in 1..10000 {
-            let pathcur: (Vec<usize>, &mut Node) = search(&mut node); //search!
+	    let mut hands = hands(&node.state);
+            let pathcur: (Vec<usize>, &mut Node) = search(&mut node, &mut hands); //search!
             let path = pathcur.0;
             let cur = pathcur.1;
             let n: i8;
@@ -508,7 +534,7 @@ fn main() {
                     &cur.state,
                     numToCard(path[path.len() - 1] as u8),
                 )))); //expand!
-                n = simulate(&(*cur.outcomes[path[path.len() - 1]].as_ref().unwrap()).state);
+                n = simulate(&(*cur.outcomes[path[path.len() - 1]].as_ref().unwrap()).state, &mut hands);
                 //simulate!
             }
             propagate(&mut node, path, n);