Geek Answers Handbook

Why does the use of Observable.merge matter in order?

I am trying to write a basic "game loop" using Observables in F #. Basically, I conceptualize the main stream of input events when two streams are combined together: pressing user keys (only the keyboard is used to start the game) and regular ticks of the game (say, 60 times per second).

My problem, apparently, is related to the fact that one of the observed sequences, i.e. ticks is also a loop that calls DispatchEvents () on the window, allowing it to handle its inputs and events with the fire keys pressed, so one event stream is actually caused by others, if that makes sense. Here is the code:

open System;
open System.IO
open SFML.Window
open SFML.Graphics
open System.Reactive
open System.Reactive.Linq
open System.Diagnostics

type InputEvent =
| Tick of TimeSpan
| KeyPressed of Keyboard.Key

[<EntryPoint;STAThread>]
let main _ = 

    use window = new RenderWindow(VideoMode(640u, 480u), "GameWindow")
    window.SetVerticalSyncEnabled(true)

    let displayStream = 
        Observable.Create(
            fun (observer:IObserver<TimeSpan>) -> 
                let sw = Stopwatch.StartNew()
                while (window.IsOpen()) do
                    window.DispatchEvents() // this calls the KeyPressed event synchronously
                    window.Display() // this blocks until the next vertical sync
                    window.Clear()
                    observer.OnNext sw.Elapsed
                    sw.Restart()
                observer.OnCompleted();
                { new IDisposable with member this.Dispose() = ()})    

    let onDisplay elapsedTime = 
        // draw game: code elided

    let inputEvents = Observable.merge 
                          (window.KeyPressed |> Observable.map (fun key -> KeyPressed(key.Code)))
                          (displayStream |> Observable.map (fun t -> Tick(t)))
    use subscription = 
        inputEvents.Subscribe(fun inputEvent -> match inputEvent with
                                                | Tick(t) -> onDisplay(t)
                                                | KeyPressed(key) -> printfn "%A" key)

    0

This works, however, if I reorder the parameters in Observable.merge:

    let inputEvents = Observable.merge 
                          (displayStream |> Observable.map (fun t -> Tick(t)))
                          (window.KeyPressed |> Observable.map (fun key -> KeyPressed(key.Code)))

( onDisplay), KeyPressed, . ?

( , SFML, ).

+4
1

, :

firstStream.Subscribe(...);
secondStream.Subscribe(...);

, Observable.create, . , merge , displayStream. , displayStream , KeyPressed. , .

displayStream . Subscribe .

, , displayStream - , . Subject displayStream. , , " ", , displayStream, OnNext .

+6

More articles:


All Articles