@pkmn/engine 0.1.0-dev.a1fcc5d9 → 0.1.0-dev.a27b3ff3

package/src/lib/gen1/calc.zig

@@ -1,44 +1,35 @@
-const std = @import("std");
-
-const pkmn = @import("../pkmn.zig");
+const DEBUG = @import("../common/debug.zig").print;
 
+const chance = @import("chance.zig");
 const common = @import("../common/data.zig");
-const DEBUG = @import("../common/debug.zig").print;
+const data = @import("data.zig");
+const helpers = @import("helpers.zig");
 const optional = @import("../common/optional.zig");
+const pkmn = @import("../pkmn.zig");
 const protocol = @import("../common/protocol.zig");
 const rational = @import("../common/rational.zig");
+const std = @import("std");
 const util = @import("../common/util.zig");
 
-const chance = @import("chance.zig");
-const data = @import("data.zig");
-const helpers = @import("helpers.zig");
-
-const assert = std.debug.assert;
-
-const expect = std.testing.expect;
-const expectEqual = std.testing.expectEqual;
-const expectEqualSlices = std.testing.expectEqualSlices;
-
-const enabled = pkmn.options.calc;
-
-const Player = common.Player;
-const Result = common.Result;
-const Choice = common.Choice;
-
-const Optional = optional.Optional;
-
-const Rational = rational.Rational;
-
-const PointerType = util.PointerType;
-const isPointerTo = util.isPointerTo;
-
-const Actions = chance.Actions;
 const Action = chance.Action;
+const Actions = chance.Actions;
+const assert = std.debug.assert;
 const Chance = chance.Chance;
+const Choice = common.Choice;
 const Confusion = chance.Confusion;
 const Duration = chance.Duration;
 const Durations = chance.Durations;
+const enabled = pkmn.options.calc;
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const expectEqualSlices = std.testing.expectEqualSlices;
+const isPointerTo = util.isPointerTo;
 const Observation = chance.Observation;
+const Optional = optional.Optional;
+const Player = common.Player;
+const PointerType = util.PointerType;
+const Rational = rational.Rational;
+const Result = common.Result;
 const Sleeps = chance.Sleeps;
 
 const tty = true; // DEBUG
@@ -108,7 +99,7 @@ pub const Calc = struct {
         self: Calc,
         player: Player,
         comptime field: Action.Field,
-    ) ?std.meta.FieldType(Action, field) {
+    ) ?util.FieldType(Action, field) {
         if (!enabled) return null;
 
         const val = @field(self.overrides.get(player), @tagName(field));
@@ -155,7 +146,7 @@ const Null = struct {
         self: Null,
         player: Player,
         comptime field: Action.Field,
-    ) ?std.meta.FieldType(Action, field) {
+    ) ?util.FieldType(Action, field) {
         _ = .{ self, player };
         return null;
     }
@@ -191,7 +182,7 @@ pub const Options = struct {
     metronome: bool = false,
 };
 
-pub const MAX_FRONTIER = 67;
+pub const MAX_FRONTIER = 83;
 
 pub fn transitions(
     battle: anytype,
@@ -225,7 +216,7 @@ pub fn transitions(
     const p1 = b.side(.P1);
     const p2 = b.side(.P2);
 
-    var p: Rational(u128) = .{ .p = 0, .q = 1 };
+    var p: Rational(u256) = .{ .p = 0, .q = 1 };
     try frontier.append(opts.chance.actions);
 
     // zig fmt: off
@@ -240,6 +231,8 @@ pub fn transitions(
         const f = frontier.items[i];
         const saved = stats.saved;
 
+        var r: Rational(u256) = .{ .p = 0, .q = 1 };
+
         try debug(writer, f, .{
             .shape = true,
             .color = i,
@@ -260,8 +253,8 @@ pub fn transitions(
         for (Rolls.disable(f.p2, d.p2, p2_slp)) |p2_dis| { a.p2.disable = p2_dis;
         for (Rolls.attacking(f.p1, d.p1, p1_slp)) |p1_atk| { a.p1.attacking = p1_atk;
         for (Rolls.attacking(f.p2, d.p2, p2_slp)) |p2_atk| { a.p2.attacking = p2_atk;
-        for (Rolls.confusion(f.p1, d.p1, p1_atk, p1_slp)) |p1_cfz| { a.p1.confusion = p1_cfz;
-        for (Rolls.confusion(f.p2, d.p2, p2_atk, p2_slp)) |p2_cfz| { a.p2.confusion = p2_cfz;
+        for (Rolls.confusion(f.p1, d.p1, tie, p1_atk, p1_slp)) |p1_cfz| { a.p1.confusion = p1_cfz;
+        for (Rolls.confusion(f.p2, d.p2, tie, p2_atk, p2_slp)) |p2_cfz| { a.p2.confusion = p2_cfz;
         for (Rolls.confused(f.p1, p1_cfz)) |p1_cfzd| { a.p1.confused = p1_cfzd;
         for (Rolls.confused(f.p2, p2_cfz)) |p2_cfzd| { a.p2.confused = p2_cfzd;
         for (Rolls.paralyzed(f.p1, p1_cfzd)) |p1_par| { a.p1.paralyzed = p1_par;
@@ -307,12 +300,12 @@ pub fn transitions(
                 const p1_max: u9 = if (p2_dmg.min != p2_min)
                     p1_dmg.min
                 else
-                    try Rolls.coalesce(.P1, @as(u8, @intCast(p1_dmg.min)), summaries, cap);
+                    Rolls.coalesce(.P1, @as(u8, @intCast(p1_dmg.min)), summaries, cap);
                 const p2_max: u9 =
-                    try Rolls.coalesce(.P2, @as(u8, @intCast(p2_dmg.min)), summaries, cap);
+                    Rolls.coalesce(.P2, @as(u8, @intCast(p2_dmg.min)), summaries, cap);
 
                 if (opts.chance.actions.matches(f)) {
-                    if (!map(opts.chance.actions).eql(a)) {
+                    if (!opts.chance.actions.relax().eql(a)) {
                         if (!summary) {
                             try debug(writer, opts.chance.actions, .{
                                 .p1_max = p1_max,
@@ -352,6 +345,8 @@ pub fn transitions(
                     q.reduce();
                     try p.add(q);
                     p.reduce();
+                    try r.add(q);
+                    r.reduce();
 
                     stats.saved += 1;
 
@@ -360,7 +355,7 @@ pub fn transitions(
                         return error.TestUnexpectedResult;
                     }
                 } else {
-                    if (!matches(opts.chance.actions, i, frontier.items)) {
+                    if (!opts.chance.actions.matchesAny(frontier.items, i)) {
                         try frontier.append(opts.chance.actions);
 
                         try debug(writer, opts.chance.actions, .{
@@ -393,14 +388,15 @@ pub fn transitions(
         }}}}}}}}}}}}}}}}}}}}}}}}}}}}
 
         assert(stats.saved > saved);
-        const old = @hasDecl(std.fmt, "formatFloatDecimal");
-        if (!old and @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))},
-            );
-        }
+        // TODO: ziglang/zig#22667
+        // const old = @hasDecl(std.fmt, "formatFloatDecimal");
+        // if (!old and @TypeOf(writer) != @TypeOf(std.io.null_writer)) {
+        //     try writer.print(
+        //         "    {} ({d:.2}%)\n  = ──────────\n    {} ({d:.2}%)\n\n",
+        //         .{r, 100 * @as(f128, @floatFromInt(r.p)) / @as(f128, @floatFromInt(r.q)),
+        //           p, 100 * @as(f128, @floatFromInt(p.p)) / @as(f128, @floatFromInt(p.q))},
+        //     );
+        // }
 
     }
 
@@ -530,23 +526,6 @@ fn unfix(actual: anytype) data.Battle(data.PRNG) {
     };
 }
 
-fn map(actions: Actions) Actions {
-    if (!pkmn.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;
-}
-
-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;
-        if (f.matches(actions)) return true;
-    }
-    return false;
-}
-
 fn err(comptime fmt: []const u8, v: anytype, seed: ?u64) void {
     const w = std.io.getStdErr().writer();
     w.print(fmt, v) catch return;
@@ -694,11 +673,13 @@ pub const Rolls = struct {
     const CFZ_CONTINUING = [_]Optional(Confusion){.continuing};
     const CFZ_ENDED = [_]Optional(Confusion){.ended};
     const CFZ = [_]Optional(Confusion){ .continuing, .ended };
+    const CFZ_TIE = [_]Optional(Confusion){ .started, .continuing, .ended };
 
     /// FIXME
     pub fn confusion(
         action: Action,
         duration: Duration,
+        tie: Optional(Player),
         sibling: Optional(Observation),
         parent: Optional(Observation),
     ) []const Optional(Confusion) {
@@ -712,6 +693,8 @@ pub const Rolls = struct {
                 &CFZ_ENDED
             else if ((parent == .continuing and parent == .ended) or duration.confusion < 2)
                 &CFZ_CONTINUING
+            else if (tie != .None)
+                &CFZ_TIE
             else
                 &CFZ,
         };
@@ -770,7 +753,7 @@ pub const Rolls = struct {
 
     /// Returns the max damage roll which will produce the same damage as `roll`
     /// given the base damage in `summaries`.
-    pub fn coalesce(player: Player, roll: u8, summaries: *Summaries, cap: bool) !u8 {
+    pub fn coalesce(player: Player, roll: u8, summaries: *Summaries, cap: bool) u8 {
         if (roll == 0) return roll;
 
         const dmg = summaries.get(player.foe()).damage;
@@ -880,12 +863,12 @@ test "Rolls.damage" {
 
 test "Rolls.coalesce" {
     var summaries = Summaries{ .p1 = .{ .damage = .{ .base = 74, .final = 69, .capped = true } } };
-    try expectEqual(@as(u8, 0), try Rolls.coalesce(.P2, 0, &summaries, false));
-    try expectEqual(@as(u8, 241), try Rolls.coalesce(.P2, 238, &summaries, false));
-    try expectEqual(@as(u8, 255), try Rolls.coalesce(.P2, 238, &summaries, true));
+    try expectEqual(@as(u8, 0), Rolls.coalesce(.P2, 0, &summaries, false));
+    try expectEqual(@as(u8, 241), Rolls.coalesce(.P2, 238, &summaries, false));
+    try expectEqual(@as(u8, 255), Rolls.coalesce(.P2, 238, &summaries, true));
     summaries.p1.damage.final = 74;
-    try expectEqual(@as(u8, 217), try Rolls.coalesce(.P2, 217, &summaries, false));
-    try expectEqual(@as(u8, 255), try Rolls.coalesce(.P2, 217, &summaries, true));
+    try expectEqual(@as(u8, 217), Rolls.coalesce(.P2, 217, &summaries, false));
+    try expectEqual(@as(u8, 255), Rolls.coalesce(.P2, 217, &summaries, true));
 }
 
 test "Rolls.hit" {

package/src/lib/gen1/chance.zig

@@ -1,30 +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 Optional = optional.Optional;
+const Player = common.Player;
+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;
@@ -75,6 +72,25 @@ pub const Actions = extern struct {
         return true;
     }
 
+    /// 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: anytype, shape: bool) !void {
         try writer.writeAll("<P1 = ");
         try self.p1.fmt(writer, shape);

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);

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;

package/src/lib/gen1/helpers.zig

@@ -1,25 +1,19 @@
-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;