@pkmn/engine 0.1.0-dev.abd68573 → 0.1.0-dev.ac9225d5

package/src/lib/gen1/chance.zig

@@ -255,6 +255,8 @@ pub const Duration = packed struct(u16) {
 
 pub const Commit = enum { hit, miss, binding };
 
+const uN = if (options.miss) u8 else u9;
+
 /// Tracks chance actions and their associated probability during a Generation I battle update when
 /// `options.chance` is enabled.
 pub fn Chance(comptime Rational: type) type {
@@ -291,15 +293,12 @@ pub fn Chance(comptime Rational: type) type {
         //
         // Finally, because each player's actions are processed sequentially we only need a single
         // shared structure to track this information (though it needs to be cleared appropriately)
-        pending: if (showdown) struct {
-            hit: bool = false,
-            hit_probablity: u8 = 0,
-        } else struct {
+        pending: if (showdown) struct {} else struct {
             crit: bool = false,
             crit_probablity: u8 = 0,
             damage_roll: u8 = 0,
             hit: bool = false,
-            hit_probablity: u8 = 0,
+            hit_probablity: uN = 0,
             binding: u8 = 0,
         } = .{},
 
@@ -308,25 +307,29 @@ pub fn Chance(comptime Rational: type) type {
 
         /// Convenience helper to clear fields which typically should be cleared between updates.
         pub fn reset(self: *Self) void {
+            if (!enabled) return;
+
             self.probability.reset();
             self.actions.reset();
             self.pending = .{};
         }
 
         pub fn commit(self: *Self, player: Player, kind: Commit) Error!void {
+            if (!enabled) return;
+
+            assert(!showdown);
+
             var action = self.actions.get(player);
 
             // We need to handle binding specially because we still need to commit it when attacking
             // into a Pokémon that is immune
-            if (!showdown) {
-                if (kind != .miss and self.pending.binding != 0) {
-                    assert(action.duration == 0);
-                    action.duration = @intCast(self.pending.binding);
-                    assert(action.durations.binding == 0);
-                    action.durations.binding = 1;
-                }
-                if (kind == .binding) return;
-            } else assert(kind != .binding);
+            if (kind != .miss and self.pending.binding != 0) {
+                assert(action.duration == 0);
+                action.duration = @intCast(self.pending.binding);
+                assert(action.durations.binding == 0);
+                action.durations.binding = 1;
+            }
+            if (kind == .binding) return;
 
             // Always commit the hit result if we make it here (commit won't be called at all if the
             // target is immune/behind a sub/etc)
@@ -335,19 +338,19 @@ pub fn Chance(comptime Rational: type) type {
                 action.hit = if (self.pending.hit) .true else .false;
             }
 
-            if (showdown) return;
+            // If the move actually lands we can commit any past critical hit / damage rolls. Note
+            // we can't rely on the presence or absence of a damage roll to determine whether a
+            // "critical hit" was spurious or not as moves that do 1 or less damage don't rol for
+            // damage but can still crit (instead, whether or not a roll is deemed to be a no-op is
+            // passed to the critical hit helper)
+            if (kind != .hit) return assert(!self.pending.crit or self.pending.crit_probablity > 0);
 
-            // If the move actually lands we can commit any past critical hit / damage rolls. We
-            // avoid updating anything if there wasn't a damage roll as any "critical hit" not tied
-            // to a damage roll is actually a no-op
-            if (kind == .hit and self.pending.damage_roll > 0) {
-                assert(!self.pending.crit or self.pending.crit_probablity > 0);
-
-                if (self.pending.crit_probablity != 0) {
-                    try self.probability.update(self.pending.crit_probablity, 256);
-                    action.critical_hit = if (self.pending.crit) .true else .false;
-                }
+            if (self.pending.crit_probablity != 0) {
+                try self.probability.update(self.pending.crit_probablity, 256);
+                action.critical_hit = if (self.pending.crit) .true else .false;
+            }
 
+            if (self.pending.damage_roll > 0) {
                 try self.probability.update(1, 39);
                 action.damage = self.pending.damage_roll;
             }
@@ -398,12 +401,17 @@ pub fn Chance(comptime Rational: type) type {
             self.actions.p2.speed_tie = self.actions.p1.speed_tie;
         }
 
-        pub fn hit(self: *Self, ok: bool, accuracy: u8) void {
+        pub fn hit(self: *Self, player: Player, ok: bool, accuracy: uN) Error!void {
             if (!enabled) return;
 
             const p = if (ok) accuracy else @as(u8, @intCast(256 - @as(u9, accuracy)));
-            self.pending.hit = ok;
-            self.pending.hit_probablity = p;
+            if (showdown) {
+                try self.probability.update(p, 256);
+                self.actions.get(player).hit = if (ok) .true else .false;
+            } else {
+                self.pending.hit = ok;
+                self.pending.hit_probablity = p;
+            }
         }
 
         pub fn criticalHit(self: *Self, player: Player, crit: bool, rate: u8) Error!void {
@@ -621,19 +629,25 @@ test "Chance.speedTie" {
 test "Chance.hit" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
-    chance.hit(true, 229);
-    try expectProbability(&chance.probability, 1, 1);
-    try expectValue(Optional(bool).None, chance.actions.p1.hit);
-    try chance.commit(.P1, .hit);
+    try chance.hit(.P1, true, 229);
+    if (!showdown) {
+        try expectProbability(&chance.probability, 1, 1);
+        try expectValue(Optional(bool).None, chance.actions.p1.hit);
+
+        try chance.commit(.P1, .hit);
+    }
     try expectValue(Optional(bool).true, chance.actions.p1.hit);
     try expectProbability(&chance.probability, 229, 256);
 
     chance.reset();
 
-    chance.hit(false, 255);
-    try expectProbability(&chance.probability, 1, 1);
-    try expectValue(Optional(bool).None, chance.actions.p2.hit);
-    try chance.commit(.P2, .miss);
+    try chance.hit(.P2, false, 255);
+    if (!showdown) {
+        try expectProbability(&chance.probability, 1, 1);
+        try expectValue(Optional(bool).None, chance.actions.p2.hit);
+
+        try chance.commit(.P2, .miss);
+    }
     try expectValue(Optional(bool).false, chance.actions.p2.hit);
     try expectProbability(&chance.probability, 1, 256);
 }
@@ -649,26 +663,18 @@ test "Chance.criticalHit" {
         try expectProbability(&chance.probability, 1, 1);
         try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
 
-        try chance.commit(.P1, .hit);
-        try expectProbability(&chance.probability, 1, 1);
-        try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
-
-        chance.hit(true, 128);
+        try chance.hit(.P1, true, 128);
 
-        try chance.commit(.P1, .hit);
-        try expectProbability(&chance.probability, 1, 2);
+        try expectProbability(&chance.probability, 1, 1);
         try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
 
-        chance.probability.reset();
         try chance.damage(.P1, 217);
 
-        try chance.commit(.P1, .miss);
-        try expectProbability(&chance.probability, 1, 2);
+        try expectProbability(&chance.probability, 1, 1);
         try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
 
-        chance.probability.reset();
-
         try chance.commit(.P1, .hit);
+
         try expectProbability(&chance.probability, 17, 19968); // (1/2) * (17/256) * (1/39)
         try expectValue(Optional(bool).true, chance.actions.p1.critical_hit);
     }
@@ -683,20 +689,14 @@ test "Chance.criticalHit" {
         try expectProbability(&chance.probability, 1, 1);
         try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
 
-        try chance.commit(.P1, .hit);
-        try expectProbability(&chance.probability, 1, 1);
-        try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
-
-        chance.hit(true, 128);
+        try chance.hit(.P1, true, 128);
 
-        try chance.commit(.P1, .hit);
-        try expectProbability(&chance.probability, 1, 2);
+        try expectProbability(&chance.probability, 1, 1);
         try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
 
-        chance.probability.reset();
         try chance.damage(.P1, 217);
-
         try chance.commit(.P1, .hit);
+
         try expectProbability(&chance.probability, 251, 19968); // (1/2) * (251/256) * (1/39)
         try expectValue(Optional(bool).false, chance.actions.p1.critical_hit);
     }
@@ -713,11 +713,8 @@ test "Chance.damage" {
         try expectProbability(&chance.probability, 1, 1);
         try expectValue(0, chance.actions.p1.damage);
 
-        try chance.commit(.P1, .miss);
-        try expectProbability(&chance.probability, 1, 1);
-        try expectValue(0, chance.actions.p1.damage);
-
         try chance.commit(.P1, .hit);
+
         try expectProbability(&chance.probability, 1, 39);
         try expectValue(217, chance.actions.p1.damage);
     }
@@ -807,6 +804,7 @@ test "Chance.duration" {
     if (!showdown) {
         try expectValue(0, chance.actions.p2.duration);
         try expectValue(0, chance.actions.p2.durations.binding);
+
         try chance.commit(.P2, .hit);
     }
     try expectValue(4, chance.actions.p2.duration);
@@ -989,8 +987,8 @@ const Null = struct {
         _ = .{ self, p1 };
     }
 
-    pub fn hit(self: Null, ok: bool, accuracy: u8) void {
-        _ = .{ self, ok, accuracy };
+    pub fn hit(self: Null, player: Player, ok: bool, accuracy: uN) Error!void {
+        _ = .{ self, player, ok, accuracy };
     }
 
     pub fn criticalHit(self: Null, player: Player, crit: bool, rate: u8) Error!void {

package/src/lib/gen1/data.zig

@@ -22,11 +22,11 @@ const expect = std.testing.expect;
 
 /// The minimum size in bytes required to hold all Generation I choice options.
 pub const MAX_CHOICES: usize = 9; // move 1..4, switch 2..6
-/// The optimal size in bytes required to hold all Generation I choice options.
-/// At least as large as MAX_CHOICES.
+/// The maximum number of bytes possibly logged by a single Generation I update.
 pub const MAX_LOGS: usize = 180;
 
-/// The maximum number of bytes possibly logged by a single Generation I update.
+/// The optimal size in bytes required to hold all Generation I choice options.
+/// At least as large as MAX_CHOICES.
 pub const CHOICES_SIZE = if (builtin.mode == .ReleaseSmall)
     MAX_CHOICES
 else

package/src/lib/gen1/helpers.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 
 const common = @import("../common/data.zig");
 const optional = @import("../common/optional.zig");
@@ -35,6 +36,8 @@ const Status = data.Status;
 const Action = chance.Action;
 const Actions = chance.Actions;
 
+const endian = builtin.cpu.arch.endian();
+
 /// Configuration options controlling the domain of valid Pokémon that can be generated by the
 /// random generator helpers.
 pub const Options = struct {
@@ -43,6 +46,8 @@ pub const Options = struct {
     /// Whether to generate Pokémon with moves that contain bugs on Pokémon Showdown that are
     /// unimplementable in the engine.
     block: bool = showdown,
+    // FIXME: remove once durations work with -Dchance
+    durations: bool = false,
 };
 
 /// Helpers to simplify initialization of a Generation I battle.
@@ -230,6 +235,7 @@ pub const Pokemon = struct {
             var m: Move = .None;
             sample: while (true) {
                 m = @enumFromInt(rand.range(u8, 1, Move.size - 1 + 1));
+                if (opt.durations and durations(m)) continue :sample;
                 if (opt.block and blocked(m)) continue :sample;
                 for (0..i) |j| if (ms[j].id == m) continue :sample;
                 break;
@@ -267,6 +273,23 @@ fn blocked(m: Move) bool {
     };
 }
 
+fn durations(m: Move) bool {
+    // Any moves that have effects that result in duration tracking with -Dchance
+    return switch (Move.get(m).effect) {
+        .Confusion,
+        .Bide,
+        .Sleep,
+        .Rage,
+        .Binding,
+        .Thrashing,
+        .ConfusionChance,
+        .Disable,
+        .Metronome,
+        => true,
+        else => false,
+    };
+}
+
 /// Convenience helper to create a move-type choice for the provided move slot.
 pub fn move(slot: u4) Choice {
     return .{ .type = .Move, .data = slot };
@@ -287,7 +310,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for speed ties given the `action` state.
     pub fn speedTie(action: Action) []const Optional(Player) {
-        return if (@field(action, "speed_tie") == .None) &PLAYER_NONE else &PLAYERS;
+        return if (action.speed_tie == .None) &PLAYER_NONE else &PLAYERS;
     }
 
     const BOOL_NONE = [_]Optional(bool){.None};
@@ -297,25 +320,19 @@ pub const Rolls = struct {
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
     pub fn hit(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .true) return &BOOL_NONE;
-        return if (@field(action, "hit") == .None) &BOOL_NONE else &BOOLS;
+        return if (action.hit == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for critical hits given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub fn criticalHit(
-        action: Action,
-        parent: Optional(bool),
-    ) []const Optional(bool) {
+    pub fn criticalHit(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .false) return &BOOL_NONE;
-        return if (@field(action, "critical_hit") == .None) &BOOL_NONE else &BOOLS;
+        return if (action.critical_hit == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for secondary chances hits given the
     /// `action` state and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub fn secondaryChance(
-        action: Action,
-        parent: Optional(bool),
-    ) []const Optional(bool) {
+    pub fn secondaryChance(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .false) return &BOOL_NONE;
         return if (@field(action, "secondary_chance") == .None) &BOOL_NONE else &BOOLS;
     }
@@ -326,7 +343,7 @@ pub const Rolls = struct {
     /// Returns the range bounding damage rolls given the `action` state and the state of
     /// the `parent` (whether the player's Pokémon's move hit).
     pub fn damage(action: Action, parent: Optional(bool)) Range {
-        return if (parent == .false or @field(action, "damage") == 0)
+        return if (parent == .false or action.damage == 0)
             .{ .min = 0, .max = 1 }
         else
             .{ .min = 217, .max = 256 };
@@ -347,14 +364,14 @@ pub const Rolls = struct {
     /// Returns a slice with the correct range of values for confused given the `action` state
     /// and the state of the `parent` (the player's Pokémon's remaining confusion turns).
     pub fn confused(action: Action, parent: u4) []const Optional(bool) {
-        return if (parent == 0 or @field(action, "confused") == .None) &BOOL_NONE else &BOOLS;
+        return if (parent == 0 or action.confused == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for paralysis given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon was confused).
     pub fn paralyzed(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .true) return &BOOL_NONE;
-        return if (@field(action, "paralyzed") == .None) &BOOL_NONE else &BOOLS;
+        return if (action.paralyzed == .None) &BOOL_NONE else &BOOLS;
     }
 
     const DURATION_NONE = [_]u1{0};
@@ -364,7 +381,7 @@ pub const Rolls = struct {
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
     pub fn duration(action: Action, parent: Optional(bool)) []const u1 {
         if (parent == .false) return &DURATION_NONE;
-        return if (@field(action, "duration") == 0) &DURATION_NONE else &DURATION;
+        return if (action.duration == 0) &DURATION_NONE else &DURATION;
     }
 
     const U3_NONE = [_]u3{0};
@@ -372,8 +389,8 @@ pub const Rolls = struct {
 
     /// Returns a slice with a range of values for sleep given the `action` and `origin` states.
     pub inline fn sleep(action: Action, origin: Action) []const u3 {
-        const a = @field(action.durations, "sleep");
-        const o = @field(origin.durations, "sleep");
+        const a = action.durations.sleep;
+        const o = origin.durations.sleep;
         if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
         assert(a == 0 or a == o + 1);
         return if (o >= 7) &U3_NONE else &[_]u3{ 0, o + 1 };
@@ -385,8 +402,8 @@ pub const Rolls = struct {
     /// and the state of the `parent` (the player's Pokémon's remaining sleep turns).
     pub inline fn disable(action: Action, origin: Action, parent: u4) []const u4 {
         if (parent > 0) return &DISABLE_NONE;
-        const a = @field(action.durations, "disable");
-        const o = @field(origin.durations, "disable");
+        const a = action.durations.disable;
+        const o = origin.durations.disable;
         if (o == a) return if (o == 0) &DISABLE_NONE else &[_]u4{o};
         assert(a == 0 or a == o + 1);
         return if (o >= 8) &DISABLE_NONE else &[_]u4{ 0, o + 1 };
@@ -396,8 +413,8 @@ pub const Rolls = struct {
     /// and the state of the `parent` (the player's remaining sleep turns).
     pub inline fn confusion(action: Action, origin: Action, parent: u4) []const u3 {
         if (parent > 0) return &U3_NONE;
-        const a = @field(action.durations, "confusion");
-        const o = @field(origin.durations, "confusion");
+        const a = action.durations.confusion;
+        const o = origin.durations.confusion;
         if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
         assert(a == 0 or a == o + 1);
         return if (o >= 5) &U3_NONE else if (o < 2)
@@ -410,8 +427,8 @@ pub const Rolls = struct {
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
     pub inline fn attacking(action: Action, origin: Action, parent: Optional(bool)) []const u3 {
         if (parent == .true) return &U3_NONE;
-        const a = @field(action.durations, "attacking");
-        const o = @field(origin.durations, "attacking");
+        const a = action.durations.attacking;
+        const o = origin.durations.attacking;
         if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
         assert(a == 0 or a == o + 1);
         return if (o >= 3) &U3_NONE else if (o < 2)
@@ -424,8 +441,8 @@ pub const Rolls = struct {
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
     pub inline fn binding(action: Action, origin: Action, parent: Optional(bool)) []const u3 {
         if (parent == .true) return &U3_NONE;
-        const a = @field(action.durations, "binding");
-        const o = @field(origin.durations, "binding");
+        const a = action.durations.binding;
+        const o = origin.durations.binding;
         if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
         assert(a == 0 or a == o + 1);
         return if (o >= 4) &U3_NONE else &[_]u3{ 0, o + 1 };
@@ -440,7 +457,7 @@ pub const Rolls = struct {
     /// These slots may or **may not be valid** as slots may be unset / have 0 PP.
     pub fn moveSlot(action: Action, parent: Optional(bool)) []const u4 {
         if (parent == .false) return &SLOT_NONE;
-        return if (@field(action, "move_slot") == 0) &SLOT_NONE else &SLOT;
+        return if (action.move_slot == 0) &SLOT_NONE else &SLOT;
     }
 
     const MULTI_NONE = [_]u4{0};
@@ -450,7 +467,7 @@ pub const Rolls = struct {
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
     pub fn multiHit(action: Action, parent: Optional(bool)) []const u4 {
         if (parent == .false) return &MULTI_NONE;
-        return if (@field(action, "multi_hit") == 0) &MULTI_NONE else &MULTI;
+        return if (action.multi_hit == 0) &MULTI_NONE else &MULTI;
     }
 
     const PSYWAVE_NONE = [_]u8{0};
@@ -468,7 +485,7 @@ pub const Rolls = struct {
         parent: Optional(bool),
     ) []const u8 {
         if (parent == .false) return &PSYWAVE_NONE;
-        return if (@field(action, "psywave") == 0)
+        return if (action.psywave == 0)
             &PSYWAVE_NONE
         else
             PSYWAVE[0 .. @as(u16, side.stored().level) * 3 / 2];
@@ -478,7 +495,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for metronome given the `action` state.
     pub fn metronome(action: Action) []const Move {
-        return if (@field(action, "metronome") == .None) &MOVE_NONE else &Move.METRONOME;
+        return if (action.metronome == .None) &MOVE_NONE else &Move.METRONOME;
     }
 };
 
@@ -797,3 +814,47 @@ test "Rolls.psywave" {
     try expectEqual(121, rolls[rolls.len - 1]);
     try expectEqualSlices(u8, &.{0}, Rolls.psywave(actions.p2, &side, .false));
 }
+
+/// Empirically determined maximum number of bytes possibly required to store the diff between two
+/// Generation I battles.
+pub const MAX_DIFFS: usize = 117;
+
+/// The optimal size in bytes required to hold the diff between two Generation I battles.
+/// At least as large as MAX_DIFFS.
+pub const DIFFS_SIZE = if (builtin.mode == .ReleaseSmall)
+    MAX_DIFFS
+else
+    std.math.ceilPowerOfTwo(usize, MAX_DIFFS) catch unreachable;
+
+/// TODO
+pub fn diff(
+    a: *const data.Battle(data.PRNG),
+    b: *const data.Battle(data.PRNG),
+    w: protocol.ByteStream.Writer,
+) !usize {
+    const pos = w.stream.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 = 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;
+}
+
+/// TODO
+pub fn patch(battle: *data.Battle(data.PRNG), buf: []u8) void {
+    var i: usize = 0;
+    while (i < buf.len) : (i += 3) {
+        const off = @as(u16, @intCast(buf[i])) * 2;
+        const val = std.mem.readInt(u16, @ptrCast(buf[i + 1 .. i + 3]), endian);
+        std.mem.writeInt(u16, @ptrCast(std.mem.asBytes(battle)[off .. off + 2]), val, endian);
+    }
+}