@pkmn/engine 0.1.0-dev.14ca6108 → 0.1.0-dev.15f64810

package/src/lib/common/rational.zig

@@ -43,8 +43,7 @@ pub fn Rational(comptime T: type) type {
         /// Update the rational by multiplying its numerator by p and its denominator by q.
         /// Both p and q must be >= 1, and if computable at comptime must have no common factors.
         pub fn update(r: *Self, p: anytype, q: anytype) Error!void {
-            // FIXME
-            // std.debug.print("({d}/{d}) * ", .{p, q});
+            // std.debug.print("({d}/{d}) * ", .{ p, q }); // DEBUG
             assert(p >= 1);
             assert(q >= 1);
 
@@ -185,16 +184,16 @@ pub fn Rational(comptime T: type) type {
             try writer.print("{d}/{d}", .{ self.p, self.q });
         }
 
-        inline fn multiplication(r: *Self, p: anytype, q: anytype) !void {
+        fn multiplication(r: *Self, p: anytype, q: anytype) !void {
             r.p = try std.math.mul(T, r.p, p);
             r.q = try std.math.mul(T, r.q, q);
         }
 
-        inline fn addition(r: *Self, p: anytype, q: anytype) !void {
+        fn addition(r: *Self, p: anytype, q: anytype) !void {
             // (a/b) + (c/d) = (ad+bc)/(bd)
-            var d = try std.math.mul(T, r.q, q);
-            var n1 = try std.math.mul(T, r.p, q);
-            var n2 = try std.math.mul(T, r.q, p);
+            const d = try std.math.mul(T, r.q, q);
+            const n1 = try std.math.mul(T, r.p, q);
+            const n2 = try std.math.mul(T, r.q, p);
 
             r.p = try std.math.add(T, n1, n2);
             r.q = d;
@@ -203,7 +202,7 @@ pub fn Rational(comptime T: type) type {
 }
 
 // https://en.wikipedia.org/wiki/Euclidean_algorithm
-inline fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
+fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
     assert(p >= 1);
     assert(q >= 1);
 
@@ -234,6 +233,8 @@ test Rational {
         var r: Rational(t) = .{};
 
         var c: t = 128;
+        _ = &c;
+
         try r.update(c, 256);
         try doTurn(&r);
 
@@ -320,6 +321,8 @@ test BigRational {
     try r.reset();
 
     var c: u8 = 128;
+    _ = &c;
+
     try r.update(c, 256);
     try doTurn(&r);
 

package/src/lib/common/rng.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-const options = @import("./options.zig");
+const options = @import("options.zig");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
@@ -25,6 +25,11 @@ pub fn PRNG(comptime gen: comptime_int) type {
         pub fn next(self: *Self) Output(gen) {
             return self.src.next();
         }
+
+        pub fn advance(self: *Self, n: usize) void {
+            if (!options.advance) return;
+            for (0..n) |_| self.src.advance();
+        }
     };
 }
 
@@ -61,11 +66,15 @@ pub const PSRNG = extern struct {
             (@as(u64, self.range(u16, 0, 0x10000)) << 16) |
             (@as(u64, self.range(u16, 0, 0x10000)));
     }
+
+    pub fn Bound(comptime T: type) type {
+        return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
+    }
 };
 
 test PSRNG {
     var psrng: PSRNG = .{ .src = .{ .seed = 0x0001000200030004 } };
-    try expectEqual(@as(u8, 121), psrng.range(u8, 0, 256));
+    try expectEqual(121, psrng.range(u8, 0, 256));
     try expectEqual(false, psrng.chance(u8, 128, 256)); // 226 < 128
 }
 
@@ -89,6 +98,10 @@ pub const Gen12 = extern struct {
         self.index = (self.index + 1) % 9;
         return val;
     }
+
+    pub fn advance(self: *Gen12) void {
+        _ = self.next();
+    }
 };
 
 test Gen12 {
@@ -98,9 +111,9 @@ test Gen12 {
         try expectEqual(e, rng.next());
     }
 
-    try expectEqual(@as(u8, 16), Gen12.percent(6) + 1);
-    try expectEqual(@as(u8, 16), Gen12.percent(7) - 1);
-    try expectEqual(@as(u8, 128), Gen12.percent(50) + 1);
+    try expectEqual(16, Gen12.percent(6) + 1);
+    try expectEqual(16, Gen12.percent(7) - 1);
+    try expectEqual(128, Gen12.percent(50) + 1);
 }
 
 // https://pkmn.cc/pokeemerald/src/random.c
@@ -188,7 +201,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             for (0..n) |_| _ = self.next();
         }
 
-        pub fn range(self: *Self, comptime T: type, from: T, to: Bound(T)) T {
+        pub fn range(self: *Self, comptime T: type, from: T, to: PSRNG.Bound(T)) T {
             assert(showdown);
             return @intCast(@as(u64, self.next()) * (to - from) / divisor + from);
         }
@@ -197,7 +210,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             self: *Self,
             comptime T: type,
             numerator: T,
-            denominator: Bound(T),
+            denominator: PSRNG.Bound(T),
         ) bool {
             assert(showdown);
             assert(denominator > 0);
@@ -228,7 +241,3 @@ fn Output(comptime gen: comptime_int) type {
         else => unreachable,
     };
 }
-
-fn Bound(comptime T: type) type {
-    return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
-}

package/src/lib/gen1/calc.zig

@@ -38,6 +38,9 @@ const Duration = chance.Duration;
 
 const Rolls = helpers.Rolls;
 
+const tty = true; // DEBUG
+const summary = false; // DEBUG
+
 /// Information relevant to damage calculation that occured during a Generation I battle `update`.
 pub const Summaries = extern struct {
     /// Relevant information for Player 1.
@@ -50,7 +53,7 @@ pub const Summaries = extern struct {
     }
 
     /// Returns the `Summary` for the given `player`.
-    pub inline fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Summary) {
+    pub fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Summary) {
         assert(@typeInfo(@TypeOf(self)).Pointer.child == Summaries);
         return if (player == .P1) &self.p1 else &self.p2;
     }
@@ -201,6 +204,8 @@ pub const Options = struct {
     metronome: bool = false,
 };
 
+pub const MAX_FRONTIER = 14;
+
 pub fn transitions(
     battle: anytype,
     c1: Choice,
@@ -211,8 +216,8 @@ pub fn transitions(
 ) !?Stats {
     var stats: Stats = .{};
 
-    var actions = options.actions;
-    var cap = options.cap;
+    const actions = options.actions;
+    const cap = options.cap;
 
     var seen = std.AutoHashMap(Actions, void).init(allocator);
     defer seen.deinit();
@@ -232,8 +237,8 @@ pub fn transitions(
     _ = try b.update(c1, c2, &opts);
     stats.updates += 1;
 
-    var p1 = b.side(.P1);
-    var p2 = b.side(.P2);
+    const p1 = b.side(.P1);
+    const p2 = b.side(.P2);
 
     var p: Rational(u128) = .{ .p = 0, .q = 1 };
     try frontier.append(opts.chance.actions);
@@ -247,13 +252,13 @@ pub fn transitions(
     var i: usize = 0;
     assert(frontier.items.len == 1);
     while (i < frontier.items.len) : (i += 1) {
-        var template = frontier.items[i];
+        const template = frontier.items[i];
         opts.calc.overrides.durations = .{
             .p1 = template.p1.durations,
             .p2 = template.p2.durations,
         };
 
-        try debug(writer, template, true, .{ .color = i, .bold = true, .background = true });
+        try debug(writer, template, true, .{ .color = i, .bold = true, .background = true, .indent = false });
 
         var a: Actions = .{ .p1 = .{ .metronome = p1_move }, .p2 = .{ .metronome = p2_move } };
 
@@ -281,7 +286,7 @@ pub fn transitions(
         for (Rolls.moveSlot(template.p1, p1_hit)) |p1_slot| { a.p1.move_slot = p1_slot;
         for (Rolls.moveSlot(template.p2, p2_hit)) |p2_slot| { a.p2.move_slot = p2_slot;
         for (Rolls.multiHit(template.p1, p1_hit)) |p1_multi| { a.p1.multi_hit = p1_multi;
-        for (Rolls.multiHit(template.p2, p1_hit)) |p2_multi| { a.p2.multi_hit = p2_multi;
+        for (Rolls.multiHit(template.p2, p2_hit)) |p2_multi| { a.p2.multi_hit = p2_multi;
         for (Rolls.secondaryChance(template.p1, p1_hit)) |p1_sec| { a.p1.secondary_chance = p1_sec;
         for (Rolls.secondaryChance(template.p2, p2_hit)) |p2_sec| { a.p2.secondary_chance = p2_sec;
         for (Rolls.criticalHit(template.p1, p1_hit)) |p1_crit| { a.p1.critical_hit = p1_crit;
@@ -308,21 +313,21 @@ pub fn transitions(
                 const p2_max: u8 = @intCast(p2_dmg.min);
                 _ = cap;
 
-                // var p1_max = if (p1_min != 0) p1_min else
-                //     try Rolls.coalesce(.P1, @intCast(u8, p1_dmg.min), &opts.calc.summaries, cap);
-                // var p2_max =
-                //     try Rolls.coalesce(.P2, @intCast(u8, p2_dmg.min), &opts.calc.summaries, cap);
+                // const p1_max = if (p1_min != 0) p1_min else
+                //     try Rolls.coalesce(.P1, @as(u8, @intCast(p1_dmg.min)), &opts.calc.summaries, cap);
+                // const p2_max =
+                //     try Rolls.coalesce(.P2, @as(u8, @intCast(p2_dmg.min)), &opts.calc.summaries, cap);
 
                 if (opts.chance.actions.matches(template)) {
                     if (!opts.chance.actions.eql(a)) {
-                        try debug(writer, opts.chance.actions, false, .{ .color = i, .dim = true });
+                        if (!summary) try debug(writer, opts.chance.actions, false, .{ .color = i, .dim = true });
 
                         p1_min = p1_max;
                         p2_dmg.min = p2_max;
                         continue;
                     }
 
-                    try debug(writer, opts.chance.actions, false, .{ .color = i });
+                    if (!summary) try debug(writer, opts.chance.actions, false, .{ .color = i });
 
                     for (p1_dmg.min..@as(u9, p1_max) + 1) |p1d| {
                         for (p2_dmg.min..@as(u9, p2_max) + 1) |p2d| {
@@ -346,17 +351,25 @@ pub fn transitions(
                         return error.TestUnexpectedResult;
                     }
                 } else {
-                    try debug(writer, opts.chance.actions, false, .{ .dim = true });
+
 
                     if (!matches(opts.chance.actions, i, frontier.items)) {
                         try frontier.append(opts.chance.actions);
 
+                        try debug(writer, opts.chance.actions, false, .{ .dim = true, .newline = false });
+                        try writer.writeAll(" → ");
                         try debug(writer, opts.chance.actions, true, .{
                             .color = frontier.items.len - 1,
                             .dim = true,
-                            .background = true
+                            .background = true,
+                            .indent = false,
                         });
+                    } else if (!summary) {
+                        try debug(writer, opts.chance.actions, false, .{ .dim = true });
                     }
+
+                    // if (opts.chance.actions.p1.damage == 0) p1_max = 255;
+                    // if (opts.chance.actions.p2.damage == 0) p2_max = 255;
                 }
 
                 p1_min = p1_max;
@@ -367,6 +380,12 @@ pub fn transitions(
             p1_dmg.min = p1_min;
 
         }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
+
+        if (@TypeOf(writer) != @TypeOf(std.io.null_writer)) {
+            p.reduce();
+            try writer.print("  = {s} ({d:.2}%)\n\n", .{p, 100 * @as(f128, @floatFromInt(p.p)) / @as(f128, @floatFromInt(p.q))});
+        }
+
     }
 
     assert(frontier.items.len == i);
@@ -387,7 +406,86 @@ pub fn transitions(
     return stats;
 }
 
-inline fn matches(actions: Actions, i: usize, frontier: []Actions) bool {
+pub fn update(
+    battle: anytype,
+    c1: Choice,
+    c2: Choice,
+    options: anytype,
+    allocator: std.mem.Allocator,
+    writer: anytype,
+    transition: bool,
+) !Result {
+    options.chance.reset();
+
+    if (!pkmn.options.chance or !pkmn.options.calc or @TypeOf(battle.rng) != data.PRNG) {
+        return battle.update(c1, c2, options);
+    }
+
+    var copy = battle.*;
+    const actions = options.chance.actions;
+
+    // Perfom the actual update
+    const result = battle.update(c1, c2, options);
+
+    // Ensure we can encode the diffs in less than MAX_DIFFS bytes.
+    var buf: [helpers.MAX_DIFFS]u8 = undefined;
+    var stream: protocol.ByteStream = .{ .buffer = &buf };
+    const n = try helpers.diff(&copy, battle, stream.writer());
+
+    // Applying the diff to the battle should take us back to the original copy
+    // of the battle (ignoring the RNG).
+    var patched = battle.*;
+    patched.rng = copy.rng;
+    helpers.patch(&patched, buf[0..n]);
+    try expectEqual(copy, patched);
+
+    if (!pkmn.options.chance or !pkmn.options.calc) return result;
+
+    if (transition) {
+        // Ensure we can generate all transitions from the same original state
+        // (we must change the battle's RNG from a FixedRNG to a PRNG because
+        // the transitions function relies on RNG for discovery of states)
+        if (try transitions(unfix(copy), c1, c2, allocator, writer, .{
+            .actions = actions,
+            .cap = true,
+        })) |stats| try expect(stats.frontier <= MAX_FRONTIER);
+    }
+
+    // Demonstrate that we can produce the same state by forcing the RNG to behave the
+    // same as we observed - note that because we do not pass in a durations override
+    // mask none of the durations will be extended.
+    var override = pkmn.battle.options(
+        protocol.NULL,
+        chance.NULL,
+        Calc{ .overrides = .{ .actions = actions } },
+    );
+    const overridden = copy.update(c1, c2, &override);
+    try expectEqual(result, overridden);
+
+    // The actual battle excluding its RNG field should match a copy updated with
+    // overridden RNG (the copy RNG may have advanced because of no-ops)
+    copy.rng = battle.rng;
+    try expectEqual(copy, battle.*);
+
+    return result;
+}
+
+fn unfix(actual: anytype) data.Battle(data.PRNG) {
+    return .{
+        .sides = actual.sides,
+        .turn = actual.turn,
+        .last_damage = actual.last_damage,
+        .last_moves = actual.last_moves,
+        .rng = .{ .src = .{
+            .seed = if (pkmn.options.showdown)
+                0x12345678
+            else
+                .{ 123, 234, 56, 78, 9, 101, 112, 131, 4 },
+        } },
+    };
+}
+
+fn matches(actions: Actions, i: usize, frontier: []Actions) bool {
     for (frontier, 0..) |f, j| {
         // TODO: is skipping this redundant check worth it?
         if (i == j) continue;
@@ -408,19 +506,24 @@ const Style = struct {
     bold: bool = false,
     background: bool = false,
     dim: bool = false,
+    newline: bool = true,
+    indent: bool = true,
 };
 
 fn debug(writer: anytype, actions: Actions, shape: bool, style: Style) !void {
-    _ = .{ writer, actions, shape, style };
-    // const mod: usize = if (style.dim) 2 else 1;
-    // const background: usize = if (style.background) 4 else 3;
-    // const color: usize = if (style.color) |c| (c % 6) + 1 else 7;
-    // if (style.dim or style.bold) try writer.print("\x1b[{d}m", .{mod});
-    // try writer.print("\x1b[{d}{d}m", .{ background, color });
-    // try actions.fmt(writer, shape);
-    // try writer.writeAll("\x1b[0m\n");
-    // DEBUG
-    // if (style.dim) try writer.writeAll("    ");
-    // try actions.fmt(writer, shape);
-    // try writer.writeByte('\n');
+    if (style.indent) try writer.writeAll("  ");
+    if (tty) {
+        const mod: usize = if (style.dim) 2 else 1;
+        const background: usize = if (style.background) 4 else 3;
+        const color: usize = if (style.color) |c| (c % 6) + 1 else 7;
+
+        if (style.dim or style.bold) try writer.print("\x1b[{d}m", .{mod});
+        try writer.print("\x1b[{d}{d}m", .{ background, color });
+        try actions.fmt(writer, shape);
+        try writer.writeAll("\x1b[0m");
+    } else {
+        if (style.dim) try writer.writeAll("  ");
+        try actions.fmt(writer, shape);
+    }
+    if (style.newline) try writer.writeByte('\n');
 }