repos/icfp2012: src/sim.tp comparison

comparison src/sim.tp @ 62:ff2b38518a58

Updated heuristic

author	Mike Pavone <pavone@retrodev.com>
date	Mon, 16 Jul 2012 04:03:03 -0700
parents	7d4e51b4769a
children	aa822c683e28

comparison

equal deleted inserted replaced

-:f851895ea67a
+:ff2b38518a58
 			ret <- #{
 				id <- (idStr byte: 0)
 				string <- idStr
 				isrobot <- { false }
 				eq <- :other { id = (other id) }
-				navigable <- { cannav }
+				navigable <- cannav
 			}
 			typedict set: (ret id) ret
 			ret
 		}
 		#{
 						string <- {
 							name . "(" . idx . ")"
 						}
 					}}
 					here <- calcIndex: x y
-					//TODO: Add wait move when rocks are in motion
+					cur <- #[(amove: here "A") (amove: here "W")]
-					//(amove: here "W")
-					cur <- #[(amove: here "A")]
 					up <- amove: (calcIndex: x y + 1) "U"
 					down <- amove: (calcIndex: x y - 1) "D"
 					left <- amove: (calcIndex: x - 1 y) "L"
 					right <- amove: (calcIndex: x + 1 y) "R"
 					foreach: #[up down left right] :idx el {
 						}
 					}
 					cur
 				}
 				distanceFrom:to <- :x y celltype {
-					//print: "calculating distance from " . x . ", " . y . " to " . celltype . "\n"
+					//debugLog: "calculating distance from " . x . ", " . y . " to " . celltype . "\n"
+					if: (celltype eq: (cellTypes closedLift)) {
+						celltype navigable!: true
+					}
 					moves <- validMoves: x y
 					curdist <- 0
 					visited <- _nextGrid
 					foreach: grid :idx el {
 						visited set: idx false
 					}
 					notfound <- true
 					while: { if: notfound { (moves length) > 0 } } do: {
 						nextmoves <- #[]
 						curdist <- curdist + 1
+						//debugLog: "moves at distance " . curdist . "\n"
 						foreach: moves :idx move {
 							curpos <- move index
+							//debugLog: "" . move . " " . (grid get: curpos) . "\n"
 							if: (not: (visited get: curpos)) {
 								if: ((grid get: curpos) eq: celltype) {
 									notfound <- false
 								} else: {
 									visited set: curpos true
 									foreach: (validMoves: (calcX: curpos) (calcY: curpos)) :idx move {
 										nextmoves append: move
 									}
 								}
 							}
 						}
 						moves <- nextmoves
 					}
-					curdist
+					if: (celltype eq: (cellTypes closedLift)) {
+						celltype navigable!: false
+					}
+					if: notfound {
+						-1
+					} else: {
+						curdist
+					}
 				}
 				getRobot <- { _robot }
 				updatePos <- :obj Index {
 					obj x!: (calcX: Index)
 					obj y!: (calcY: Index)
 				score <- 0
 				maxScore <- { score + (lambdaCount - (_robot collected)) * 25 + lambdaCount * 50 }
 				heuristic <- {
 					if: (not: _heuristicValid) {
 						dest <- if: (_robot collected) = lambdaCount {
-							cellTypes openLift
+							dist <- (distanceFrom: (_robot x) (_robot y) to: (cellTypes openLift))
+							if: dist < 0 {
+								//debugLog: "open lift unreachable\n"
+								_heuristic <- (_robot collected) * 50 -  (moves length)
+							} else: {
+								//debugLog: "open lift unreachable at distance" . dist . "\n"
+								_heuristic <- (_robot collected) * 75 - dist -  (moves length)
+							}
 						} else: {
-							cellTypes lambda
+							mult <- 0
-						}
+							liftdist <- (distanceFrom: (_robot x) (_robot y) to: (cellTypes closedLift))
-						_heuristic <- score - (distanceFrom: (_robot x) (_robot y) to: dest)
+							if: liftdist < 0 {
+								mult <- 50
+							} else: {
+								mult <- 75
+							}
+							lambdadist <- (distanceFrom: (_robot x) (_robot y) to: (cellTypes lambda))
+							if: lambdadist < 0 {
+								//debugLog: "lambda unreachable with lift multilier " . mult . "\n"
+								_heuristic <- score
+							} else: {
+								//debugLog: "lambda reachable at distance " . lambdadist . " lift multilier " . mult . "\n"
+								_heuristic <- (_robot collected) * mult - lambdadist - (moves length)
+							}
+						}
+						//_heuristic <- (_robot collected) * 75 - (distanceFrom: (_robot x) (_robot y) to: (cellTypes openLift) -  (moves length)
 						_heuristicValid <- true
 					}
 					_heuristic
 				}
 				addPoints <- :points { score <- score + points }
 				abort <- {
 					_ended <- true
 					addPoints: (_robot collected) * 25
 				}
 				advance <- :roboCmd {
-					_heuristicValid <- false
+					if: roboCmd = "?" {
-					if: roboCmd = "A" {
+						os write: 2 "valid moves: "
-						moves append: roboCmd
+						valid <- validMoves: (_robot x) (_robot y)
-						abort
+						foreach: valid :idx el {
-					}
+							os write: 2 (el cmd)
+						}
+						os write: 2 "\n"
+					} else: {
+						if: roboCmd = "h" {
+							os write: 2 "heuristic: " . heuristic . "\n"
+						} else: {
+							_heuristicValid <- false
+							if: roboCmd = "A" {
+								moves append: roboCmd
+								abort
+							}
-					if: (not: _ended) {
+							if: (not: _ended) {
-						_robot doCmd: roboCmd
+								_robot doCmd: roboCmd
-						score <- score - 1
+								score <- score - 1
-						moves append: roboCmd
+								moves append: roboCmd
-						doUpdate:
+								doUpdate:
-						checkForDeath:
+								checkForDeath:
-						swapGrids:
+								swapGrids:
-						if: (moves length) >= _maxmoves {
+								if: (moves length) >= _maxmoves {
-							abort
+									abort
+								}
+							}
 						}
 					}
 					self
 				}
 				printGrid <- {

Mercurial > repos > icfp2012

comparison src/sim.tp @ 62:ff2b38518a58