--- a/code/dotScanner.lm	Sun Jul 27 19:52:30 2014 -0700
+++ b/code/dotScanner.lm	Sun Jul 27 19:53:08 2014 -0700
@@ -25,6 +25,9 @@
 		grid:get	
 		grid:update:with
 		grid:set:to
+		gridMaxX
+		gridMaxY
+		gridArea
 		grid:inBounds?
 		calcPos
 	] from: (module: "grid.lm")

--- a/code/gameState.lm	Sun Jul 27 19:52:30 2014 -0700
+++ b/code/gameState.lm	Sun Jul 27 19:53:08 2014 -0700
@@ -25,6 +25,9 @@
 		grid:get	
 		grid:update:with
 		grid:set:to
+		gridMaxX
+		gridMaxY
+		gridArea
 		grid:inBounds?
 		calcPos
 	] from: (module: "grid.lm")
@@ -34,50 +37,53 @@
 		(a + b) = 2
 	}
 
-	makeTicker <- :mapWidth mapHeight {
+	makeTicker <- :mapGrid {
 		lives <- 3
 		lambdamanPos <- #[5 5]
 		win <- 0
 		pillCount <- 50 
 
+		isFood <- :tile { (2 <= tile) myAnd: (tile <= 4) }
+		getLambdamanChoice <- {0}
+
 		makeEventType <- :lagTick isMovement behavior{
 			print: 12
 			:curTick {
 				print: 11
 				expireTick <- curTick + lagTick
-				#[expireTick isMovement :gameState {behavior: expireTick gameState}]
+				#[expireTick isMovement :events {behavior: expireTick events}]
 			}
 		}
 
-		endOfLives <- makeEventType: (127 * mapWidth * mapHeight * 160) 0 :tick gameState {
+		endOfLives <- makeEventType: (127 * (mapGrid gridArea) * 16) 0 :tick events {
 			lives <- 0
 			777 print
-			addEvents <- []
-			#[addEvents gameState]
+			events
 		}
 
-		isFood <- :tile {(2 <= tile) and (tile <= 4)}
-		getLambdaManChoice <- :{0}
-		moveLambdaMan <- makeEventType: 127 1 :tick gameState {
-			move <- getLambdaManChoice: 
+		moveLambdaman <- makeEventType: 127 1 :tick events {
+			print: 20
+			move <- getLambdamanChoice: 
 			newPos <- (calcPos: move lambdamanPos)
-			impending <- grid: grid get: newPos
+			impending <- grid: mapGrid get: newPos
+			print: 21
 			if: (not: (impending = 0)) {
 				lambdamanPos <- impending
-			} else { }
+			} else: { }
 
+			print: 22
 			if: (impending isFood) {
-				#[(moveLambdaMan: (tick + 10)) gameState]
-			} else { 
-				#[(moveLambdaMan: tick) gameState]
+				(moveLambdaman: (tick + 10)) | events
+			} else: { 
+				(moveLambdaman: tick) | events
 			}
 		}
 
 		/*
 		fruit <- 0
-		fruit1Appears <- makeEventType: (127 * 200) 0 :gameState {
+		fruit1Appears <- makeEventType: (127 * 200) 0 :events {
 			fruit <- 80
-			#[fruit1Expires gameState]
+			fruit1Expires | events
 		}
 		fruit2Appears <- (127 * 400) 0
 		fruit1Expires <- (127 * 280) 0
@@ -89,14 +95,14 @@
 		frightModeDeactivate <- (127 * 20) 0
 		*/
 
-		executeEvents <- :tick isMove events gameState {
+		executeEvents <- :tick isMove events {
+			print: #[23 tick isMove events]
 			event <- 0
 			eventTick <- 0
 			eventIsMove <- 0
 			eventLam <- 0
 
 			unexpired <- []
-			res <- 0
 			while: { not: (events empty?) } do: {
 				event <- events value
 				eventTick <- event value
@@ -104,45 +110,38 @@
 				print: 17
 				if: ( ( eventTick = tick ) myAnd: ( eventIsMove = isMove ) ) {
 					eventLam <- ((event tail) tail)
-					res <- eventLam: gameState
-					unexpired <- res value
-					gameState <- res tail
+					unexpired <- eventLam: unexpired
 				} else: {
 					unexpired <- event | unexpired
 				}
 				events <- events tail
 			}
 			print: 18
-			#[unexpired gameState]
+			unexpired
 		}
 
-		executeTick <- :tick events gameState {
+		executeTick <- :tick events {
 			// TODO: update fruit countdown for AI input
 
 			print: 14
 			// 1.) movement
-			res <- executeEvents: tick 1 events gameState 
-			events <- res value
-			gameState <- (res tail) value
+			events <- executeEvents: tick 1 events
 
 			print: 15
 			// 2.) actions
-			res <- executeEvents: tick 0 events gameState
-			
-			events <- res value
-			gameState <- (res tail) value
+			events <- executeEvents: tick 0 events
 			
 			print: 16
 			// 3.) collide pills powerpills fruit
 
 			if: pillCount = 0 {
 				win <- 1
-				#[[] gameState]
+				[]
 			} else: {
 				if: lives = 0 {
-					#[[] gameState]
-				} else: { 
-					#[events gameState]
+					[]
+				} else: {
+					events
 				}
 			}
 
@@ -160,39 +159,58 @@
 				curMin
 			}
 		}
+
 		print: 4
 		:runUntil {
-			res <- 0
 			tick <- 1
 			events <- [
 				endOfLives: 0
+				moveLambdaman: 0
 			]
-			print: 6
-			gameState <- #[0 0]
-			while: {(tick < runUntil) and (not: (events empty?))} do: {
+			print: 5
+			while: {(tick < runUntil) myAnd: (not: (events empty?))} do: {
+				print: 6
+				events <- executeTick: tick events
 				print: 7
 				tick <- events nextTick
-				print: 5
-				res <- executeTick: tick events gameState
-				print: 13
-				events <- res value
-				gameState <- res tail
 			}
 		}
 	}
 
 	step <- :myState world {
 		print: 1
-		ticker <- makeTicker: 10 10
+		grid <- makeTree: (map: (world value) :row { 
+			makeTree: row 
+		})
+
+		ticker <- makeTicker: grid
 		print: 2
 		ticker: 1000
 		print: 3
 
 		#[0 0]
 	}
-
+/*
 	main <- :initWorld ghostCode{
 		#[0 step]
 	}
+*/
+	main <- {
+		print: (step: 0 #[
+			//grid
+			[
+				[0 0 0 0]
+				[0 2 2 0]
+				[0 1 0 0]
+				[0 0 0 0]
+			]
+			//lmstate
+			#[0 #[1 2] 2 3 0]
+			//ghost state
+			[]
+			//fruit state
+			0
+		])
+	}
 }
 

--- a/code/grid.lm	Sun Jul 27 19:52:30 2014 -0700
+++ b/code/grid.lm	Sun Jul 27 19:53:08 2014 -0700
@@ -39,11 +39,15 @@
 		grid: grid update: pos with: :el { val }
 	}
 
+	gridMaxY <- :grid {grid value}
+	gridMaxX <- :grid {(get: 0 fromTree: grid) value}
+	gridArea <- :grid {(grid gridMaxX) * (grid gridMaxY)}
+
 	grid:inBounds? <- :grid :pos {
 		x <- pos value
 		y <- pos tail
-		maxY <- grid value
-		maxX <- (get: 0 fromTree: grid) value
+		maxY <- (grid gridMaxY)
+		maxX <- (grid gridMaxX)
 		((x >= 0) + (y >= 0) + (x < maxX) + (y < maxY)) > 0
 	}