Simo Råman

Building Roguelike in F#

Tue, 19 May 2015 05:15:00 -1200

I know many people who started programming because they wanted to write a game of their own. I myself had never done game programming but after I ran into articles about programming a roguelike in Haskell I decided to give it a try using F#.

First I wanted to get hero to move around on map.

These are the types I came up with:

namespace SharpRogue
module Types =
    type Coordinate = { x:int; y:int; }

    type Hero = {
        currentPosition : Coordinate;
        oldPosition : Coordinate;
    }

    type MapTile = {
        coordinate : Coordinate;
        tile : char;
    }

    type World = {
        tiles : MapTile list
        hero : Hero
    }

    type Input = 
        Up 
        | Down
        | Left
        | Right
        | Open
        | Exit

Game World consists of MapTiles and Hero. MapTile has a coordinate in the world and a char that symbolises content of the tile, for example symbol for wall is '#'. Hero has data of it's location(currentPosition) and location on previous turn(oldPosition). Input is a discriminated union of the possible inputs from the player.

// Graphics.fs
let hideCursor() = System.Console.SetCursorPosition(0,0)

let drawHero (hero:Hero, world:MapTile list) = 
    System.Console.
        SetCursorPosition(hero.currentPosition.x, hero.currentPosition.y)
    System.Console.Write '@'
    let found = List.find (Utils.findTile hero.oldPosition) world
    System.Console.
        SetCursorPosition(hero.oldPosition.x, hero.oldPosition.y)
    found.tile |> System.Console.Write
    hideCursor()

let drawTile (tile:MapTile) = 
    System.Console.
        SetCursorPosition(tile.coordinate.x, tile.coordinate.y)
    System.Console.Write tile.tile

let drawWorld world = 
    System.Console.Clear()
    List.map (fun x -> drawTile(x)) world |> ignore

let drawOpenDoor coordinate =
    System.Console.SetCursorPosition(coordinate.x, coordinate.y)
    System.Console.Write '-'
    hideCursor()

Since my roguelike is basically a console app the "graphics" module deals with writing out chars on the correct coordinate in the console. HideCursor-function is used to set cursor on the upper left corner of screen. Otherwise it will stay where a character has been written last. drawHero draws the @-character representing hero in currentPosition of hero record. Original tile from world record will replace @-character in oldPosition of hero. Originally I reprinted whole map after every move, but that caused screen to flicker.

The game logic is located in the Program.fs-file. Starting at the main function:

[<EntryPoint>]
let main argv = 
    generateCoordinates |> drawWorld
    let world = {
        hero = { 
                oldPosition = {x = 1; y = 1;}; 
                currentPosition = {x = 1; y = 1;}; 
        }; 
        tiles = generateCoordinates
    }
    gameLoop world
    0 // return an integer exit code

GenerateCoordinates breaks level map into coordinates and tiles. World initialized with hero starting from the top left corner.

GameLoop is a recursive function that draws hero, gets player input and calls gameLoop again with new state of the world.

let rec gameLoop world =
    drawHero (world.hero, world.tiles)
    let input = getInput()
    match input with
        | Exit -> ()
        | Open -> openDoor world.hero world |> gameLoop
        | _ -> {world with hero = (move input world);} |> gameLoop

Move returns hero with updated coordinates. Movement is allowed if the wanted location is not a wall(#) or a closed door(+). OpenDoor replaces closed door(+) located next to the hero in the given direction with an open door(-).

let move direction world = 
    let hero = world.hero
    let newCoordinates = getNextCoordinate hero direction
    let found = List.find (Utils.findTile newCoordinates) world.tiles   
    match found.tile with
        | '#' -> hero
        | '+' -> hero         
        | _ -> {hero with currentPosition = newCoordinates; 
                oldPosition = hero.currentPosition} 


let openDoor hero world = 
    let direction = getInput()
    let coordinate = getNextCoordinate hero direction
    let tile = List.find (Utils.findTile coordinate) world.tiles
    if tile.tile = '+' then drawOpenDoor tile.coordinate
    let newTiles = List.map 
        (fun x -> 
            if x.coordinate = coordinate then { x with tile = '-'} 
            else x) world.tiles
    {world with hero = hero; tiles = newTiles}

Here is the amazing result!

Not quite Nethack yet, but we'll see what features future brings. The codes for SharpRogue can be found on GitHub.

Generating music in F# part 3: Note values

Sat, 04 Apr 2015 22:36:00 -1200

Previous posts in series:
Part 1
Part 2

After last post the program can generate melodies using Markov chains generated from seed data. Next important aspect of a catchy melody is note value. Note value means a relative duration of a note.

Just like notes note values are modelled as a type:

type value =
    | Full
    | Half
    | Quarter
    | Eighth

The actual duration of a note value in seconds is relative to tempo. A map of durations for values can be created using this function:

let time beatsPerMinute =
    let quarterLength = 60. / beatsPerMinute     
    Map.ofList [
    (Eighth, 0.5 * quarterLength); 
    (Quarter, quarterLength); 
    (Half, 2. * quarterLength);
    (Full, 4. * quarterLength)]

Beats per minute(bpm) means the amount of quarter notes in a minute. Dividing minute(60 seconds) with bpm yields length of quarter note in seconds. Other time values can be counted from that quarter note value.

I wanted some more complex seed data:

let yesterday = 
    [(G, Eighth); (F, Eighth); (F, Half);
    (A, Eighth); (B, Eighth);(Cis, Eighth); (D, Eighth); (E, Eighth);(F, Eighth);
    (E, Eighth); (D, Eighth); (D, Half);
    (D, Eighth); (D, Eighth); (C, Eighth); (Ais, Eighth); (A, Eighth); (G, Eighth);
    (Ais, Quarter); (A, Eighth); (A, Quarter); (G, Quarter);
    (F, Quarter); (A, Eighth); (G, Eighth); (G, Quarter); (D, Eighth);
    (F, Quarter); (A, Eighth); (A, Eighth); (A, Half);]

Melody is now represented as list of tuples of note and value. Both types will have their own Markov chain structure

let createMarkovChains data =
    data
    |> Seq.windowed 2
    |> Seq.groupBy (fun x -> x.[0])
    |> Seq.map (fun x -> 
           (fst x, 
            x
            |> snd
            |> Seq.map (Seq.nth 1)))
    |> Map.ofSeq

let noteData = 
    yesterday
    |> List.map(fst)
    |> createMarkovChains

let timingsData =
    yesterday
    |> List.map(snd)
    |> createMarkovChains

Creation of random sequence is not dependent of the type of item in this case. Functions can be made more generic by removing type declarations referring to note-type.

let getNextElement (random : System.Random) (data : Map<_,_>) currentElement = 
    let nextSet = data.[currentElement]
    let nextElementIndex = random.Next(0, Seq.length nextSet)
    nextSet
    |> Seq.skip nextElementIndex
    |> Seq.head

let r = System.Random()
let nextElementFromData x y = getNextElement r x y

let rec randomSequence wantedLength seedData currentElement (acc : 'a list) = 
    if acc.Length = wantedLength then acc
    else 
        let nextElement = nextElementFromData seedData currentElement
        randomSequence wantedLength seedData nextElement (acc @ [ nextElement ])

Here is the main now:

[<EntryPoint>]
let main argv = 
    let availableNotes = 
        noteData |> Map.toSeq |> Seq.map fst |> List.ofSeq
    let firstNote = availableNotes.[r.Next(0, availableNotes.Length)]
    let melody = randomSequence 24 noteData firstNote [ firstNote ] 
                    |> List.map(fun x -> frequency.[x])

    let timingsForTempo = (time 120.)
    let availableTimes = 
        timingsData |> Map.toSeq |> Seq.map fst |> List.ofSeq
    let firstTime = availableTimes.[r.Next(0, availableTimes.Length)]
    let timings = randomSequence 24 timingsData firstTime [ firstTime ] 
                    |> List.map(fun x -> timingsForTempo.[x])

    List.zip melody timings |> Synth.writeMelody
    0

Random sequences are created for both notes and time values. Then they are zipped into list of tuples and written to wav-file.

Full source on GitHub. Here is an example output:

Generating music with F# part 2: Markov chains

Sun, 29 Mar 2015 00:14:37 -1200

Continuing from the previous post.

To make melody generation more interesting I decided to try applying statistical process called Markov chain. In the context of this post by Markov chain I mean that the next state of the system is not completely random but next states have different probabilities that depend on the current state.

There is a Finnish children's song and a Swedish drinking song called "Ukko-Nooa" or "Gubben Noak" that has a simple melody that goes like this:

let nooaMelody =
    [C; C; C; E; D; D; D; F; E; E; D; D; C;
    E; E; E; E; G; F; D; D; D; D; F; E;
    C; C; C; E; D; D; D; F; E; E; D; D; C;]

We create a map of notes to sequence of notes. Sequence consists of notes that can follow the note that is used as key.

let noteData = 
    nooaMelody
    |> Seq.windowed 2
    |> Seq.groupBy (fun (x : note []) -> x.[0])
    |> Seq.map (fun x -> 
           (fst x, 
            x
            |> snd
            |> Seq.map (Seq.nth 1)))
    |> Map.ofSeq

This is how to get next random note based on current note.

let getNextNote (random : System.Random) (data : Map<note,seq<note>>) (currentNote : note) = 
    let nextSet : seq<note> = data.[currentNote]
    let nextNoteIndex = random.Next(0, Seq.length nextSet)
    nextSet
    |> Seq.skip nextNoteIndex
    |> Seq.head

The more times a note is contained in the sequence where currentNote acts as a key, the more likely it is to become next note.

Rest of the program looks like this:

let r = System.Random()
let nextNoteFromData : Map<note,seq<note>> -> note -> note = getNextNote r

let rec randomMelody wantedLength noteData currentNote (melody : note list) = 
    if melody.Length = wantedLength then melody
    else 
        let nextNote = nextNoteFromData noteData currentNote
        randomMelody wantedLength noteData nextNote (melody @ [nextNote])

[<EntryPoint>]
let main argv = 
    let availableNotes = 
        noteData |> Map.toSeq |> Seq.map fst |> List.ofSeq
    let firstNote = availableNotes.[r.Next(0, availableNotes.Length)]
    randomMelody 8 noteData firstNote [ firstNote ]
    |> Seq.map (fun x -> frequency.[x])
    |> Synth.writeMelody
    0 // return an integer exit code

nextNoteFromData is partially applied function of getNextNote that can be used without passing an instance of System.Random along. randomMelody recursively creates list of notes until given length is achieved.

That's it! Here is an example of the output. Much better than the completely random version from previous post.

The full source code is on GitHub