Back to Questions
1.3k
views3
comments
Simple game in F#: Would need some advice on functional design
f#functional

Hello, everyone!

I am in the process of learning F# and am still struggling with many basic concepts of functional programming.
So as a practice, I wrote a pathetic little game and tried to keep it as 'functional' as I could. If some of you more experienced programmers could take a quick look at it, and maybe tell me how one could improve the code, that would be very nice.

I would be especially interested in your take on managing state in F#.
I wrapped all state into one type (the "World"-type) and pass this around the various functions as an argument - an idea I got from Robert Pickering's Ant Colony example (though I don't know, if I understood the idea right)

As you can see without a doubt, I am still a beginner and welcome any and all tips!
(I am aware that you are all very busy so I hope asking advice about a complete program is not against etiquette)

Anyway, here comes the code:
(Gameplay: Move around with the arrow-keys, try to stay away from the monsters, hehe.)

Thank you,
Bernhard
------------------------------------------------------------

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
118
119
120
121
122

#light


open System


// Constants
let mapX = 40
let mapY = 20
let monsterCount = 35

type GameState = Running | Killed


// Entity, used for player and monsters
type Entity =
    { X: int; Y: int;}
    
    // Move the entity
    member p.Move(dx,dy) =
        // Perform boundary checks
        let mx = if (p.X + dx <= 0)||(p.X + dx > mapX-1) then 0 else dx 
        let my = if (p.Y + dy <= 0)||(p.Y + dy > mapY-1) then 0 else dy
        {X = p.X + mx ; Y = p.Y + my}


// The World     
type World =
    { Player: Entity;
      Monsters: list<Entity>
      gameState: GameState
      turnCount: int }
     
let rand = Random()


// Initialize the map:
let initWorld() =
    
    // Hide the cursor, size console buffer and window
    Console.CursorVisible <- false
    Console.SetWindowSize(mapX+2, mapY+2)
    Console.SetBufferSize(mapX+2, mapY+2)
    
    // Put player in the center of the map
    let player = {new Entity with X = mapX/2 and Y = mapY/2}
    
    // Create random monster locations
    let monsters = [for i in 0 .. monsterCount-1 -> ({X=rand.Next(1, mapX) ; Y=rand.Next(1, mapY)})]
    
    {Player = player ; Monsters = monsters ; gameState = Running ; turnCount = 0}


// Process player movement
let processPlayer (world: World) =
    let key = Console.ReadKey(true).Key
    match key with
    |ConsoleKey.UpArrow -> world.Player.Move(0,-1)
    |ConsoleKey.DownArrow -> world.Player.Move(0,1)
    |ConsoleKey.RightArrow -> world.Player.Move(1,0)
    |ConsoleKey.LeftArrow -> world.Player.Move(-1,0)
    |_ -> world.Player.Move(0,0)


// Move each monster in a random direction
let processMonsters (world: World) =
    world.Monsters |> List.map (fun m -> m.Move(rand.Next(-1,2),rand.Next(-1,2)))
    
// Create new world with updated player and monsters
let updateWorld (world: World) =
    let player = processPlayer world
    let monsters = processMonsters world
    
    // Test for collision
    let newGameState : GameState =
        let hitList = monsters |> List.filter(fun m -> (m.X = player.X && m.Y = player.Y))
        if (hitList.Length = 0) then Running else Killed
    {Player = player ; Monsters = monsters ; gameState = newGameState ; turnCount = world.turnCount + 1}


// Draw a character at position x y
let drawChar x y col (c:char)  = 
    Console.SetCursorPosition (x,y)
    Console.ForegroundColor <- col
    Console.Write(c)
        
// Draw the game world      
let presentWorld (world: World) =

    Console.Clear()
    
    // Draw boundaries
    let col = ConsoleColor.DarkGray
    for i = 0 to mapX do
        drawChar i 0 col '#'
        drawChar i mapY col '#'
    for i = 0 to mapY do
        drawChar 0 i col '#'
        drawChar mapX i col '#'
        
    // Draw the player and the monsters         
    drawChar world.Player.X world.Player.Y ConsoleColor.White '@'
    world.Monsters |> List.iter (fun i -> drawChar i.X i.Y ConsoleColor.Red 'm')


// The game loop
let rec gameLoop (currentWorld: World) =

    presentWorld currentWorld
    
    match currentWorld.gameState with
    |Running -> let newWorld = updateWorld currentWorld
                gameLoop newWorld
    |Killed ->  Console.Clear()
                printfn "You survived for %d turns." currentWorld.turnCount 


// Initialize world and start up game loop
let initialWorld = initWorld()
gameLoop(initialWorld)
.

haha. it's cute. i never made a console game before. so that's how you make them

i'm learning F# myself so i took this as an exercise. the spec helped out a lot: [link:research.microsoft.com]

one thing i'm not sure of is whether or not it's necessary to closure a function within another function, or if the compiler automatically abstracts functions that don't change. eg:

1
2
3
4
5

let add1 =
    let add x y = x + y


    fun v -> add v 1

vs

1
2
3
4
5
6

let add1 v =


    let add x y = x + y

    add v 1

does the compiler notice that "add" is fully free and can be abstracted? i'm guessing it does. if so the former form isn't necessary, but it's a good idiom anyway in cases where you're using something expensive for the function but don't want to pollute the enclosing scope with it:

1
2
3
4
5

let fn =
    let expensive_val = expensive_calculation blah blah


    fun arg -> cheap_calculation expensive_val

anyway here's the code. you'll notice i'm not a fan of OO, but it should give you some ideas about the sorts of things you can do:

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

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

#light


open System


let mapX = 40
let mapY = 20
let monsterCount = 35


Console.CursorVisible <- false
Console.SetWindowSize( mapX + 2, mapY + 2 )
Console.SetBufferSize( mapX + 2, mapY + 2 )


let move =
    let clamp max v =
        match v with // pat match with comparisons
        | _ when v < 1 -> 1
        | _ when v > max - 1 -> max - 1
        | _ -> v


    fun (x, y) (dx, dy) ->
        (clamp mapX (x + dx), clamp mapY (y + dy))


let rand: int * int -> int = Random().Next // function as value


let processPlayer player =
    let key = Console.ReadKey(true).Key;


    move player (match key with
    | ConsoleKey.UpArrow -> (0,-1)
    | ConsoleKey.DownArrow -> (0,1)
    | ConsoleKey.RightArrow -> (1,0)
    | ConsoleKey.LeftArrow -> (-1,0)
    | _ -> (0,0)) // match as expression


let processMonsters = Array.map (fun m -> move m (rand(-1,2), rand(-1,2))) // currying

   
let updateWorld player monsters =
    let player = processPlayer player
    let monsters = processMonsters monsters


    (player, monsters, monsters |> Array.exists ((=) player)) // currying


let drawChar col (c: char) (x, y) =
    Console.SetCursorPosition (x, y)
    Console.ForegroundColor <- col
    Console.Write(c)

       
let presentWorld =
    let draw = drawChar ConsoleColor.DarkGray '#' // currying


    fun player monsters ->
        Console.Clear()


        for i = 0 to mapX do
            draw (i, 0)
            draw (i, mapY)


        for i = 0 to mapY do
            draw (0, i)
            draw (mapX, i)


        drawChar ConsoleColor.White '@' player
        monsters |> Array.iter (drawChar ConsoleColor.Red 'm') // currying


let rec gameLoop player monsters turnCount =
    presentWorld player monsters
   

    match updateWorld player monsters with // pat match on return values
    | (player, monsters, false) -> gameLoop player monsters (turnCount + 1)
    | (player, monsters, true) -> Console.Clear()
                                  printfn "You survived for %d turns." turnCount


let player = (mapX / 2, mapY / 2)


let monsters = Array.init monsterCount (fun _ -> (rand(1, mapX), rand(1, mapY)))


gameLoop player monsters 1
By on 9/4/2008 5:59 AM ()

Dear amr,

thanks a lot for taking the time working with my mess and commenting your changes, I appreciate it very much.
I willl take a harder look at partial function application, as this seems to be a powerful abstraction mechanism.

Thanks again,
Bernhard

By on 9/4/2008 8:17 AM ()

Check out those blogs, there are some little F# games on it :
[link:monkeycoder.spaces.live.com]
[link:blogs.technet.com]

Russell

By on 9/10/2008 3:28 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper