PacMan

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

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

More information

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