1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

open System
open System.Diagnostics

open System.Threading

    // State Monad
    type State<'s,'a> = State of ('s -> 'a * 's)
    type StateBuilder<'s>() =
      member x.Return v : State<'s,_> = State(fun s -> v,s)
      member x.Bind(State v, f) : State<'s,_> =
        State(fun s ->
          let (a,s) = v s
          let (State v') = f a
          v' s)
    let withState<'s> = StateBuilder<'s>()

    let getState = State(fun s -> s,s)
    let putState v = State(fun _ -> (),v)
    let runState (State f) init = f init
    // /State Monad

    // Types
    type Position = { x:int ; y:int } 
    type Delta = { dx:int ; dy:int } 
    type World = { ball:(Position * Delta); user:Position}

    let _ = 

        let updatePosition (delta:Delta) = 
            withState {
                let! oldPosition = getState
                let newPosition = { Position.x = oldPosition.x + delta.dx; Position.y = oldPosition.y + delta.dy }
                do! putState newPosition
                return "pos updated"
            }

        let DetermineDelta (x:ConsoleKeyInfo) = 
            match x.Key with
                | ConsoleKey.UpArrow -> { Delta.dx = 0 ; Delta.dy = -1} 
                | ConsoleKey.DownArrow -> { Delta.dx = 0 ; Delta.dy = 1}
                | ConsoleKey.LeftArrow -> { Delta.dx = -1 ; Delta.dy = 0}
                | ConsoleKey.RightArrow -> { Delta.dx = 1 ; Delta.dy = 0} 
                | _ -> { Delta.dx = 0 ; Delta.dy = 0}

        let updateUserPosition user key =
            let delta = DetermineDelta key
            // let newPosition = snd (runState (updatePosition delta) user)     // moanad
            let newPosition = { x = user.x + delta.dx; y = user.y + delta.dy }  // non-moanad

            newPosition
            
        let updateBallPosition (positionDelta:Position*Delta) =
            let position = fst positionDelta
            let delta = snd positionDelta
            // let newPosition = snd (runState (updatePosition delta) position)         // moanad
            let newPosition = { x = position.x + delta.dx; y = position.y + delta.dy }  // non-moanad

            // Bounds check X
            if newPosition.x = Console.WindowWidth || newPosition.x = 0 then
                let newDelta = { Delta.dx = -1 * delta.dx; Delta.dy = delta.dy }
                // let correctedPosition = snd (runState (updatePosition newDelta) position)            // moanad
                let correctedPosition = { x = position.x + newDelta.dx; y = position.y + newDelta.dy }  // non-moanad
                (correctedPosition,newDelta)

            else // Bounds check Y
                if newPosition.y = Console.WindowHeight || newPosition.y = 0 then
                    let newDelta = { Delta.dx = delta.dx; Delta.dy = -1 * delta.dy }
                    // let correctedPosition = snd (runState (updatePosition newDelta) position)            // moanad
                    let correctedPosition = { x = position.x + newDelta.dx; y = position.y + newDelta.dy }  // non-moanad
                    (correctedPosition,newDelta)
                else
                    (newPosition,delta) 

        let world = { user = { Position.x = 10 ; Position.y = 10 }; ball = ({ Position.x = 15; Position.y = 15}, { Delta.dx = 1; Delta.dy = 1})}

        let drawBall (old:Position*Delta) (nu:Position*Delta) =
            let oldPosition = fst old
            let newPosition = fst nu
            Console.SetCursorPosition(oldPosition.x, oldPosition.y)
            Console.Write " "
            Console.SetCursorPosition(newPosition.x, newPosition.y)
            Console.Write "*"

        let drawUser (strPos:Option<ConsoleKeyInfo>*Position) = 
            let key = fst strPos
            let pos = snd strPos

            if key.IsSome then
                Console.SetCursorPosition(pos.x, pos.y)
                Console.Write (Option.get key).KeyChar

        let rec gameLoop (world:World) (pollForKey:(unit -> Option<ConsoleKeyInfo>)) =

            // poll keyboard
            // event ? no event
            // event: handle exit, user move & drop, move ball, c/det
            // no event: move ball, c/det

            Thread.Sleep 100
            let theKey = pollForKey()

            if Option.isSome theKey && theKey.Value.Key = ConsoleKey.Escape then
                Console.WriteLine "bye bye..."
                ()
            else
                let updatedBall = updateBallPosition world.ball

                let newWorld = match theKey with
                    | None -> { user = world.user; ball = updatedBall }
                    | Some(key) -> { user = (updateUserPosition world.user key); ball = updatedBall }

                drawBall world.ball newWorld.ball
                drawUser (theKey, newWorld.user)
                
                gameLoop newWorld pollForKey

        (gameLoop world Input.pollKeys)