@pkmn/engine 0.1.0-dev.a0447192 → 0.1.0-dev.a15b6c17

package/src/lib/gen1/chance.zig

@@ -1,34 +1,27 @@
-const std = @import("std");
-
-const assert = std.debug.assert;
-const print = std.debug.print;
-
-const expect = std.testing.expect;
-const expectEqual = std.testing.expectEqual;
-
 const DEBUG = @import("../common/debug.zig").print;
+
+const array = @import("../common/array.zig");
+const common = @import("../common/data.zig");
+const data = @import("data.zig");
+const optional = @import("../common/optional.zig");
 const options = @import("../common/options.zig");
 const rational = @import("../common/rational.zig");
+const std = @import("std");
 const util = @import("../common/util.zig");
 
-const Array = @import("../common/array.zig").Array;
-const Player = @import("../common/data.zig").Player;
-const Optional = @import("../common/optional.zig").Optional;
-
-const data = @import("data.zig");
-
+const Array = array.Array;
+const assert = std.debug.assert;
 const enabled = options.chance;
-const showdown = options.showdown;
-
-const PointerType = util.PointerType;
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
 const isPointerTo = util.isPointerTo;
-
 const Move = data.Move;
 const MoveSlot = data.MoveSlot;
-
-const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
-const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;
-const Struct = if (@hasField(std.builtin.Type, "struct")) .@"struct" else .Struct;
+const Optional = optional.Optional;
+const Player = common.Player;
+const PointerType = util.PointerType;
+const print = std.debug.print;
+const showdown = options.showdown;
 
 /// Actions taken by a hypothetical "chance player" that convey information about which RNG events
 /// were observed during a Generation I battle `update`. This can additionally be provided as input
@@ -59,15 +52,15 @@ pub const Actions = extern struct {
     /// same shape if they have the same fields set (though those fields need not necessarily be
     /// set to the same value).
     pub fn matches(a: Actions, b: Actions) bool {
-        inline for (@field(@typeInfo(Actions), @tagName(Struct)).fields) |player| {
-            inline for (@field(@typeInfo(Action), @tagName(Struct)).fields) |field| {
+        inline for (@typeInfo(Actions).@"struct".fields) |player| {
+            inline for (@typeInfo(Action).@"struct".fields) |field| {
                 const a_val = @field(@field(a, player.name), field.name);
                 const b_val = @field(@field(b, player.name), field.name);
 
                 switch (@typeInfo(@TypeOf(a_val))) {
-                    Enum => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
+                    .@"enum" => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
                         return false,
-                    Int => if ((a_val > 0) != (b_val > 0)) return false,
+                    .int => if ((a_val > 0) != (b_val > 0)) return false,
                     else => unreachable,
                 }
             }
@@ -75,7 +68,26 @@ pub const Actions = extern struct {
         return true;
     }
 
-    pub fn fmt(self: Actions, writer: anytype, shape: bool) !void {
+    /// TODO
+    pub fn matchesAny(a: Actions, bs: []Actions, i: usize) bool {
+        for (bs, 0..) |b, j| {
+            // TODO: is skipping this redundant check worth it?
+            if (i == j) continue;
+            if (b.matches(a)) return true;
+        }
+        return false;
+    }
+
+    /// TODO
+    pub fn relax(actions: Actions) Actions {
+        if (!options.overwrite) return actions;
+        var a = actions;
+        if (a.p1.confusion == .overwritten) a.p1.confusion = .continuing;
+        if (a.p2.confusion == .overwritten) a.p2.confusion = .continuing;
+        return a;
+    }
+
+    pub fn fmt(self: Actions, writer: *std.Io.Writer, shape: bool) !void {
         try writer.writeAll("<P1 = ");
         try self.p1.fmt(writer, shape);
         try writer.writeAll(", P2 = ");
@@ -83,8 +95,7 @@ pub const Actions = extern struct {
         try writer.writeAll(">");
     }
 
-    pub fn format(a: Actions, comptime f: []const u8, o: std.fmt.FormatOptions, w: anytype) !void {
-        _ = .{ f, o };
+    pub fn format(a: Actions, w: *std.Io.Writer) !void {
         try fmt(a, w, false);
     }
 };
@@ -108,18 +119,41 @@ test Actions {
 }
 
 /// Observation made about a duration - whether the duration has started, been continued, or ended.
-pub const Observation = enum { started, continuing, ended };
-/// An extension of Observation to account for "hidden" confusion.
-pub const Confusion = enum {
-    started,
-    continuing,
-    ended,
-    /// An indicator that an existing confusion duration has been overwritten by a new confusion
-    /// duration due to a Thrashing move ending. This is not immediately observable to an opponent,
-    /// to compute probabilities from an opponent's point of view based solely on public information
-    /// extra work must be done to correct for the information leak
-    overwritten,
-};
+pub fn Observation(comptime field: Duration.Field) type {
+    return switch (field) {
+        .attacking, .binding => enum(u2) {
+            started,
+            continuing,
+            ended,
+        },
+        .sleep, .disable => enum(u3) {
+            started,
+            continuing,
+            ended,
+            // TODO haze support
+            unused1,
+            unused2,
+            unused3,
+            unused4,
+        },
+        .confusion => enum(u4) {
+            started,
+            continuing,
+            ended,
+            /// An indicator that an existing confusion duration has been overwritten by a new
+            /// confusion duration due to a Thrashing move ending ("hidden" confusion). This is not
+            /// immediately observable to an opponent, to compute probabilities from an opponent's
+            /// point of view based solely on public information extra work must be done to correct
+            /// for the information leak
+            overwritten,
+            // TODO haze support
+            unused1,
+            unused2,
+            unused3,
+            unused4,
+        },
+    };
+}
 
 /// Information about the RNG that was observed during a Generation I battle `update` for a
 /// single player.
@@ -146,26 +180,24 @@ pub const Action = packed struct(u64) {
     duration: u4 = 0,
 
     /// TODO
-    sleep: Optional(Observation) = .None,
+    sleep: Optional(Observation(.sleep)) = .None,
     /// TODO
-    confusion: Optional(Confusion) = .None,
+    confusion: Optional(Observation(.confusion)) = .None,
     /// TODO
-    disable: Optional(Observation) = .None,
+    disable: Optional(Observation(.disable)) = .None,
     /// TODO
-    attacking: Optional(Observation) = .None,
+    attacking: Optional(Observation(.attacking)) = .None,
     /// TODO
-    binding: Optional(Observation) = .None,
-
-    _: u1 = 0,
+    binding: Optional(Observation(.binding)) = .None,
 
     /// If not 0, the move slot (1-4) to return in Rolls.moveSlot. If present as an override,
     /// invalid values (eg. due to empty move slots or 0 PP) will be ignored.
-    move_slot: u4 = 0,
+    move_slot: u3 = 0,
+    /// If not 0, the value (2-5) to return for Rolls.distribution for multi hit.
+    multi_hit: u3 = 0,
 
     /// TODO
     pp: u4 = 0,
-    /// If not 0, the value (2-5) to return for Rolls.distribution for multi hit.
-    multi_hit: u4 = 0,
 
     /// If not 0, psywave - 1 should be returned as the damage roll for Rolls.psywave.
     psywave: u8 = 0,
@@ -175,18 +207,19 @@ pub const Action = packed struct(u64) {
 
     pub const Field = std.meta.FieldEnum(Action);
 
-    pub fn format(a: Action, comptime f: []const u8, o: std.fmt.FormatOptions, w: anytype) !void {
-        _ = .{ f, o };
+    pub fn format(a: Action, w: *std.Io.Writer) !void {
         try fmt(a, w, false);
     }
 
-    pub fn fmt(self: Action, writer: anytype, shape: bool) !void {
+    const SYMBOLS = [_][]const u8{ "+", "", "-", "#" };
+
+    pub fn fmt(self: Action, writer: *std.Io.Writer, shape: bool) !void {
         try writer.writeByte('(');
         var printed = false;
-        inline for (@field(@typeInfo(Action), @tagName(Struct)).fields) |field| {
+        inline for (@typeInfo(Action).@"struct".fields) |field| {
             const val = @field(self, field.name);
             switch (@typeInfo(@TypeOf(val))) {
-                Enum => if (val != .None) {
+                .@"enum" => if (val != .None) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -195,19 +228,14 @@ pub const Action = packed struct(u64) {
                             if (val == .false) "!" else "",
                             field.name,
                         });
-                    } else if (@TypeOf(val) == Optional(Observation) or
-                        @TypeOf(val) == Optional(Confusion))
-                    {
-                        try writer.print("{s}{s}", .{
-                            ([_][]const u8{ "+", "", "-", "#" })[@intFromEnum(val) - 1],
-                            field.name,
-                        });
+                    } else if (@TypeOf(val) != Move and @TypeOf(val) != Optional(Player)) {
+                        try writer.print("{s}{s}", .{ SYMBOLS[@intFromEnum(val) - 1], field.name });
                     } else {
                         try writer.print("{s}:{s}", .{ field.name, @tagName(val) });
                     }
                     printed = true;
                 },
-                Int => if (val != 0) {
+                .int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -240,14 +268,8 @@ pub const Durations = extern struct {
         return if (player == .P1) &self.p1 else &self.p2;
     }
 
-    pub fn format(
-        self: Durations,
-        comptime fmt: []const u8,
-        opts: std.fmt.FormatOptions,
-        writer: anytype,
-    ) !void {
-        _ = .{ fmt, opts };
-        try writer.print("[P1 = {}, P2 = {}]", .{ self.p1, self.p2 });
+    pub fn format(self: Durations, writer: *std.Io.Writer) !void {
+        try writer.print("[P1 = {f}, P2 = {f}]", .{ self.p1, self.p2 });
     }
 };
 
@@ -263,19 +285,18 @@ pub const Duration = packed struct(u32) {
 
     _: u1 = 0,
 
+    pub const Field = enum { attacking, binding, sleep, disable, confusion };
+
     pub fn format(
         self: Duration,
-        comptime fmt: []const u8,
-        opts: std.fmt.FormatOptions,
-        writer: anytype,
+        writer: *std.Io.Writer,
     ) !void {
-        _ = .{ fmt, opts };
         try writer.writeByte('(');
         var printed = false;
-        inline for (@field(@typeInfo(Duration), @tagName(Struct)).fields) |field| {
+        inline for (@typeInfo(Duration).@"struct".fields) |field| {
             const val = @field(self, field.name);
             switch (@typeInfo(@TypeOf(val))) {
-                Int => if (val != 0) {
+                .int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
                     if (comptime std.mem.eql(u8, field.name, "sleeps")) {
                         try writer.print("{s}:[", .{field.name});
@@ -536,7 +557,7 @@ pub fn Chance(comptime Rational: type) type {
             self: *Self,
             comptime field: Action.Field,
             player: Player,
-            obs: Optional(Confusion),
+            obs: Optional(Observation(.confusion)),
         ) void {
             if (!enabled) return;
 
@@ -578,7 +599,7 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn sleep(self: *Self, player: Player, obs: Optional(Observation)) Error!void {
+        pub fn sleep(self: *Self, player: Player, obs: Optional(Observation(.sleep))) Error!void {
             if (!enabled) return;
 
             var a = self.actions.get(player);
@@ -602,7 +623,11 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn confusion(self: *Self, player: Player, obs: Optional(Confusion)) Error!void {
+        pub fn confusion(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.confusion)),
+        ) Error!void {
             if (!enabled) return;
 
             var a = self.actions.get(player);
@@ -624,7 +649,11 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn disable(self: *Self, player: Player, obs: Optional(Observation)) Error!void {
+        pub fn disable(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.disable)),
+        ) Error!void {
             if (!enabled) return;
 
             var a = self.actions.get(player);
@@ -646,7 +675,11 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn attacking(self: *Self, player: Player, obs: Optional(Observation)) Error!void {
+        pub fn attacking(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.attacking)),
+        ) Error!void {
             if (!enabled) return;
 
             var a = self.actions.get(player);
@@ -668,7 +701,11 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn binding(self: *Self, player: Player, obs: Optional(Observation)) Error!void {
+        pub fn binding(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.binding)),
+        ) Error!void {
             if (!enabled) return;
 
             var a = self.actions.get(player);
@@ -878,13 +915,13 @@ test "Chance.moveSlot" {
 
     try chance.moveSlot(.P2, 2, &ms, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(@as(u4, 2), chance.actions.p2.move_slot);
+    try expectValue(@as(u3, 2), chance.actions.p2.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 1, &ms, 0);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(@as(u4, 1), chance.actions.p1.move_slot);
+    try expectValue(@as(u3, 1), chance.actions.p1.move_slot);
 }
 
 test "Chance.multiHit" {
@@ -1051,7 +1088,7 @@ pub fn expectProbability(r: anytype, p: u64, q: u64) !void {
 
     r.reduce();
     if (r.p != p or r.q != q) {
-        print("expected {d}/{d}, found {}\n", .{ p, q, r });
+        print("expected {d}/{d}, found {f}\n", .{ p, q, r });
         return error.TestExpectedEqual;
     }
 }
@@ -1129,28 +1166,44 @@ const Null = struct {
         self: Null,
         comptime field: Action.Field,
         player: Player,
-        obs: Optional(Confusion),
+        obs: Optional(Observation(.confusion)),
     ) void {
         _ = .{ self, field, player, obs };
     }
 
-    pub fn sleep(self: Null, player: Player, obs: Optional(Observation)) Error!void {
+    pub fn sleep(self: Null, player: Player, obs: Optional(Observation(.sleep))) Error!void {
         _ = .{ self, player, obs };
     }
 
-    pub fn confusion(self: Null, player: Player, obs: Optional(Confusion)) Error!void {
+    pub fn confusion(
+        self: Null,
+        player: Player,
+        obs: Optional(Observation(.confusion)),
+    ) Error!void {
         _ = .{ self, player, obs };
     }
 
-    pub fn disable(self: Null, player: Player, obs: Optional(Observation)) Error!void {
+    pub fn disable(
+        self: Null,
+        player: Player,
+        obs: Optional(Observation(.disable)),
+    ) Error!void {
         _ = .{ self, player, obs };
     }
 
-    pub fn attacking(self: Null, player: Player, obs: Optional(Observation)) Error!void {
+    pub fn attacking(
+        self: Null,
+        player: Player,
+        obs: Optional(Observation(.attacking)),
+    ) Error!void {
         _ = .{ self, player, obs };
     }
 
-    pub fn binding(self: Null, player: Player, obs: Optional(Observation)) Error!void {
+    pub fn binding(
+        self: Null,
+        player: Player,
+        obs: Optional(Observation(.binding)),
+    ) Error!void {
         _ = .{ self, player, obs };
     }
 

package/src/lib/gen1/data/moves.zig

@@ -1,12 +1,10 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
-const rng = @import("../../common/rng.zig");
 const gen1 = @import("../../gen1/data.zig");
+const rng = @import("../../common/rng.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const percent = rng.Gen12.percent;
 const Type = gen1.Type;
 

package/src/lib/gen1/data/species.zig

@@ -1,11 +1,9 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const gen1 = @import("../../gen1/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const Stats = gen1.Stats;
 const Types = gen1.Types;
 

package/src/lib/gen1/data/types.zig

@@ -1,8 +1,7 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const gen1 = @import("../../gen1/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
 const Effectiveness = gen1.Effectiveness;
@@ -99,7 +98,7 @@ pub const Type = enum(u4) {
         return CHART[@intFromEnum(t1)][@intFromEnum(t2)];
     }
 
-    /// The precedence order of Type `t2` vs. Type `t1`.
+    /// The precedence order of Type `t1` vs. Type `t2`.
     pub fn precedence(t1: Type, t2: Type) u8 {
         for (PRECEDENCE, 0..) |matchup, i| {
             if (matchup.type1 == t1 and matchup.type2 == t2) return @intCast(i);
@@ -109,7 +108,7 @@ pub const Type = enum(u4) {
 };
 
 /// Representation of a Pokémon's typing.
-pub const Types = packed struct {
+pub const Types = packed struct(u8) {
     /// A Pokémon's primary type.
     type1: Type = .Normal,
     /// A Pokémon's secondary type (may be identical to its primary type).

package/src/lib/gen1/data.zig

@@ -1,20 +1,16 @@
-const std = @import("std");
 const builtin = @import("builtin");
-
-const pkmn = @import("../pkmn.zig");
-
+const calc = @import("calc.zig");
+const chance = @import("chance.zig");
 const data = @import("../common/data.zig");
+const mechanics = @import("mechanics.zig");
+const moves = @import("data/moves.zig");
+const pkmn = @import("../pkmn.zig");
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
-const util = @import("../common/util.zig");
-
-const moves = @import("data/moves.zig");
 const species = @import("data/species.zig");
+const std = @import("std");
 const types = @import("data/types.zig");
-
-const calc = @import("calc.zig");
-const chance = @import("chance.zig");
-const mechanics = @import("mechanics.zig");
+const util = @import("../common/util.zig");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
@@ -66,7 +62,7 @@ pub fn Battle(comptime RNG: anytype) type {
         /// The last damage dealt by either side.
         last_damage: u16 = 0,
         /// Details about the last move selected/used by each player required to detect desyncs.
-        last_moves: [2]MoveDetails = [_]MoveDetails{.{}} ** 2,
+        last_moves: [2]MoveDetails = @splat(.{}),
         /// The pseudo random number generator.
         rng: RNG,
 
@@ -126,12 +122,12 @@ test Battle {
 /// Representation of one side of a Generation I Pokémon battle.
 pub const Side = extern struct {
     /// The player's party in its original order
-    pokemon: [6]Pokemon = [_]Pokemon{.{}} ** 6,
+    pokemon: [6]Pokemon = @splat(.{}),
     /// The active Pokémon for the side, zero initialized if the battle has yet to start.
     /// Note that fainted Pokémon are still consider "active" until their replacement switches in.
     active: ActivePokemon = .{},
     /// One-based slot indexes reflecting the current order of the player's party.
-    order: [6]u8 = [_]u8{0} ** 6,
+    order: [6]u8 = @splat(0),
     /// The last move the player selected.
     last_selected_move: Move = .None,
     /// The last move the player used.
@@ -170,7 +166,7 @@ pub const ActivePokemon = extern struct {
     /// The active Pokémon's volatile statuses and associated data.
     volatiles: Volatiles = .{},
     /// The active Pokémon's current move slots.
-    moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
+    moves: [4]MoveSlot = @splat(.{}),
 
     comptime {
         assert(@sizeOf(ActivePokemon) == 32);
@@ -190,7 +186,7 @@ pub const Pokemon = extern struct {
     /// The Pokémon's unmodified stats.
     stats: Stats(u16) = .{},
     /// The Pokémon's original stored move slots.
-    moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
+    moves: [4]MoveSlot = @splat(.{}),
     /// The Pokémon's current HP.
     hp: u16 = 0,
     /// The Pokémon's current status.

package/src/lib/gen1/helpers.zig

@@ -1,32 +1,24 @@
-const std = @import("std");
 const builtin = @import("builtin");
-
 const common = @import("../common/data.zig");
+const data = @import("data.zig");
 const options = @import("../common/options.zig");
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
+const std = @import("std");
 const util = @import("../common/util.zig");
 
-const data = @import("data.zig");
-
 const assert = std.debug.assert;
-
 const Choice = common.Choice;
-
-const showdown = options.showdown;
-
-const PSRNG = rng.PSRNG;
-
 const DVs = data.DVs;
 const Move = data.Move;
 const MoveSlot = data.MoveSlot;
+const PSRNG = rng.PSRNG;
+const showdown = options.showdown;
 const Species = data.Species;
 const Stats = data.Stats;
 
 const endian = builtin.cpu.arch.endian();
 
-const Struct = if (@hasField(std.builtin.Type, "struct")) .@"struct" else .Struct;
-
 /// Configuration options controlling the domain of valid Pokémon that can be generated by the
 /// random generator helpers.
 pub const Options = struct {
@@ -169,7 +161,7 @@ pub const Pokemon = struct {
         var pokemon = data.Pokemon{};
         pokemon.species = p.species;
         const species = Species.get(p.species);
-        inline for (@field(@typeInfo(@TypeOf(pokemon.stats)), @tagName(Struct)).fields) |field| {
+        inline for (@typeInfo(@TypeOf(pokemon.stats)).@"struct".fields) |field| {
             const hp = comptime std.mem.eql(u8, field.name, "hp");
             const spc =
                 comptime std.mem.eql(u8, field.name, "spa") or std.mem.eql(u8, field.name, "spd");
@@ -205,7 +197,7 @@ pub const Pokemon = struct {
         const lvl = if (rand.chance(u8, 1, 20)) rand.range(u8, 1, 99 + 1) else 100;
         var stats: Stats(u16) = .{};
         const dvs = DVs.random(rand);
-        inline for (@field(@typeInfo(@TypeOf(stats)), @tagName(Struct)).fields) |field| {
+        inline for (@typeInfo(@TypeOf(stats)).@"struct".fields) |field| {
             @field(stats, field.name) = Stats(u16).calc(
                 field.name,
                 @field(species.stats, field.name),
@@ -218,7 +210,7 @@ pub const Pokemon = struct {
             );
         }
 
-        var ms = [_]MoveSlot{.{}} ** 4;
+        var ms: [4]MoveSlot = @splat(.{});
         const n = if (rand.chance(u8, 1, 100)) rand.range(u4, 1, 3 + 1) else 4;
         for (0..n) |i| {
             var m: Move = .None;
@@ -298,23 +290,23 @@ else
 pub fn diff(
     a: *const data.Battle(data.PRNG),
     b: *const data.Battle(data.PRNG),
-    w: protocol.ByteStream.Writer,
+    w: *protocol.Writer,
 ) !usize {
-    const pos = w.stream.pos;
+    const pos = w.pos;
     const size = @sizeOf(data.Battle(data.PRNG)) - @sizeOf(data.PRNG);
     assert(size % 2 == 0);
     assert(size / 2 < 255);
 
     var i: usize = 0;
     while (i < size) : (i += 2) {
-        const val = util.bytesAsValue(u16, std.mem.asBytes(a)[i .. i + 2]).*;
-        if (val != util.bytesAsValue(u16, std.mem.asBytes(b)[i .. i + 2]).*) {
+        const val = std.mem.bytesAsValue(u16, std.mem.asBytes(a)[i .. i + 2]).*;
+        if (val != std.mem.bytesAsValue(u16, std.mem.asBytes(b)[i .. i + 2]).*) {
             try w.writeByte(@intCast(i / 2));
             try w.writeInt(u16, val, endian);
         }
     }
 
-    return w.stream.pos - pos;
+    return w.pos - pos;
 }
 
 /// TODO