Mercurial > repos > icfp2014

comparison code/gameState.lm @ 54:476cd9eba2be

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fixed event system with refactor to remove gamestate passing. much more simple, less pure. runs correctly in simulator.
author William Morgan <billjunk@mrgn.org>
date Sun, 27 Jul 2014 16:52:36 -0700
parents 2c790eabe379
children c17380c8bac3
comparison
equal deleted inserted replaced
53:2c790eabe379 54:476cd9eba2be
49 makeEventType <- :lagTick isMovement behavior{ 49 makeEventType <- :lagTick isMovement behavior{
50 print: 12 50 print: 12
51 :curTick { 51 :curTick {
52 print: 11 52 print: 11
53 expireTick <- curTick + lagTick 53 expireTick <- curTick + lagTick
54 #[expireTick isMovement :gameState {behavior: expireTick gameState}] 54 #[expireTick isMovement :events {behavior: expireTick events}]
55 } 55 }
56 } 56 }
57 57
58 endOfLives <- makeEventType: (127 * (mapGrid gridArea) * 16) 0 :tick gameState { 58 endOfLives <- makeEventType: (127 * (mapGrid gridArea) * 16) 0 :tick events {
59 lives <- 0 59 lives <- 0
60 777 print 60 777 print
61 addEvents <- [] 61 events
62 #[addEvents gameState] 62 }
63 } 63
64 64 moveLambdaman <- makeEventType: 127 1 :tick events {
65 /*
66 moveLambdaman <- makeEventType: 127 1 :tick gameState {
67 addEvents <- []
68 #[addEvents gameState]
69 }
70 */
71 moveLambdaman <- makeEventType: 127 1 :tick gameState {
72 print: 20 65 print: 20
73 move <- getLambdamanChoice: 66 move <- getLambdamanChoice:
74 newPos <- (calcPos: move lambdamanPos) 67 newPos <- (calcPos: move lambdamanPos)
75 impending <- grid: mapGrid get: newPos 68 impending <- grid: mapGrid get: newPos
76 print: 21 69 print: 21
78 lambdamanPos <- impending 71 lambdamanPos <- impending
79 } else: { } 72 } else: { }
80 73
81 print: 22 74 print: 22
82 if: (impending isFood) { 75 if: (impending isFood) {
83 #[(moveLambdaman: (tick + 10)) gameState] 76 (moveLambdaman: (tick + 10)) | events
84 } else: { 77 } else: {
85 #[(moveLambdaman: tick) gameState] 78 (moveLambdaman: tick) | events
86 } 79 }
87 } 80 }
88 81
89 /* 82 /*
90 fruit <- 0 83 fruit <- 0
91 fruit1Appears <- makeEventType: (127 * 200) 0 :gameState { 84 fruit1Appears <- makeEventType: (127 * 200) 0 :events {
92 fruit <- 80 85 fruit <- 80
93 #[fruit1Expires gameState] 86 fruit1Expires | events
94 } 87 }
95 fruit2Appears <- (127 * 400) 0 88 fruit2Appears <- (127 * 400) 0
96 fruit1Expires <- (127 * 280) 0 89 fruit1Expires <- (127 * 280) 0
97 fruit2Expires <- (127 * 480) 0 90 fruit2Expires <- (127 * 480) 0
98 moveGhost0 <- 1 //(ghostType, ghostId)!? 91 moveGhost0 <- 1 //(ghostType, ghostId)!?
100 moveGhost2 <- 1 //(ghostType, ghostId)!? 93 moveGhost2 <- 1 //(ghostType, ghostId)!?
101 moveGhost3 <- 1 //(ghostType, ghostId)!? 94 moveGhost3 <- 1 //(ghostType, ghostId)!?
102 frightModeDeactivate <- (127 * 20) 0 95 frightModeDeactivate <- (127 * 20) 0
103 */ 96 */
104 97
105 executeEvents <- :tick isMove events gameState { 98 executeEvents <- :tick isMove events {
106 print: #[23 tick isMove events gameState] 99 print: #[23 tick isMove events]
107 event <- 0 100 event <- 0
108 eventTick <- 0 101 eventTick <- 0
109 eventIsMove <- 0 102 eventIsMove <- 0
110 eventLam <- 0 103 eventLam <- 0
111 104
112 unexpired <- [] 105 unexpired <- []
113 res <- 0
114 while: { not: (events empty?) } do: { 106 while: { not: (events empty?) } do: {
115 event <- events value 107 event <- events value
116 eventTick <- event value 108 eventTick <- event value
117 eventIsMove <- (event tail) value 109 eventIsMove <- (event tail) value
118 print: 17 110 print: 17
119 if: ( ( eventTick = tick ) myAnd: ( eventIsMove = isMove ) ) { 111 if: ( ( eventTick = tick ) myAnd: ( eventIsMove = isMove ) ) {
120 eventLam <- ((event tail) tail) 112 eventLam <- ((event tail) tail)
121 res <- eventLam: gameState 113 unexpired <- eventLam: unexpired
122 unexpired <- (res value) | unexpired
123 gameState <- res tail
124 } else: { 114 } else: {
125 unexpired <- event | unexpired 115 unexpired <- event | unexpired
126 } 116 }
127 events <- events tail 117 events <- events tail
128 } 118 }
129 print: 18 119 print: 18
130 #[unexpired gameState] 120 unexpired
131 } 121 }
132 122
133 executeTick <- :tick events gameState { 123 executeTick <- :tick events {
134 // TODO: update fruit countdown for AI input 124 // TODO: update fruit countdown for AI input
135 125
136 print: 14 126 print: 14
137 // 1.) movement 127 // 1.) movement
138 res <- executeEvents: tick 1 events gameState 128 events <- executeEvents: tick 1 events
139 events <- res value
140 gameState <- res tail
141 129
142 print: 15 130 print: 15
143 // 2.) actions 131 // 2.) actions
144 res <- executeEvents: tick 0 events gameState 132 events <- executeEvents: tick 0 events
145 print: #[19 res]
146 events <- res value
147 gameState <- res tail
148 133
149 print: 16 134 print: 16
150 // 3.) collide pills powerpills fruit 135 // 3.) collide pills powerpills fruit
151 136
152 if: pillCount = 0 { 137 if: pillCount = 0 {
153 win <- 1 138 win <- 1
154 #[[] gameState] 139 []
155 } else: { 140 } else: {
156 if: lives = 0 { 141 if: lives = 0 {
157 #[[] gameState] 142 []
158 } else: { 143 } else: {
159 #[events gameState] 144 events
160 } 145 }
161 } 146 }
162 147
163 } 148 }
164 149
175 } 160 }
176 } 161 }
177 162
178 print: 4 163 print: 4
179 :runUntil { 164 :runUntil {
180 res <- 0
181 tick <- 1 165 tick <- 1
182 events <- [ 166 events <- [
183 endOfLives: 0 167 endOfLives: 0
184 moveLambdaman: 0 168 moveLambdaman: 0
185 ] 169 ]
186 print: 6 170 print: 5
187 gameState <- #[0 0]
188 while: {(tick < runUntil) myAnd: (not: (events empty?))} do: { 171 while: {(tick < runUntil) myAnd: (not: (events empty?))} do: {
189 print: 5 172 print: 6
190 res <- executeTick: tick events gameState 173 events <- executeTick: tick events
191 print: 13
192 events <- res value
193 gameState <- res tail
194 print: 7 174 print: 7
195 tick <- events nextTick 175 tick <- events nextTick
196 } 176 }
197 } 177 }
198 } 178 }