Mercurial > repos > icfp2014
comparison code/dotScanner.lm @ 28:75c97fb80602
Tag team simple AI WIP
author | William Morgan <billjunk@mrgn.org> |
---|---|
date | Sat, 26 Jul 2014 00:03:41 -0700 |
parents | 4f7a421e77c6 |
children | 5d1ac440b9db |
comparison
equal
deleted
inserted
replaced
27:abd8ceef0dd8 | 28:75c97fb80602 |
---|---|
53 } else: {} | 53 } else: {} |
54 lst <- lst tail | 54 lst <- lst tail |
55 } | 55 } |
56 reverse: new | 56 reverse: new |
57 } | 57 } |
58 | |
59 flatten <- :lst { | |
60 fold: lst [] with: :acc el { | |
61 fold: el acc with: :iacc iel { | |
62 iel | iacc | |
63 } | |
64 } | |
65 } | |
58 | 66 |
59 makeTree:size <- :lst :size { | 67 makeTree:size <- :lst :size { |
60 ret <- 0 | 68 ret <- 0 |
61 sub <- 0 | 69 sub <- 0 |
62 half <- size / 2 | 70 half <- size / 2 |
80 size <- lst length | 88 size <- lst length |
81 #[size (makeTree: lst size: size)] | 89 #[size (makeTree: lst size: size)] |
82 } | 90 } |
83 | 91 |
84 get:fromTree:size <- :idx :tree :size { | 92 get:fromTree:size <- :idx :tree :size { |
85 print: #[1 tree size] | |
86 ret <- 0 | 93 ret <- 0 |
87 half <- size / 2 | 94 half <- size / 2 |
88 if: size <= 2 { | 95 if: size <= 2 { |
89 if: idx = 0 { | 96 if: idx = 0 { |
90 ret <- tree value | 97 ret <- tree value |
101 ret | 108 ret |
102 } | 109 } |
103 | 110 |
104 get:fromTree <- :idx :tree { | 111 get:fromTree <- :idx :tree { |
105 size <- tree value | 112 size <- tree value |
106 print: #[0 size] | |
107 get: idx fromTree: (tree tail) size: size | 113 get: idx fromTree: (tree tail) size: size |
108 } | 114 } |
109 | 115 |
110 treeMap:size <- :tree fun :size { | 116 treeMap:size <- :tree fun :size { |
111 ret <- 0 | 117 ret <- 0 |
165 tree:set:to <- :tree :idx :val { | 171 tree:set:to <- :tree :idx :val { |
166 tree: tree update: idx with: :el { val } | 172 tree: tree update: idx with: :el { val } |
167 } | 173 } |
168 | 174 |
169 grid:get <- :grid :pos { | 175 grid:get <- :grid :pos { |
176 print: #[15 pos] | |
170 x <- pos value | 177 x <- pos value |
171 y <- pos tail | 178 y <- pos tail |
172 get: x fromTree: (get: y fromTree: grid) | 179 get: x fromTree: (get: y fromTree: grid) |
173 } | 180 } |
174 | 181 |
189 y <- pos tail | 196 y <- pos tail |
190 maxY <- grid value | 197 maxY <- grid value |
191 maxX <- (get: 0 fromTree: grid) value | 198 maxX <- (get: 0 fromTree: grid) value |
192 ((x >= 0) + (y >= 0) + (x < maxX) + (y < maxY)) > 0 | 199 ((x >= 0) + (y >= 0) + (x < maxX) + (y < maxY)) > 0 |
193 } | 200 } |
194 | |
195 /* | |
196 ListGet <- :cell idx { | |
197 if: idx = 0 {cell value} else: { | |
198 ListGet: (cell tail) (idx - 1) | |
199 } | |
200 } | |
201 TupGet <- :cell depth size { | |
202 if: idx = 0 {cell value} else: { | |
203 if: size = 1 {cell tail} else: { // warning, out-of-bounds idx will return a value! | |
204 TupGet: (cell tail) (idx - 1) (size - 1) | |
205 }} | |
206 } | |
207 | |
208 // rowmajor lists | |
209 GridGet <- :x y w h{ | |
210 ListGet | |
211 ... | |
212 } | |
213 */ | |
214 | 201 |
215 visited <- 0 | 202 visited <- 0 |
216 /* | 203 |
217 advancer <- :listOfTupsLams { | 204 advancer <- :continuations { |
205 print: 5 | |
218 notdone <- 1 | 206 notdone <- 1 |
219 while: { notdone } do: { | 207 while: { notdone } do: { |
220 listOfLamTups <- fold: listOfLamTups [] with: :acc el{ | 208 if: (continuations isInteger?) { |
221 ret <- 0 | 209 notdone <- 0 |
222 newTupLams <- (el tail): | 210 } else: { |
223 | 211 print: 6 |
224 | 212 continuations <- flatten: (fold: continuations [] with: :acc el{ |
225 // zero means "I have not found it" | 213 print: 7 |
226 | 214 ret <- acc |
227 if: (el value) = 0 { | 215 if: notdone { |
228 newTupLams <- (el tail): | 216 ret <- el: |
229 if: (isInteger?: newTupLams) { | 217 if: (ret isInteger?) { |
230 ret <- acc | 218 } else: { |
231 } else: { | 219 if: (ret value) { |
232 ret <- acc | newTupLams | 220 notdone <- 0 |
233 } | 221 ret <- (ret tail) |
234 } else: { | 222 } else: { |
235 notdone <- 0 | 223 ret <- (ret tail) | acc |
236 ret <- [(el tail)] | 224 } |
237 } | 225 } |
238 } | 226 } else: {} |
239 } | 227 }) |
240 | 228 } |
241 } | 229 } |
242 */ | 230 continuations |
231 } | |
243 | 232 |
244 calcPos <- :move from { | 233 calcPos <- :move from { |
245 x <- from value | 234 x <- from value |
246 y <- from tail | 235 y <- from tail |
247 if: move { | 236 if: move { |
263 makeContClos <- :grid myLoc path { | 252 makeContClos <- :grid myLoc path { |
264 { | 253 { |
265 ret <- [] | 254 ret <- [] |
266 move <- 0 | 255 move <- 0 |
267 atpos <- 0 | 256 atpos <- 0 |
257 print: 9 | |
268 if: (grid: grid inBounds?: myLoc) { | 258 if: (grid: grid inBounds?: myLoc) { |
259 print: 10 | |
269 if: (grid: visited get: myLoc) { | 260 if: (grid: visited get: myLoc) { |
270 } else: { | 261 } else: { |
262 print: 11 | |
271 atpos <- grid: grid get: myLoc | 263 atpos <- grid: grid get: myLoc |
272 if: (atpos = 2) + (atpos = 3) + (atpos = 4) { | 264 if: (atpos = 2) + (atpos = 3) + (atpos = 4) { |
265 print: 12 | |
273 ret <- #[1 (reverse: path)] | 266 ret <- #[1 (reverse: path)] |
274 } else: { | 267 } else: { |
268 print: 13 | |
275 visited <- grid: visited set: myLoc to: 1 | 269 visited <- grid: visited set: myLoc to: 1 |
276 if: atpos { | 270 if: atpos { |
271 print: 14 | |
277 move <- 0 | 272 move <- 0 |
278 while: { move < 4 } do: { | 273 while: { move < 4 } do: { |
279 ret <- (makeContClos: grid (calcPos: move myLoc) move | path) | ret | 274 ret <- (makeContClos: grid (calcPos: move myLoc) move | path) | ret |
280 } | 275 } |
281 ret <- #[0 ret] | 276 ret <- #[0 ret] |
282 } else: {} | 277 } else: {} |
283 } | 278 } |
284 } | 279 } |
285 } else: {} | 280 } else: { |
281 print: 42 | |
282 } | |
286 ret | 283 ret |
287 } | 284 } |
288 } | 285 } |
289 | 286 |
290 //scanFor <- :target visited { | |
291 //} | |
292 counterLoad <- 4 | |
293 step <- :myState world { | 287 step <- :myState world { |
288 print: -1 | |
294 grid <- makeTree: (map: (world value) :row { makeTree: row }) | 289 grid <- makeTree: (map: (world value) :row { makeTree: row }) |
295 lmState <- (world value) tail | 290 print: 0 |
291 lmState <- (world tail) value | |
292 print: 1 | |
296 myLoc <- (lmState tail) value | 293 myLoc <- (lmState tail) value |
297 | 294 |
298 | 295 print: 2 |
299 visited <- treeMap: grid :el { 0 } | 296 visited <- treeMap: grid :row { |
300 /* | 297 treeMap: row :el { 0 } |
301 cont <- { | 298 } |
302 if: (grid: grid get: myLoc | 299 print: 3 |
303 visited <- tree: visited set: myLoc to: 1 | 300 path <- advancer: [(makeContClos: grid myLoc [])] |
304 */ | 301 print: #[4 path] |
305 | 302 #[0 (path value)] |
306 | |
307 | |
308 //myPos <- | |
309 path <- [3 1 3 1] //scanFor: 2 3 [myPos] | |
310 move <- myState value | |
311 counter <- (myState tail) - 1 | |
312 if: counter = 0 { | |
313 move <- move + 1 | |
314 counter <- counterLoad | |
315 if: move = 4 { | |
316 move <- 0 | |
317 } else: {} | |
318 } else: {} | |
319 #[0 ((path tail) value)] | |
320 } | 303 } |
321 | 304 |
322 main <- :initWorld mystery { | 305 main <- :initWorld mystery { |
323 #[0 step] | 306 #[0 step] |
324 } | 307 } |
325 } | 308 } |
326 | 309 |
327 //does not work: | 310 |
328 //someListOrTup get: 0 | |
329 //lambdaman program (step function) faulted TagMismatch | |
330 |