Rollback Example

examples/rollback/Config.roc

@@ -0,0 +1,14 @@
+module [baseUrl, rollback]
+
+import Rollback
+
+baseUrl : Str
+baseUrl = "wss://matchbox-10.fly.dev"
+
+rollback : Rollback.Config
+rollback = {
+    millisPerTick: 1000 // 120,
+    maxRollbackTicks: 16,
+    tickAdvantageLimit: 10,
+    sendMostRecent: 20,
+}

examples/rollback/Input.roc

@@ -0,0 +1,82 @@
+module [Input, read, blank, toByte, fromByte]
+
+import rr.Keys exposing [Keys]
+
+Input : {
+    up : [Up, Down],
+    down : [Up, Down],
+    left : [Up, Down],
+    right : [Up, Down],
+}
+
+read : Keys -> Input
+read = \keys ->
+    up = if Keys.anyDown keys [KeyUp, KeyW] then Down else Up
+    down = if Keys.anyDown keys [KeyDown, KeyS] then Down else Up
+    left = if Keys.anyDown keys [KeyLeft, KeyA] then Down else Up
+    right = if Keys.anyDown keys [KeyRight, KeyD] then Down else Up
+
+    { up, down, left, right }
+
+blank : Input
+blank =
+    { up: Up, down: Up, left: Up, right: Up }
+
+upMask : U8
+upMask = Num.shiftLeftBy 1 0
+
+downMask : U8
+downMask = Num.shiftLeftBy 1 1
+
+leftMask : U8
+leftMask = Num.shiftLeftBy 1 2
+
+rightMask : U8
+rightMask = Num.shiftLeftBy 1 3
+
+toByte : Input -> U8
+toByte = \input ->
+    merge = \previous, direction, mask ->
+        when direction input is
+            Up -> previous
+            Down -> Num.bitwiseOr previous mask
+
+    0
+    |> merge .up upMask
+    |> merge .down downMask
+    |> merge .left leftMask
+    |> merge .right rightMask
+
+fromByte : U8 -> Input
+fromByte = \byte ->
+    lookup = \mask ->
+        if (Num.bitwiseAnd mask byte) != 0 then
+            Down
+        else
+            Up
+
+    {
+        up: lookup upMask,
+        down: lookup downMask,
+        left: lookup leftMask,
+        right: lookup rightMask,
+    }
+
+expect
+    cycled = blank |> toByte |> fromByte
+    cycled == blank
+
+expect
+    justUp = { Input.blank & up: Down }
+    cycled = justUp |> toByte |> fromByte
+    cycled == justUp
+
+expect
+    upLeft = { Input.blank & up: Down, left: Down }
+    cycled = upLeft |> toByte |> fromByte
+    cycled == upLeft
+
+expect
+    allDown = { up: Down, left: Down, right: Down, down: Down }
+    cycled = allDown |> toByte |> fromByte
+    cycled == allDown

examples/rollback/NonEmptyList.roc

@@ -0,0 +1,146 @@
+module [
+    NonEmptyList,
+    new,
+    first,
+    last,
+    findLast,
+    findFirst,
+    map,
+    toList,
+    dropNonLastIf,
+    append,
+    appendAll,
+    updateNonLast,
+    sortWith,
+    fromList,
+    walkUntil,
+]
+
+## A List guaranteed to contain at least one item
+NonEmptyList a := Inner a
+
+Inner a : {
+    list : List a,
+    last : a,
+}
+
+new : a -> NonEmptyList a
+new = \item ->
+    @NonEmptyList { list: [], last: item }
+
+first : NonEmptyList a -> a
+first = \@NonEmptyList inner ->
+    when List.first inner.list is
+        Ok f -> f
+        Err ListWasEmpty -> inner.last
+
+last : NonEmptyList a -> a
+last = \@NonEmptyList inner ->
+    inner.last
+
+findLast : NonEmptyList a, (a -> Bool) -> Result a [NotFound]
+findLast = \@NonEmptyList inner, isMatch ->
+    if isMatch inner.last then
+        Ok inner.last
+    else
+        List.findLast inner.list isMatch
+
+findFirst : NonEmptyList a, (a -> Bool) -> Result a [NotFound]
+findFirst = \@NonEmptyList inner, isMatch ->
+    when List.findFirst inner.list isMatch is
+        Ok found -> Ok found
+        Err NotFound ->
+            if isMatch inner.last then
+                Ok inner.last
+            else
+                Err NotFound
+
+map : NonEmptyList a, (a -> b) -> NonEmptyList b
+map = \@NonEmptyList inner, transform ->
+    newList = List.map inner.list transform
+    newLast = transform inner.last
+    @NonEmptyList { list: newList, last: newLast }
+
+toList : NonEmptyList a -> List a
+toList = \@NonEmptyList inner ->
+    inner.list
+    |> List.append inner.last
+
+fromList : List a -> Result (NonEmptyList a) [ListWasEmpty]
+fromList = \original ->
+    when List.last original is
+        Err ListWasEmpty -> Err ListWasEmpty
+        Ok lastItem ->
+            nonLast = List.dropLast original 1
+            Ok (@NonEmptyList { list: nonLast, last: lastItem })
+
+## Drop items from the list matching a predicate
+## But keep the last item in the list regardless of whether it passes
+dropNonLastIf : NonEmptyList a, (a -> Bool) -> NonEmptyList a
+dropNonLastIf = \@NonEmptyList inner, shouldDrop ->
+    list = List.dropIf inner.list shouldDrop
+    @NonEmptyList { inner & list }
+
+updateNonLast : NonEmptyList a, (List a -> List a) -> NonEmptyList a
+updateNonLast = \@NonEmptyList inner, update ->
+    list = update inner.list
+    @NonEmptyList { inner & list }
+
+append : NonEmptyList a, a -> NonEmptyList a
+append = \@NonEmptyList inner, item ->
+    @NonEmptyList {
+        last: item,
+        list: List.append inner.list inner.last,
+    }
+
+appendAll : NonEmptyList a, List a -> NonEmptyList a
+appendAll = \@NonEmptyList inner, items ->
+    when List.last items is
+        Err ListWasEmpty -> @NonEmptyList inner
+        Ok newLast ->
+            newNonLast = List.takeFirst items (List.len items - 1)
+            @NonEmptyList {
+                last: newLast,
+                list: List.concat inner.list newNonLast,
+            }
+
+sortWith : NonEmptyList a, (a, a -> [LT, EQ, GT]) -> NonEmptyList a
+sortWith = \nonEmpty, compare ->
+    fullList = toList nonEmpty
+    sorted = List.sortWith fullList compare
+
+    nonLast = List.dropLast sorted 1
+    lastItem =
+        when List.last sorted is
+            Err _ -> crash "unreachable"
+            Ok item -> item
+
+    @NonEmptyList { list: nonLast, last: lastItem }
+
+Step state : [Break state, Continue state]
+
+walkUntil : NonEmptyList item, (item -> Step state), (state, item -> Step state) -> state
+walkUntil = \nonEmpty, fromFirst, step ->
+    list = toList nonEmpty
+
+    WrappedState s : [Empty, SeenOne s]
+
+    wrappedInitial : WrappedState state
+    wrappedInitial = Empty
+
+    walked =
+        List.walkUntil list wrappedInitial \wrappedState, item ->
+            when wrappedState is
+                Empty ->
+                    when fromFirst item is
+                        Break s -> Break (SeenOne s)
+                        Continue s -> Continue (SeenOne s)
+
+                SeenOne state ->
+                    when step state item is
+                        Break s -> Break (SeenOne s)
+                        Continue s -> Continue (SeenOne s)
+
+    when walked is
+        Empty -> crash "unreachable"
+        SeenOne state -> state

examples/rollback/Pixel.roc

@@ -0,0 +1,80 @@
+module [
+    Pixel,
+    PixelVec,
+    add,
+    sub,
+    toVector2,
+    subpixelsPerPixel,
+    fromParts,
+    totalSubpixels,
+    fromPixels,
+]
+
+import rr.RocRay exposing [Vector2]
+
+# A 1-D integer position with a integer sub-pixel component
+# Use instead of floats to avoid rounding errors
+Pixel := { pixels : I64, subpixels : I64 }
+    implements [
+        Eq,
+        Hash,
+        Inspect { toInspector: pixelInspector },
+    ]
+
+PixelVec : { x : Pixel, y : Pixel }
+
+subpixelsPerPixel : I64
+subpixelsPerPixel = 16
+
+toVector2 : PixelVec -> Vector2
+toVector2 = \{ x: @Pixel xpx, y: @Pixel ypx } ->
+    { x: Num.toF32 xpx.pixels, y: Num.toF32 ypx.pixels }
+
+add : Pixel, { pixels ? I64, subpixels ? I64 } -> Pixel
+add = \@Pixel px, { pixels ? 0, subpixels ? 0 } ->
+    pixel = @Pixel { pixels: px.pixels + pixels, subpixels: px.subpixels + subpixels }
+    normalize pixel
+
+sub : Pixel, { pixels ? I64, subpixels ? I64 } -> Pixel
+sub = \@Pixel px, { pixels ? 0, subpixels ? 0 } ->
+    pixel = @Pixel { pixels: px.pixels - pixels, subpixels: px.subpixels - subpixels }
+    normalize pixel
+
+normalize : Pixel -> Pixel
+normalize = \@Pixel px ->
+    total = px.pixels * subpixelsPerPixel + px.subpixels
+
+    pixels = Num.divTrunc total subpixelsPerPixel
+    subpixels = Num.rem px.subpixels subpixelsPerPixel
+
+    @Pixel { pixels, subpixels }
+
+totalSubpixels : Pixel -> I64
+totalSubpixels = \@Pixel px ->
+    px.pixels * subpixelsPerPixel + px.subpixels
+
+fromPixels : I64 -> Pixel
+fromPixels = \pixels ->
+    fromParts { pixels, subpixels: 0 }
+
+fromParts : { pixels : I64, subpixels : I64 } -> Pixel
+fromParts = \{ pixels, subpixels } ->
+    @Pixel { pixels, subpixels }
+    |> normalize
+
+pixelInspector : Pixel -> Inspector f where f implements InspectFormatter
+pixelInspector = \@Pixel px ->
+    Inspect.str (Inspect.toStr px)
+
+expect
+    x = fromParts { pixels: 1, subpixels: 0 }
+    y = fromParts { pixels: 2, subpixels: 2 }
+    vec = { x, y }
+
+    inspected = Inspect.toStr vec
+    expected =
+        """
+        {x: "{pixels: 1, subpixels: 0}", y: "{pixels: 2, subpixels: 2}"}
+        """
+
+    inspected == expected

examples/rollback/Resolution.roc

@@ -0,0 +1,7 @@
+module [width, height]
+
+width : I64
+width = 600
+
+height : I64
+height = 800