@pkmn/engine 0.1.0-dev.36b5d56b → 0.1.0-dev.388b6109

package/src/lib/gen1/chance.zig

@@ -23,10 +23,6 @@ const PointerType = util.PointerType;
 const print = std.debug.print;
 const showdown = options.showdown;
 
-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;
-
 /// 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
 /// to the `update` call to override the normal behavior of the RNG in order to force specific
@@ -49,22 +45,36 @@ pub const Actions = extern struct {
 
     /// Returns true if `a` is equal to `b`.
     pub fn eql(a: Actions, b: Actions) bool {
-        return @as(u128, @bitCast(a)) == @as(u128, @bitCast(b));
+        return @as(u64, @bitCast(a.p1)) == @as(u64, @bitCast(b.p1)) and
+            @as(u64, @bitCast(a.p2)) == @as(u64, @bitCast(b.p2));
     }
 
     /// Returns true if `a` has the same "shape" as `b`, where `Actions` are defined to have the
     /// 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| {
-                const a_val = @field(@field(a, player.name), field.name);
-                const b_val = @field(@field(b, player.name), field.name);
+        inline for (if (@hasField(@TypeOf(@typeInfo(Actions).@"struct"), "fields"))
+            @typeInfo(Actions).@"struct".fields
+        else
+            @typeInfo(Actions).@"struct".field_names) |player|
+        {
+            const player_name = if (@hasField(@TypeOf(player), "name"))
+                player.name
+            else
+                player;
+            inline for (if (@hasField(@TypeOf(@typeInfo(Action).@"struct"), "fields"))
+                @typeInfo(Action).@"struct".fields
+            else
+                @typeInfo(Action).@"struct".field_names) |field|
+            {
+                const field_name = if (@hasField(@TypeOf(field), "name")) field.name else 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,
                 }
             }
@@ -91,7 +101,7 @@ pub const Actions = extern struct {
         return a;
     }
 
-    pub fn fmt(self: Actions, writer: anytype, shape: bool) !void {
+    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 = ");
@@ -99,8 +109,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);
     }
 };
@@ -124,18 +133,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.
@@ -162,26 +194,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,
@@ -191,44 +221,45 @@ 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| {
-            const val = @field(self, field.name);
+        inline for (if (@hasField(@TypeOf(@typeInfo(Action).@"struct"), "fields"))
+            @typeInfo(Action).@"struct".fields
+        else
+            @typeInfo(Action).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else 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});
+                        try writer.print("{s}:?", .{field_name});
                     } else if (@TypeOf(val) == Optional(bool)) {
                         try writer.print("{s}{s}", .{
                             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,
+                            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) });
+                        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});
+                        try writer.print("{s}:?", .{field_name});
                     } else {
-                        try writer.print("{s}:{d}", .{ field.name, val });
+                        try writer.print("{s}:{d}", .{ field_name, val });
                     }
                     printed = true;
                 },
@@ -256,14 +287,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 });
     }
 };
 
@@ -279,29 +304,33 @@ 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| {
-            const val = @field(self, field.name);
+        inline for (if (@hasField(@TypeOf(@typeInfo(Duration).@"struct"), "fields"))
+            @typeInfo(Duration).@"struct".fields
+        else
+            @typeInfo(Duration).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else 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});
+                    if (comptime std.mem.eql(u8, field_name, "sleeps")) {
+                        try writer.print("{s}:[", .{field_name});
                         for (0..6) |i| {
                             if (i != 0) try writer.writeByte(',');
                             try writer.print("{d}", .{Sleeps.get(val, i)});
                         }
                         try writer.writeAll("]");
                     } else {
-                        try writer.print("{s}:{d}", .{ field.name, val });
+                        try writer.print("{s}:{d}", .{ field_name, val });
                     }
                     printed = true;
                 },
@@ -552,7 +581,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;
 
@@ -594,7 +623,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);
@@ -618,7 +647,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);
@@ -640,7 +673,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);
@@ -662,7 +699,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);
@@ -684,7 +725,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);
@@ -894,13 +939,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" {
@@ -1067,7 +1112,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;
     }
 }
@@ -1145,28 +1190,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/types.zig

@@ -98,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);
@@ -108,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

@@ -62,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,
 
@@ -122,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.
@@ -166,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);
@@ -186,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

@@ -19,8 +19,6 @@ 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 {
@@ -163,15 +161,20 @@ 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| {
-            const hp = comptime std.mem.eql(u8, field.name, "hp");
+        inline for (if (@hasField(@TypeOf(@typeInfo(@TypeOf(pokemon.stats)).@"struct"), "fields"))
+            @typeInfo(@TypeOf(pokemon.stats)).@"struct".fields
+        else
+            @typeInfo(@TypeOf(pokemon.stats)).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else 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");
-            @field(pokemon.stats, field.name) = Stats(u16).calc(
-                field.name,
-                @field(species.stats, field.name),
-                if (hp) p.dvs.hp() else if (spc) p.dvs.spc else @field(p.dvs, field.name),
-                @field(p.stats, field.name),
+                comptime std.mem.eql(u8, field_name, "spa") or std.mem.eql(u8, field_name, "spd");
+            @field(pokemon.stats, field_name) = Stats(u16).calc(
+                field_name,
+                @field(species.stats, field_name),
+                if (hp) p.dvs.hp() else if (spc) p.dvs.spc else @field(p.dvs, field_name),
+                @field(p.stats, field_name),
                 p.level,
             );
         }
@@ -199,20 +202,25 @@ 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| {
-            @field(stats, field.name) = Stats(u16).calc(
-                field.name,
-                @field(species.stats, field.name),
-                if (comptime std.mem.eql(u8, field.name, "hp"))
+        inline for (if (@hasField(@TypeOf(@typeInfo(@TypeOf(stats)).@"struct"), "fields"))
+            @typeInfo(@TypeOf(stats)).@"struct".fields
+        else
+            @typeInfo(@TypeOf(stats)).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else field;
+            @field(stats, field_name) = Stats(u16).calc(
+                field_name,
+                @field(species.stats, field_name),
+                if (comptime std.mem.eql(u8, field_name, "hp"))
                     dvs.hp()
                 else
-                    @field(dvs, field.name),
+                    @field(dvs, field_name),
                 if (rand.chance(u8, 1, 20)) rand.range(u16, 0, EXP + 1) else EXP,
                 lvl,
             );
         }
 
-        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;
@@ -292,23 +300,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