Home Insert About

PacMan

Single level retro game playable inside TryFsharp using the cursor keys.

Load in:
tryfsharp.org
tryfs.net
Embed
Raw View
Copy Source
Copy Link
Tools:

PacMan game

  1: type Game(scene:IScene, input:IInput) =
  2:     let createText text = scene.CreateText(text)
  3:     let toBitmap color lines = scene.CreateBitmap(color,lines)
  4:     let toImage (bitmap:IBitmap) = bitmap.CreateContent()
  5:     let load s =
  6:         let w,h,lines = Images.nameToValue |> Seq.find (fst >> (=) s) |> snd
  7:         scene.CreateBitmap(w,h,lines).CreateContent()
  8:     let add item = scene.Contents.Add(item)
  9:     let remove item = scene.Contents.Remove(item)
 10:     let contains item = scene.Contents.Contains(item)
 11:     let set (element:IContent) (x,y) = element.Move(x - 16 |> float, y + 8 |> float)
 12:     let maze = "
 13: ##/------------7/------------7##
 14: ##|............|!............|##
 15: ##|./__7./___7.|!./___7./__7.|##
 16: ##|o|  !.|   !.|!.|   !.|  !o|##
 17: ##|.L--J.L---J.LJ.L---J.L--J.|##
 18: ##|..........................|##
 19: ##|./__7./7./______7./7./__7.|##
 20: ##|.L--J.|!.L--7/--J.|!.L--J.|##
 21: ##|......|!....|!....|!......|##
 22: ##L____7.|L__7 |! /__J!./____J##
 23: #######!.|/--J LJ L--7!.|#######
 24: #######!.|!          |!.|#######
 25: #######!.|! /__==__7 |!.|#######
 26: -------J.LJ |      ! LJ.L-------
 27: ########.   | **** !   .########
 28: _______7./7 |      ! /7./_______
 29: #######!.|! L______J |!.|#######
 30: #######!.|!          |!.|#######
 31: #######!.|! /______7 |!.|#######
 32: ##/----J.LJ L--7/--J LJ.L----7##
 33: ##|............|!............|##
 34: ##|./__7./___7.|!./___7./__7.|##
 35: ##|.L-7!.L---J.LJ.L---J.|/-J.|##
 36: ##|o..|!.......<>.......|!..o|##
 37: ##L_7.|!./7./______7./7.|!./_J##
 38: ##/-J.LJ.|!.L--7/--J.|!.LJ.L-7##
 39: ##|......|!....|!....|!......|##
 40: ##|./____JL__7.|!./__JL____7.|##
 41: ##|.L--------J.LJ.L--------J.|##
 42: ##|..........................|##
 43: ##L--------------------------J##"
 44: 
 45:     let tops = [
 46:         0b00000000, 0b00000000, 0b00000000
 47:         0b00000000, 0b00000000, 0b00000000
 48:         0b00000000, 0b00000000, 0b00000000
 49:         0b00000000, 0b00000000, 0b00000000
 50:         0b00000011, 0b11111111, 0b11000000
 51:         0b00000100, 0b00000000, 0b00100000
 52:         0b00001000, 0b00000000, 0b00010000
 53:         0b00001000, 0b00000000, 0b00010000]
 54:     let mids = [
 55:         0b00001000, 0b00000000, 0b00010000
 56:         0b00001000, 0b00000000, 0b00010000
 57:         0b00001000, 0b00000000, 0b00010000
 58:         0b00001000, 0b00000000, 0b00010000
 59:         0b00001000, 0b00000000, 0b00010000
 60:         0b00001000, 0b00000000, 0b00010000
 61:         0b00001000, 0b00000000, 0b00010000
 62:         0b00001000, 0b00000000, 0b00010000]
 63:     let bots = [
 64:         0b00001000, 0b00000000, 0b00010000
 65:         0b00001000, 0b00000000, 0b00010000
 66:         0b00000100, 0b00000000, 0b00100000
 67:         0b00000011, 0b11111111, 0b11000000
 68:         0b00000000, 0b00000000, 0b00000000
 69:         0b00000000, 0b00000000, 0b00000000
 70:         0b00000000, 0b00000000, 0b00000000
 71:         0b00000000, 0b00000000, 0b00000000]
 72:     let door' = [
 73:         0b00000000
 74:         0b00000000
 75:         0b00000000
 76:         0b00000000
 77:         0b11111111
 78:         0b00000000
 79:         0b00000000
 80:         0b00000000]
 81:     let pill' = [
 82:         0b00000000
 83:         0b00000000
 84:         0b00000000
 85:         0b00011000
 86:         0b00011000
 87:         0b00000000
 88:         0b00000000
 89:         0b00000000]
 90:     let power' = [
 91:         0b00000000
 92:         0b00011000
 93:         0b00111100
 94:         0b01111110
 95:         0b01111110
 96:         0b00111100
 97:         0b00011000
 98:         0b00000000]
 99: 
100:     let fromTriple xs = 
101:         let convert = toBitmap Paint.Blue
102:         List.foldBack (fun (l,m,r) (ls,ms,rs) -> l::ls, m::ms, r::rs) xs ([],[],[])
103:         |> fun (l,m,r) -> convert l, convert m, convert r
104: 
105:     let tl, top, tr         = fromTriple tops
106:     let left, blank, right  = fromTriple mids
107:     let bl, bottom, br      = fromTriple bots
108:     let door = toBitmap Paint.White door'
109:     let pill = toBitmap Paint.Yellow pill'
110:     let power = toBitmap Paint.Yellow power'
111: 
112:     let toTile c =
113:         match c with
114:         | '=' -> door
115:         | '_' -> top
116:         | '|' -> left
117:         | '!' -> right
118:         | '/' -> tl
119:         | '7' -> tr
120:         | 'L' -> bl
121:         | 'J' -> br
122:         | '-' -> bottom
123:         | '.' -> pill
124:         | 'o' -> power
125:         | _ -> blank
126: 
127:     let isWall = function
128:         | '_' | '|' | '!' | '/' | '7' | 'L' | 'J' | '-' | '*' -> true
129:         | _ -> false
130: 
131:     let isEdible = function '.' | 'o' -> true | _ -> false
132:     let mutable totalDots = 0
133:     let walls = scene.AddLayer()
134:     let lines = maze.Split('\n')
135:     let tiles =
136:         lines |> Array.mapi (fun y line ->
137:             line.ToCharArray() |> Array.mapi (fun x item ->
138:                 let tile = toTile item |> toImage
139:                 set tile (x * 8, y * 8)
140:                 if isEdible item then totalDots <- totalDots + 1
141:                 if isWall item 
142:                 then walls.Contents.Add tile |> ignore
143:                 else scene.Contents.Add tile |> ignore
144:                 tile
145:             )
146:         )
147:     let route_home =
148:         let numbers =
149:             lines |> Array.map (fun line ->
150:                 line.ToCharArray() 
151:                 |> Array.map (fun c -> if isWall c then System.Int32.MaxValue else -1)
152:             )
153:         let canFill (x,y) =
154:             y>=0 && y < numbers.Length &&
155:             x>=0 && x < numbers.[y].Length &&
156:             numbers.[y].[x] = -1
157:         let fill n (x,y) = numbers.[y].[x] <- n
158:         flood canFill fill (16,16)
159:         numbers
160: 
161:     let tileAt x y =
162:         if x < 0 || x > 30 then ' '
163:         else lines.[y].[x]
164: 
165:     let isWallAt (x,y) = tileAt x y |> isWall
166:     let p = load "p"
167:     let pu = load "pu1", load "pu2"
168:     let pd = load "pd1", load "pd2"
169:     let pl = load "pl1", load "pl2"
170:     let pr = load "pr1", load "pr2"
171:     
172:     let mutable finished = false
173:     let mutable lives = [for _ in 1..9 -> load "pl1"]
174:     do  lives |> List.iteri (fun i life -> add life; set life (16+16*i,32*8))
175:     do  lives <- lives |> List.rev
176:     let decLives () =
177:         lives <-
178:             match lives with
179:             | [] -> 
180:                 let text = createText "GAME OVER"
181:                 set text (12*8, 15*8)
182:                 add text
183:                 finished <- true
184:                 []
185:             | x::xs -> 
186:                 remove x
187:                 xs
188: 
189:     let ghost_starts = 
190:         [
191:             "red", (16, 12), (1,0)
192:             "cyan", (14, 16), (1,0)
193:             "pink" , (16, 14), (0,-1)
194:             "orange" , (18, 16), (-1,0)
195:         ]
196:         |> List.map (fun (color,(x,y),v) -> 
197:             let blue = load "blue"
198:             let eyes = load "eyeu", load "eyed", load "eyel", load "eyer"
199:             let body = load (color+"u"), load (color+"d"), load (color+"l"), load (color+"r")
200:             let _,image,_,_ = body
201:             { Blue=blue; Eyes=eyes; Body=body; X=x*8-7; Y=y*8-3; V=v; Image=image; IsReturning=false }
202:         )
203:     let mutable ghosts = ghost_starts
204:     do  ghosts |> List.iter (fun ghost -> 
205:         add ghost.Image
206:         set ghost.Image (ghost.X,ghost.Y)
207:         )
208: 
209:     let mutable score = 0
210:     let mutable bonus = 0
211:     let mutable bonuses = []
212:     let x = ref (16 * 8 - 7)
213:     let y = ref (24 * 8 - 3)
214:     let v = ref (0,0)
215:     let pacman = ref p
216:     do  add !pacman
217:     do  set !pacman (!x,!y)
218:     let mutable powerCount = 0
219: 
220:     let noWall (x,y) (ex,ey) =
221:         let bx, by = int ((x+6+ex)/8), int ((y+6+ey)/8)
222:         isWallAt (bx,by) |> not
223: 
224:     let fillValue (x,y) (ex,ey) =
225:         let bx, by = int ((x+6+ex)/8), int ((y+6+ey)/8)
226:         route_home.[by].[bx]
227: 
228:     let verticallyAligned (x,y) = x % 8 = 5
229:     let horizontallyAligned (x,y) = y % 8 = 5
230: 
231:     let canGoUp (x,y) = verticallyAligned (x,y) && noWall (x,y) (0,-4)
232:     let canGoDown (x,y) = verticallyAligned (x,y) && noWall (x,y) (0,5)
233:     let canGoLeft (x,y) = horizontallyAligned (x,y) && noWall (x,y) (-4,0)
234:     let canGoRight (x,y) = horizontallyAligned (x,y) && noWall (x,y) (5,0)
235: 
236:     let fillUp (x,y) = fillValue (x,y) (0,-4)
237:     let fillDown (x,y) = fillValue (x,y) (0,5)
238:     let fillLeft (x,y) = fillValue (x,y) (-4,0)
239:     let fillRight (x,y) = fillValue (x,y) (5,0)
240: 
241:     let go (x,y) (dx,dy) =
242:         let x = 
243:             if   dx = -1 && x = 0 then 30 * 8
244:             elif dx = 1  && x = 30 *8 then 0
245:             else x
246:         x + dx, y + dy
247: 
248:     let newGhosts () =
249:         ghosts |> List.map (fun ghost ->
250:             let x, y = ghost.X, ghost.Y
251:             let dx, dy = ghost.V
252:             let u,d,l,r = ghost.Body
253:             let u',d',l',r' = ghost.Eyes
254:             let face, eye, canMove =
255:                 match dx, dy with
256:                 | 0,-1 -> u, u', canGoUp (x,y)
257:                 | 0, 1 -> d, d', canGoDown (x,y)
258:                 | -1,0 -> l, l', canGoLeft (x,y)
259:                 | 1, 0 -> r, r', canGoRight (x,y)
260:                 | _, _ -> invalidOp ""
261:             let isBackwards (a,b) =
262:                 (a <> 0 && a = -dx) || (b <> 0 && b = -dy)
263:             let directions = 
264:                 [
265:                 if canGoUp (x,y) then yield (0,-1), fillUp (x,y)
266:                 if canGoDown (x,y) then yield (0,1), fillDown (x,y)
267:                 if canGoLeft (x,y) then yield (-1,0), fillLeft (x,y)
268:                 if canGoRight(x,y) then yield (1,0), fillRight (x,y)
269:                 ]
270:             let directions =
271:                 if ghost.IsReturning then
272:                     directions
273:                     |> Seq.sortBy snd
274:                     |> Seq.map fst
275:                 else
276:                     directions
277:                     |> Seq.map fst
278:                     |> Seq.unsort
279:                     |> Seq.sortBy isBackwards
280:             let dx, dy = directions |> Seq.head
281:             let x,y = go (x,y) (dx,dy)
282:             let returning =
283:                 if ghost.IsReturning && 0 = (fillValue (x,y) (0,0))
284:                 then false
285:                 else ghost.IsReturning
286:             remove ghost.Image
287:             let face = 
288:                 if ghost.IsReturning then eye
289:                 else
290:                     if powerCount > 0 then ghost.Blue else face
291:             add face
292:             set face (x,y)
293:             { ghost with X = x; Y = y; V = (dx,dy); Image = face; IsReturning = returning }
294:         )
295: 
296:     let mutable ghostCounter = 0
297: 
298:     let updateGhosts () = 
299:         let modulus = if powerCount > 0 then 4 else 16
300:         if ghostCounter % modulus <> 0 then
301:             ghosts <- newGhosts ()
302:         ghostCounter <- ghostCounter + 1
303: 
304:     let updatePacman () =
305:         let inputs = 
306:             [
307:             if input.IsUp then yield canGoUp (!x,!y), (0,-1), pu
308:             if input.IsDown then yield canGoDown (!x,!y), (0,1), pd
309:             if input.IsLeft  then yield canGoLeft (!x,!y), (-1,0), pl
310:             if input.IsRight then yield canGoRight (!x,!y), (1,0), pr
311:             ] 
312:         let move ((dx,dy),(d1,d2)) =
313:             let x', y' = go (!x,!y) (dx,dy)
314:             x := x'; y := y'; v := (dx,dy)
315:             remove !pacman
316:             let d = if (!x/6 + !y/6) % 2 = 0 then d1 else d2
317:             add d
318:             pacman := d
319:         let availableDirections =
320:             inputs
321:             |> List.filter (fun (can,_,_) -> can)
322:             |> List.map (fun (_,v,f) -> v,f)
323:             |> Seq.sortBy (fun (v',_) -> v' = !v)
324:         if Seq.length availableDirections > 0 then
325:             availableDirections |> Seq.head |> move
326:         else
327:             let goForward =
328:                 match !v with
329:                 | 0,-1 -> canGoUp(!x,!y), pu
330:                 | 0,1  -> canGoDown(!x,!y), pd
331:                 | -1,0 -> canGoLeft(!x,!y), pl
332:                 | 1, 0 -> canGoRight(!x,!y), pr
333:                 | 0, 0 -> false, pu
334:                 | _ -> invalidOp ""
335:             if fst goForward && inputs.Length > 0 then
336:                 (!v, snd goForward) |> move 
337:         let tx, ty = int ((!x+6)/8), int ((!y+6)/8)
338:         if tileAt tx ty = '.' then
339:             if contains (tiles.[ty].[tx]) then
340:                 score <- score + 10
341:                 remove (tiles.[ty].[tx])
342:                 totalDots <- totalDots - 1
343:         if tileAt tx ty = 'o' then
344:             if contains (tiles.[ty].[tx]) then
345:                 score <- score + 50
346:                 powerCount <- 500
347:                 bonus <- 0
348:                 totalDots <- totalDots - 1
349:             remove (tiles.[ty].[tx])
350:         set !pacman (!x,!y)
351:         if totalDots = 0 then
352:             let text = createText "LEVEL COMPLETED"
353:             set text (7*8, 15*8)
354:             add text
355:             finished <- true
356: 
357: 
358:     let updatePower () =
359:         if powerCount > 0 then
360:             if (powerCount/5) % 2 = 1 then walls.SetOpacity(0.5)
361:             else walls.SetOpacity(1.0)
362:         else walls.SetOpacity(1.0)
363:         powerCount <- powerCount - 1
364: 
365:     let mutable flashCount = 0
366: 
367:     let updateFlash () =
368:         if flashCount > 0 then
369:             if ((flashCount / 5) % 2) = 1 then (!pacman).SetOpacity(0.5)
370:             else (!pacman).SetOpacity(1.0)
371:             flashCount <- flashCount - 1
372:         else (!pacman).SetOpacity(1.0)
373: 
374:     let touchGhosts () =
375:         let px, py = !x, !y
376:         ghosts |> List.filter (fun ghost ->
377:             let x,y = ghost.X, ghost.Y
378:             ((px >= x && px < x + 13) ||
379:              (x < px + 13 && x >= px)) &&
380:             ((py >= y && py < y + 13) ||
381:              (y < py + 13 && y >= py))
382:         )
383: 
384:     let handleTouching () =
385:         let touching = touchGhosts()
386:         if touching.Length > 0 then
387:             if powerCount > 0 
388:             then ghosts <- ghosts |> List.mapi (fun i ghost ->
389:                 if not ghost.IsReturning && 
390:                    touching |> List.exists ((=) ghost)
391:                 then
392:                     score <- score + (pown 2 bonus) * 200 
393:                     let b = load ([|"200";"400";"800";"1600"|]).[bonus]
394:                     set b (ghost.X, ghost.Y)
395:                     add b
396:                     bonuses <- (100,b) :: bonuses
397:                     bonus <- min 3 (bonus + 1)
398:                     { ghost with IsReturning = true; }
399:                 else ghost
400:             )
401:             else
402:                 if flashCount = 0 then
403:                     decLives()
404:                     flashCount <- 30
405: 
406:     let updateBonuses () =
407:         let removals,remainders =
408:             bonuses 
409:             |> List.map (fun (count,x) -> count-1,x)
410:             |> List.partition (fst >> (=) 0)
411:         bonuses <- remainders
412:         removals |> List.iter (fun (_,x) -> remove x)
413: 
414:     let p1 = createText("SCORE")
415:     do  p1.Move(0.0,0.0); scene.Contents.Add(p1)
416:     let s1 = createText("")
417:     do  s1.Move(5.0*8.0,0.0); scene.Contents.Add(s1)
418: 
419:     let updateScore () =
420:         s1.SetText(sprintf "%7d" score)
421: 
422:     do  updateScore ()
423: 
424:     let update () =
425:         updatePacman ()
426:         updateGhosts ()
427:         handleTouching ()
428:         updateFlash ()
429:         updatePower ()
430:         updateBonuses ()
431:         updateScore ()
432: 
433:     member this.Update () = 
434:         if not finished then update ()
type Game =
  class
    new : scene:IScene * input:IInput -> Game
    member Update : unit -> unit
  end

Full name: Snippet.Game
val scene : IScene
Multiple items
type IScene =
  interface
    abstract member AddLayer : unit -> ILayer
    abstract member CreateBitmap : Paint * seq<int> -> IBitmap
    abstract member CreateBitmap : int * int * int [] [] -> IBitmap
    abstract member CreateText : string -> ITextContent
    abstract member LoadBitmap : string -> IBitmap
    abstract member Contents : IContents
  end

Full name: Snippet.IScene

--------------------

IScene
val input : IInput
Multiple items
type IInput =
  interface
    abstract member IsDown : bool
    abstract member IsLeft : bool
    abstract member IsRight : bool
    abstract member IsUp : bool
  end

Full name: Snippet.IInput

--------------------

IInput
val createText : (string -> ITextContent)
val text : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
abstract member IScene.CreateText : string -> ITextContent
val toBitmap : (Paint -> seq<int> -> IBitmap)
val color : Paint
val lines : seq<int>

  type: seq<int>
  inherits: System.Collections.IEnumerable
Multiple overloads
abstract member IScene.CreateBitmap : Paint * seq<int> -> IBitmap
abstract member IScene.CreateBitmap : int * int * int [] [] -> IBitmap
val toImage : (IBitmap -> IContent)
val bitmap : IBitmap
Multiple items
type IBitmap =
  interface
    abstract member CreateContent : unit -> IContent
  end

Full name: Snippet.IBitmap

--------------------

IBitmap
abstract member IBitmap.CreateContent : unit -> IContent
val load : (string -> IContent)
val s : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
val w : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val h : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val lines : int [] []

  type: int [] []
  implements: System.ICloneable
  implements: System.Collections.IList
  implements: System.Collections.ICollection
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.IStructuralEquatable
  implements: System.Collections.Generic.IList<int []>
  implements: System.Collections.Generic.ICollection<int []>
  implements: seq<int []>
  implements: System.Collections.IEnumerable
  inherits: System.Array
module Images

from Snippet
val nameToValue : (string * (int * int * int [] [])) list

Full name: Snippet.Images.nameToValue

  type: (string * (int * int * int [] [])) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<string * (int * int * int [] [])>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<string * (int * int * int [] [])>
  implements: System.Collections.IEnumerable
Multiple items
module Seq

from Snippet

--------------------

module Seq

from Microsoft.FSharp.Collections
val find : ('T -> bool) -> seq<'T> -> 'T

Full name: Microsoft.FSharp.Collections.Seq.find
val fst : ('T1 * 'T2) -> 'T1

Full name: Microsoft.FSharp.Core.Operators.fst
val snd : ('T1 * 'T2) -> 'T2

Full name: Microsoft.FSharp.Core.Operators.snd
val add : (IContent -> unit)
val item : IContent
property IScene.Contents: IContents
abstract member IContents.Add : IContent -> unit
val remove : (IContent -> unit)
abstract member IContents.Remove : IContent -> unit
val contains : (IContent -> bool)
abstract member IContents.Contains : IContent -> bool
val set : (IContent -> int * int -> unit)
val element : IContent
Multiple items
type IContent =
  interface
    abstract member Move : float * float -> unit
    abstract member SetOpacity : float -> unit
    abstract member Control : obj
  end

Full name: Snippet.IContent

--------------------

IContent
val x : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val y : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
abstract member IContent.Move : float * float -> unit
Multiple items
val float : 'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------

type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>

  type: float<'Measure>
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IFormattable
  implements: System.IComparable<float<'Measure>>
  implements: System.IEquatable<float<'Measure>>
  inherits: System.ValueType


--------------------

type float = System.Double

Full name: Microsoft.FSharp.Core.float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val maze : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
val tops : (int * int * int) list

  type: (int * int * int) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int * int * int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int * int * int>
  implements: System.Collections.IEnumerable
val mids : (int * int * int) list

  type: (int * int * int) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int * int * int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int * int * int>
  implements: System.Collections.IEnumerable
val bots : (int * int * int) list

  type: (int * int * int) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int * int * int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int * int * int>
  implements: System.Collections.IEnumerable
val door' : int list

  type: int list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int>
  implements: System.Collections.IEnumerable
val pill' : int list

  type: int list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int>
  implements: System.Collections.IEnumerable
val power' : int list

  type: int list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int>
  implements: System.Collections.IEnumerable
val fromTriple : ((int * int * int) list -> IBitmap * IBitmap * IBitmap)
val xs : (int * int * int) list

  type: (int * int * int) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int * int * int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int * int * int>
  implements: System.Collections.IEnumerable
val convert : (int list -> IBitmap)
type Paint =
  class
    new : aarrggbb:int -> Paint
    member Color : int
    static member Black : Paint
    static member Blue : Paint
    static member Transparent : Paint
    static member White : Paint
    static member Yellow : Paint
  end

Full name: Snippet.Paint
property Paint.Blue: Paint
Multiple items
module List

from Microsoft.FSharp.Collections

--------------------

type List<'T> =
  | ( [] )
  | ( :: ) of 'T * 'T list
  with
    interface System.Collections.IEnumerable
    interface System.Collections.Generic.IEnumerable<'T>
    member Head : 'T
    member IsEmpty : bool
    member Item : index:int -> 'T with get
    member Length : int
    member Tail : 'T list
    static member Cons : head:'T * tail:'T list -> 'T list
    static member Empty : 'T list
  end

Full name: Microsoft.FSharp.Collections.List<_>

  type: List<'T>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<'T>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<'T>
  implements: System.Collections.IEnumerable
val foldBack : ('T -> 'State -> 'State) -> 'T list -> 'State -> 'State

Full name: Microsoft.FSharp.Collections.List.foldBack
val l : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val m : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val r : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val ls : int list

  type: int list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int>
  implements: System.Collections.IEnumerable
val ms : int list

  type: int list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int>
  implements: System.Collections.IEnumerable
val rs : int list

  type: int list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int>
  implements: System.Collections.IEnumerable
val l : int list

  type: int list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int>
  implements: System.Collections.IEnumerable
val m : int list

  type: int list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int>
  implements: System.Collections.IEnumerable
val r : int list

  type: int list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int>
  implements: System.Collections.IEnumerable
val tl : IBitmap
val top : IBitmap
val tr : IBitmap
val left : IBitmap
val blank : IBitmap
val right : IBitmap
val bl : IBitmap
val bottom : IBitmap
val br : IBitmap
val door : IBitmap
property Paint.White: Paint
val pill : IBitmap
property Paint.Yellow: Paint
val power : IBitmap
val toTile : (char -> IBitmap)
val c : char

  type: char
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IComparable<char>
  implements: System.IEquatable<char>
  inherits: System.ValueType
val isWall : (char -> bool)
val isEdible : (char -> bool)
val mutable totalDots : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val walls : ILayer

  type: ILayer
  inherits: IContent
abstract member IScene.AddLayer : unit -> ILayer
val lines : string []

  type: string []
  implements: System.ICloneable
  implements: System.Collections.IList
  implements: System.Collections.ICollection
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.IStructuralEquatable
  implements: System.Collections.Generic.IList<string>
  implements: System.Collections.Generic.ICollection<string>
  implements: seq<string>
  implements: System.Collections.IEnumerable
  inherits: System.Array
Multiple overloads
System.String.Split(separator: char []) : string []
System.String.Split(separator: string [], options: System.StringSplitOptions) : string []
System.String.Split(separator: char [], options: System.StringSplitOptions) : string []
System.String.Split(separator: char [], count: int) : string []
System.String.Split(separator: string [], count: int, options: System.StringSplitOptions) : string []
System.String.Split(separator: char [], count: int, options: System.StringSplitOptions) : string []
val tiles : IContent [] []

  type: IContent [] []
  implements: System.ICloneable
  implements: System.Collections.IList
  implements: System.Collections.ICollection
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.IStructuralEquatable
  implements: System.Collections.Generic.IList<IContent []>
  implements: System.Collections.Generic.ICollection<IContent []>
  implements: seq<IContent []>
  implements: System.Collections.IEnumerable
  inherits: System.Array
module Array

from Microsoft.FSharp.Collections
val mapi : (int -> 'T -> 'U) -> 'T [] -> 'U []

Full name: Microsoft.FSharp.Collections.Array.mapi
val line : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
Multiple overloads
System.String.ToCharArray() : char []
System.String.ToCharArray(startIndex: int, length: int) : char []
val item : char

  type: char
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IComparable<char>
  implements: System.IEquatable<char>
  inherits: System.ValueType
val tile : IContent
property ILayer.Contents: IContents
val ignore : 'T -> unit

Full name: Microsoft.FSharp.Core.Operators.ignore
val route_home : int [] []

  type: int [] []
  implements: System.ICloneable
  implements: System.Collections.IList
  implements: System.Collections.ICollection
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.IStructuralEquatable
  implements: System.Collections.Generic.IList<int []>
  implements: System.Collections.Generic.ICollection<int []>
  implements: seq<int []>
  implements: System.Collections.IEnumerable
  inherits: System.Array
val numbers : int [] []

  type: int [] []
  implements: System.ICloneable
  implements: System.Collections.IList
  implements: System.Collections.ICollection
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.IStructuralEquatable
  implements: System.Collections.Generic.IList<int []>
  implements: System.Collections.Generic.ICollection<int []>
  implements: seq<int []>
  implements: System.Collections.IEnumerable
  inherits: System.Array
val map : ('T -> 'U) -> 'T [] -> 'U []

Full name: Microsoft.FSharp.Collections.Array.map
namespace System
type Int32 =
  struct
    member CompareTo : obj -> int
    member CompareTo : int -> int
    member Equals : obj -> bool
    member Equals : int -> bool
    member GetHashCode : unit -> int
    member GetTypeCode : unit -> System.TypeCode
    member ToString : unit -> string
    member ToString : string -> string
    member ToString : System.IFormatProvider -> string
    member ToString : string * System.IFormatProvider -> string
    static val MaxValue : int
    static val MinValue : int
    static member Parse : string -> int
    static member Parse : string * System.Globalization.NumberStyles -> int
    static member Parse : string * System.IFormatProvider -> int
    static member Parse : string * System.Globalization.NumberStyles * System.IFormatProvider -> int
    static member TryParse : string * int -> bool
    static member TryParse : string * System.Globalization.NumberStyles * System.IFormatProvider * int -> bool
  end

Full name: System.Int32

  type: System.Int32
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
field System.Int32.MaxValue = 2147483647
val canFill : (int * int -> bool)
property System.Array.Length: int
val fill : (int -> int * int -> unit)
val n : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val flood : (int * int -> bool) -> (int -> int * int -> unit) -> int * int -> unit

Full name: Snippet.Algorithm.flood
val tileAt : (int -> int -> char)
val isWallAt : (int * int -> bool)
val p : IContent
val pu : IContent * IContent
val pd : IContent * IContent
val pl : IContent * IContent
val pr : IContent * IContent
val mutable finished : bool

  type: bool
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IComparable<bool>
  implements: System.IEquatable<bool>
  inherits: System.ValueType
val mutable lives : IContent list

  type: IContent list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<IContent>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<IContent>
  implements: System.Collections.IEnumerable
val iteri : (int -> 'T -> unit) -> 'T list -> unit

Full name: Microsoft.FSharp.Collections.List.iteri
val i : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val life : IContent
val rev : 'T list -> 'T list

Full name: Microsoft.FSharp.Collections.List.rev
val decLives : (unit -> unit)
val text : ITextContent

  type: ITextContent
  inherits: IContent
val x : IContent
val xs : IContent list

  type: IContent list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<IContent>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<IContent>
  implements: System.Collections.IEnumerable
val ghost_starts : Ghost list

  type: Ghost list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Ghost>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Ghost>
  implements: System.Collections.IEnumerable
val map : ('T -> 'U) -> 'T list -> 'U list

Full name: Microsoft.FSharp.Collections.List.map
val color : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
val v : int * int
val blue : IContent
val eyes : IContent * IContent * IContent * IContent
val body : IContent * IContent * IContent * IContent
val image : IContent
Ghost.X: int
Ghost.Y: int
Ghost.V: int * int
val mutable ghosts : Ghost list

  type: Ghost list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Ghost>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Ghost>
  implements: System.Collections.IEnumerable
val iter : ('T -> unit) -> 'T list -> unit

Full name: Microsoft.FSharp.Collections.List.iter
val ghost : Ghost

  type: Ghost
  implements: System.IEquatable<Ghost>
  implements: System.Collections.IStructuralEquatable
Ghost.Image: IContent
val mutable score : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val mutable bonus : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val mutable bonuses : (int * IContent) list

  type: (int * IContent) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int * IContent>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int * IContent>
  implements: System.Collections.IEnumerable
val x : int ref

  type: int ref
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Ref<int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
Multiple items
val ref : 'T -> 'T ref

Full name: Microsoft.FSharp.Core.Operators.ref

--------------------

type 'T ref = Ref<'T>

Full name: Microsoft.FSharp.Core.ref<_>

  type: 'T ref
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Ref<'T>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val y : int ref

  type: int ref
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Ref<int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val v : (int * int) ref

  type: (int * int) ref
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Ref<int * int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val pacman : IContent ref

  type: IContent ref
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Ref<IContent>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val mutable powerCount : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val noWall : (int * int -> int * int -> bool)
val ex : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val ey : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val bx : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val by : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
Multiple items
val int : 'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------

type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

  type: int<'Measure>
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IFormattable
  implements: System.IComparable<int<'Measure>>
  implements: System.IEquatable<int<'Measure>>
  inherits: System.ValueType


--------------------

type int = int32

Full name: Microsoft.FSharp.Core.int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val not : bool -> bool

Full name: Microsoft.FSharp.Core.Operators.not
val fillValue : (int * int -> int * int -> int)
val verticallyAligned : (int * 'a -> bool)
val y : 'a
val horizontallyAligned : ('a * int -> bool)
val x : 'a
val canGoUp : (int * int -> bool)
val canGoDown : (int * int -> bool)
val canGoLeft : (int * int -> bool)
val canGoRight : (int * int -> bool)
val fillUp : (int * int -> int)
val fillDown : (int * int -> int)
val fillLeft : (int * int -> int)
val fillRight : (int * int -> int)
val go : (int * int -> int * int -> int * int)
val dx : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val dy : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val newGhosts : (unit -> Ghost list)
val u : IContent
val d : IContent
val l : IContent
val r : IContent
Ghost.Body: IContent * IContent * IContent * IContent
val u' : IContent
val d' : IContent
val l' : IContent
val r' : IContent
Ghost.Eyes: IContent * IContent * IContent * IContent
val face : IContent
val eye : IContent
val canMove : bool

  type: bool
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IComparable<bool>
  implements: System.IEquatable<bool>
  inherits: System.ValueType
val invalidOp : string -> 'T

Full name: Microsoft.FSharp.Core.Operators.invalidOp
val isBackwards : (int * int -> bool)
val a : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val b : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val directions : ((int * int) * int) list

  type: ((int * int) * int) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<(int * int) * int>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<(int * int) * int>
  implements: System.Collections.IEnumerable
val directions : seq<int * int>

  type: seq<int * int>
  inherits: System.Collections.IEnumerable
Ghost.IsReturning: bool
Multiple items
val sortBy : ('a -> 'b) -> seq<'a> -> seq<'a>

Full name: Snippet.Seq.sortBy

--------------------

val sortBy : ('T -> 'Key) -> seq<'T> -> seq<'T> (requires comparison)

Full name: Microsoft.FSharp.Collections.Seq.sortBy
val map : ('T -> 'U) -> seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.map
val unsort : seq<'a> -> seq<'a>

Full name: Snippet.Seq.unsort
val head : seq<'T> -> 'T

Full name: Microsoft.FSharp.Collections.Seq.head
val returning : bool

  type: bool
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IComparable<bool>
  implements: System.IEquatable<bool>
  inherits: System.ValueType
Ghost.Blue: IContent
val mutable ghostCounter : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val updateGhosts : (unit -> unit)
val modulus : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val updatePacman : (unit -> unit)
val inputs : (bool * (int * int) * (IContent * IContent)) list

  type: (bool * (int * int) * (IContent * IContent)) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<bool * (int * int) * (IContent * IContent)>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<bool * (int * int) * (IContent * IContent)>
  implements: System.Collections.IEnumerable
property IInput.IsUp: bool
property IInput.IsDown: bool
property IInput.IsLeft: bool
property IInput.IsRight: bool
val move : ((int * int) * (IContent * IContent) -> unit)
val d1 : IContent
val d2 : IContent
val x' : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val y' : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val availableDirections : seq<(int * int) * (IContent * IContent)>

  type: seq<(int * int) * (IContent * IContent)>
  inherits: System.Collections.IEnumerable
val filter : ('T -> bool) -> 'T list -> 'T list

Full name: Microsoft.FSharp.Collections.List.filter
val can : bool

  type: bool
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IComparable<bool>
  implements: System.IEquatable<bool>
  inherits: System.ValueType
val f : IContent * IContent
val v' : int * int
val length : seq<'T> -> int

Full name: Microsoft.FSharp.Collections.Seq.length
val goForward : bool * (IContent * IContent)
property List.Length: int
val tx : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val ty : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val updatePower : (unit -> unit)
abstract member IContent.SetOpacity : float -> unit
val mutable flashCount : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val updateFlash : (unit -> unit)
val touchGhosts : (unit -> Ghost list)
val px : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val py : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val handleTouching : (unit -> unit)
val touching : Ghost list

  type: Ghost list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Ghost>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Ghost>
  implements: System.Collections.IEnumerable
val mapi : (int -> 'T -> 'U) -> 'T list -> 'U list

Full name: Microsoft.FSharp.Collections.List.mapi
val exists : ('T -> bool) -> 'T list -> bool

Full name: Microsoft.FSharp.Collections.List.exists
val pown : 'T -> int -> 'T (requires member get_One and member ( * ) and member ( / ))

Full name: Microsoft.FSharp.Core.Operators.pown
val b : IContent
val min : 'T -> 'T -> 'T (requires comparison)

Full name: Microsoft.FSharp.Core.Operators.min
val updateBonuses : (unit -> unit)
val removals : (int * IContent) list

  type: (int * IContent) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int * IContent>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int * IContent>
  implements: System.Collections.IEnumerable
val remainders : (int * IContent) list

  type: (int * IContent) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<int * IContent>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<int * IContent>
  implements: System.Collections.IEnumerable
val count : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val partition : ('T -> bool) -> 'T list -> 'T list * 'T list

Full name: Microsoft.FSharp.Collections.List.partition
val p1 : ITextContent

  type: ITextContent
  inherits: IContent
val s1 : ITextContent

  type: ITextContent
  inherits: IContent
val updateScore : (unit -> unit)
abstract member ITextContent.SetText : string -> unit
val sprintf : Printf.StringFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.sprintf
val update : (unit -> unit)
val this : Game
member Game.Update : unit -> unit

Full name: Snippet.Game.Update
New Version
Previous Version

More information

Link: http://fssnip.net/cZ
Posted: 10 months ago
Author: Phillip Trelford (website)
Tags: Game, Silverlight

Hosting

Web site is kindly hosted by DEVSENSE s.r.o.

F# Snippets

How does the formatting of F# code work? You can read more about F# formatting tool.

License

The content on this web site is licensed under the MS-PL license. By posting new snippets to the web site, you agree to make them available under this license.

Credits

This web page was created by Tomas Petricek (blog, twitter). I'm looking for suggestions and helping hands! The web is written mostly in F# using ASP.NET MVC.