@pkmn/engine 0.1.0-dev.0cabf16e → 0.1.0-dev.0f9e9648

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 = 49;
+pub const MAX_FRONTIER = 81;
 
 pub fn transitions(
     battle: anytype,
@@ -210,11 +201,11 @@ pub fn transitions(
     var frontier = std.ArrayList(Actions).init(allocator);
     defer frontier.deinit();
 
-    const durations = options.durations;
+    const d = options.durations;
 
     var opts = pkmn.battle.options(
         protocol.NULL,
-        Chance(Rational(u128)){ .probability = .{}, .durations = durations },
+        Chance(Rational(u128)){ .probability = .{}, .durations = d },
         Calc{},
     );
 
@@ -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,
@@ -254,20 +247,20 @@ pub fn transitions(
         };
 
         for (Rolls.speedTie(f.p1)) |tie| { a.p1.speed_tie = tie; a.p2.speed_tie = tie;
-        for (Rolls.sleep(f.p1, durations.p1)) |p1_slp| { a.p1.sleep = p1_slp;
-        for (Rolls.sleep(f.p2, durations.p2)) |p2_slp| { a.p2.sleep = p2_slp;
-        for (Rolls.disable(f.p1, durations.p1, p1_slp)) |p1_dis| { a.p1.disable = p1_dis;
-        for (Rolls.disable(f.p2, durations.p2, p2_slp)) |p2_dis| { a.p2.disable = p2_dis;
-        for (Rolls.attacking(f.p1, durations.p1)) |p1_atk| { a.p1.attacking = p1_atk;
-        for (Rolls.attacking(f.p2, durations.p2)) |p2_atk| { a.p2.attacking = p2_atk;
-        for (Rolls.confusion(f.p1, durations.p1, p1_atk, p1_slp)) |p1_cfz| { a.p1.confusion = p1_cfz;
-        for (Rolls.confusion(f.p2, durations.p2, p2_atk, p2_slp)) |p2_cfz| { a.p2.confusion = p2_cfz;
+        for (Rolls.sleep(f.p1, d.p1)) |p1_slp| { a.p1.sleep = p1_slp;
+        for (Rolls.sleep(f.p2, d.p2)) |p2_slp| { a.p2.sleep = p2_slp;
+        for (Rolls.disable(f.p1, d.p1, p1_slp)) |p1_dis| { a.p1.disable = p1_dis;
+        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, 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;
         for (Rolls.paralyzed(f.p2, p2_cfzd)) |p2_par| { a.p2.paralyzed = p2_par;
-        for (Rolls.binding(f.p1, durations.p1, p1_par)) |p1_bind| { a.p1.binding = p1_bind;
-        for (Rolls.binding(f.p2, durations.p2, p2_par)) |p2_bind| { a.p2.binding = p2_bind;
+        for (Rolls.binding(f.p1, d.p1, p1_par)) |p1_bind| { a.p1.binding = p1_bind;
+        for (Rolls.binding(f.p2, d.p2, p2_par)) |p2_bind| { a.p2.binding = p2_bind;
         for (Rolls.hit(f.p1, p1_par)) |p1_hit| { a.p1.hit = p1_hit;
         for (Rolls.hit(f.p2, p2_par)) |p2_hit| { a.p2.hit = p2_hit;
         for (Rolls.psywave(f.p1, p1, p1_hit)) |p1_psywave| { a.p1.psywave = p1_psywave;
@@ -295,7 +288,7 @@ pub fn transitions(
 
                 opts.calc.overrides = a;
                 opts.calc.summaries = .{};
-                opts.chance = .{ .probability = .{}, .durations = durations };
+                opts.chance = .{ .probability = .{}, .durations = d };
                 const q = &opts.chance.probability;
 
                 b = battle;
@@ -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,
@@ -346,10 +339,15 @@ pub fn transitions(
                             }
                         }
                     }
-
                     if (p1_max != p1_min) try q.update(p1_max - p1_min + 1, 1);
                     if (p2_max != p2_dmg.min) try q.update(p2_max - p2_dmg.min + 1, 1);
+
+                    q.reduce();
                     try p.add(q);
+                    p.reduce();
+                    try r.add(q);
+                    r.reduce();
+
                     stats.saved += 1;
 
                     if (p.q < p.p) {
@@ -357,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, .{
@@ -390,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))},
+        //     );
+        // }
 
     }
 
@@ -527,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;
@@ -667,49 +649,57 @@ pub const Rolls = struct {
         };
     }
 
+    /// FIXME
+    pub fn attacking(
+        action: Action,
+        duration: Duration,
+        parent: Optional(Observation),
+    ) []const Optional(Observation) {
+        return switch (action.attacking) {
+            .None => &OBS_NONE,
+            .started => &OBS_STARTED,
+            else => if (duration.attacking >= 3)
+                &OBS_ENDED
+            else if ((parent == .continuing and parent == .ended) or duration.attacking < 2)
+                &OBS_CONTINUING
+            else
+                &OBS,
+        };
+    }
+
     const CFZ_NONE = [_]Optional(Confusion){.None};
     const CFZ_STARTED = [_]Optional(Confusion){.started};
     const CFZ_OVERWRITTEN = [_]Optional(Confusion){ .started, .overwritten };
     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) {
         return switch (action.confusion) {
             .None => &CFZ_NONE,
-            .started => if (sibling == .ended)
+            .started => if (pkmn.options.overwrite and sibling == .ended and duration.confusion < 5)
                 &CFZ_OVERWRITTEN
             else
                 &CFZ_STARTED,
             else => if (duration.confusion >= 5)
                 &CFZ_ENDED
-            else if ((parent != .None and parent != .started) or duration.confusion < 2)
+            else if ((parent == .continuing and parent == .ended) or duration.confusion < 2)
                 &CFZ_CONTINUING
+            else if (tie != .None)
+                &CFZ_TIE
             else
                 &CFZ,
         };
     }
 
-    /// FIXME
-    pub fn attacking(action: Action, duration: Duration) []const Optional(Observation) {
-        return switch (action.attacking) {
-            .None => &OBS_NONE,
-            .started => &OBS_STARTED,
-            else => if (duration.attacking >= 3)
-                &OBS_ENDED
-            else if (duration.attacking < 2)
-                &OBS_CONTINUING
-            else
-                &OBS,
-        };
-    }
-
     /// Returns a slice with a range of values for binding given the `action`, observed `durations`,
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
     pub fn binding(
@@ -763,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;
@@ -873,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;

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;
 
@@ -267,7 +261,6 @@ fn durations(m: Move) bool {
     // Any moves that have effects that result in duration tracking with -Dchance
     return switch (Move.get(m).effect) {
         .Haze,
-        .Thrashing,
         .Metronome,
         => true,
         else => false,