--- a/src/lifter.tp	Sun Jul 15 18:16:50 2012 -0700
+++ b/src/lifter.tp	Sun Jul 15 18:32:22 2012 -0700
@@ -52,20 +52,75 @@
 		(abs: sx - dx) + (abs: sy - dy)
 	}
 	
+	moveFinder <- :field {
+		#{
+			curbest <- (field clone) advance: "A"
+			playfield <- field
+			bestMove:withMaxSteps <- :self :max{
+				n <- 0
+				states <- #[playfield]
+				while: { if: (states length) > 0 { if: n < max { not: (curbest succeeded) } } } do: {
+					nextstates <- #[]
+					foreach: states :idx curstate {
+						me <-curstate getRobot
+						candidates <- curstate validMoves: (me x) (me y)
+						foreach: candidates :idx move {
+							curfield <- curstate clone
+							curfield advance: (move cmd)
+							if: (curfield ended) {
+								if: (curfield score) > (curbest score) {
+									curbest <- curfield
+								}
+							} else: {
+								//check theoretical max score for current map state
+								//discard paths that can never be better than our current best
+								if: (curfield maxScore) > (curbest score) {
+									nextstates append: curfield
+								}
+							}
+						}
+					}
+					states <- nextstates
+					n <- n + 1
+				}
+				if: (curbest succeeded) {
+					false
+				} else: {
+					if: (states length) > 0 {
+						bestofcur <- states get: 0
+						n <- 1
+						while: { n < (states length) } do: {
+							curstate <- states get: n
+							if: ((curstate score) > (bestofcur score)) {
+								bestofcur <- curstate
+							}
+							n <- n + 1
+						}
+						playfield <- bestofcur
+						true
+					}
+				}
+			}
+		}
+	}
+	
 	main <- {
 		text <- sim readFd: 0
-		playfield <- (sim state) fromStr: text
+		initial <- (sim state) fromStr: text
 		os write: 2 text
-		os write: 2 "width: " . (string: (playfield width)) . "\n"
-		os write: 2 "height: " . (string: (playfield height)) . "\n"
-		me <-playfield getRobot
-		os write: 2 "robot x: " . (me x) . " y: " . (me y) . "\n"
-		neighbors <- playfield validMoves: (me x) (me y)
-		foreach: neighbors :idx move {
-			os write: 2 "move: " . move . "\n"
-			curfield <- playfield clone
-			curfield advance: (move cmd)
-			curfield printGrid
+		os write: 2 "width: " . (string: (initial width)) . "\n"
+		os write: 2 "height: " . (string: (initial height)) . "\n"
+		
+		finder <- moveFinder: initial
+		while: { bestMove: finder withMaxSteps: 5 } do: {
+			os write: 2 "--------iteration results-------\n"
+			os write: 2 "Best:\n"
+			(finder curbest) printGrid
+			os write: 2 "Current:\n"
+			(finder playfield) printGrid
 		}
+		os write: 2 "---------------\n"
+		os write: 2 "End Best:\n"
+		(finder curbest) printGrid
 	}
 }

--- a/src/sim.tp	Sun Jul 15 18:16:50 2012 -0700
+++ b/src/sim.tp	Sun Jul 15 18:32:22 2012 -0700
@@ -81,8 +81,11 @@
 						}
 						
 						consequenceOf <- :cur {
-							if: (cur eq: lambda)   {collected <- collected + 1}
-							if: (cur eq: openLift) {mine succeeded!: true}							
+							if: (cur eq: lambda)   {
+								collected <- collected + 1
+								mine addPoints: 25
+							}
+							if: (cur eq: openLift) {mine succeeded!}							
 						}
 
 						destination <- mine getCell: xPrime yPrime
@@ -101,6 +104,13 @@
 						}
 
 					}
+					clone <- {
+						myclone <- robot
+						myclone collected!: collected
+						myclone heldBreath!: heldBreath
+						myclone razors!: razors
+						myclone
+					}
 				}
 				commands set: "L" {ret move: (-1)  0  }
 				commands set: "R" {ret move:   1   0  }
@@ -120,7 +130,7 @@
 			_nextGrid <- #[]
 			_robot <- null
 			_ended <- false
-			_lambdaCount <- 0
+			
 			_succeeded <- false
 			ret <- #{
 				grid <- in_grid
@@ -183,16 +193,20 @@
 					obj x!: (calcX: Index)
 					obj y!: (calcY: Index)
 				}
-				lambdaCount <- {_lambdaCount}
+				lambdaCount <- 0
 				water <- 0
 				flooding <- 0
 				waterproof <- 10
-				moves <- 0
+				moves <- #[]
+				score <- 0
+				maxScore <- { score + (lambdaCount - (_robot collected)) * 25 + lambdaCount * 50 }
+				addPoints <- :points { score <- score + points }
 				ended <- {_ended}
 				succeeded <- {_succeeded}
-				succeeded! <- :newval {
-					_ended <- newval
-					_succeeded <- newval
+				succeeded! <- {
+					_ended <- true
+					_succeeded <- true
+					addPoints: lambdaCount * 50
 				}
 				doUpdate <- {
 					foreach: grid :index value {
@@ -222,7 +236,7 @@
 							}}} // end if
 						} else: {
 							if: (value eq: (cellTypes closedLift)) {
-								if: (_robot collected) = _lambdaCount {
+								if: (_robot collected) = lambdaCount {
 									nextValue <- (cellTypes openLift)
 								}
 							}
@@ -237,10 +251,16 @@
 					swapGrids:
 				}
 				advance <- :roboCmd {
-					_ended <- roboCmd = "A"
+					if: roboCmd = "A" {
+						_ended <- true
+						moves append: roboCmd
+						addPoints: (_robot collected) * 25
+					}
+					
 					if: (not: _ended) {
 						_robot doCmd: roboCmd
-						moves <- moves + 1
+						score <- score - 1
+						moves append: roboCmd
 						doUpdate:
 					}
 					self
@@ -258,12 +278,19 @@
 							os write: 2 "\n"
 						}
 					}
+					os write: 2 "score: " . score . "\n"
+					os write: 2 "collected: " . (_robot collected) . "\n"
+					os write: 2 "moves: "
+					foreach: moves :idx m {
+						os write: 2 m
+					}
+					os write: 2 "\n"
 				}
 				clone <- {
 					cgrid <- #[]
 					foreach: grid :idx el {
 						if: (el isrobot) {
-							cgrid append: (cellTypes robot)
+							cgrid append: (el clone)
 						} else: {
 							cgrid append: el
 						}
@@ -272,7 +299,13 @@
 					myclone water!: water
 					myclone flooding!: flooding
 					myclone waterproof!: waterproof
-					myclone moves!: moves
+					movesclone <- #[]
+					foreach: moves :idx el {
+						movesclone append: el
+					}
+					myclone moves!: movesclone
+					myclone score!: score
+					myclone lambdaCount!: lambdaCount
 					myclone
 				}
 			}
@@ -284,7 +317,7 @@
 					ret updatePos: _robot index
 				} else: { 
 					if: (el eq: (cellTypes lambda)) {
-						_lambdaCount <- _lambdaCount + 1
+						ret lambdaCount!: (ret lambdaCount) + 1
 					}
 				}
 			}