@pkmn/engine 0.1.0-dev.cbdbb719 → 0.1.0-dev.cdc837af

package/src/lib/gen1/calc.zig

@@ -1,41 +1,36 @@
-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 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 enabled = pkmn.options.calc;
-
-const Player = common.Player;
-const Result = common.Result;
-const Choice = common.Choice;
-
+const isPointerTo = util.isPointerTo;
+const Observation = chance.Observation;
 const Optional = optional.Optional;
-
-const Rational = rational.Rational;
-
+const Player = common.Player;
 const PointerType = util.PointerType;
-const isPointerTo = util.isPointerTo;
-
-const Actions = chance.Actions;
-const Action = chance.Action;
-const Chance = chance.Chance;
-const Durations = chance.Durations;
+const Rational = rational.Rational;
+const Result = common.Result;
+const Sleeps = chance.Sleeps;
 
 const tty = true; // DEBUG
 const summary = false; // DEBUG
@@ -115,6 +110,14 @@ pub const Calc = struct {
         }) val else null;
     }
 
+    pub fn confusion(self: *Calc, player: Player) void {
+        if (!enabled) return;
+
+        if (self.overrides.get(player).confusion == .started) {
+            self.overrides.get(player).confusion = .None;
+        }
+    }
+
     pub fn base(self: *Calc, player: Player, val: u16) void {
         if (!enabled) return;
 
@@ -148,6 +151,10 @@ const Null = struct {
         return null;
     }
 
+    pub fn confusion(self: Null, player: Player) void {
+        _ = .{ self, player };
+    }
+
     pub fn base(self: Null, player: Player, val: u16) void {
         _ = .{ self, player, val };
     }
@@ -175,7 +182,7 @@ pub const Options = struct {
     metronome: bool = false,
 };
 
-pub const MAX_FRONTIER = 19;
+pub const MAX_FRONTIER = 81;
 
 pub fn transitions(
     battle: anytype,
@@ -194,9 +201,11 @@ pub fn transitions(
     var frontier = std.ArrayList(Actions).init(allocator);
     defer frontier.deinit();
 
+    const d = options.durations;
+
     var opts = pkmn.battle.options(
         protocol.NULL,
-        Chance(Rational(u128)){ .probability = .{}, .durations = options.durations },
+        Chance(Rational(u128)){ .probability = .{}, .durations = d },
         Calc{},
     );
 
@@ -220,6 +229,7 @@ pub fn transitions(
     assert(frontier.items.len == 1);
     while (i < frontier.items.len) : (i += 1) {
         const f = frontier.items[i];
+        const saved = stats.saved;
 
         try debug(writer, f, .{
             .shape = true,
@@ -235,10 +245,20 @@ pub fn transitions(
         };
 
         for (Rolls.speedTie(f.p1)) |tie| { a.p1.speed_tie = tie; a.p2.speed_tie = tie;
-        for (Rolls.confused(f.p1)) |p1_cfzd| { a.p1.confused = p1_cfzd;
-        for (Rolls.confused(f.p2)) |p2_cfzd| { a.p2.confused = p2_cfzd;
+        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, 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.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, 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;
@@ -266,7 +286,7 @@ pub fn transitions(
 
                 opts.calc.overrides = a;
                 opts.calc.summaries = .{};
-                opts.chance = .{ .probability = .{}, .durations = options.durations };
+                opts.chance = .{ .probability = .{}, .durations = d };
                 const q = &opts.chance.probability;
 
                 b = battle;
@@ -283,7 +303,7 @@ pub fn transitions(
                     try Rolls.coalesce(.P2, @as(u8, @intCast(p2_dmg.min)), summaries, cap);
 
                 if (opts.chance.actions.matches(f)) {
-                    if (!opts.chance.actions.eql(a)) {
+                    if (!opts.chance.actions.relax().eql(a)) {
                         if (!summary) {
                             try debug(writer, opts.chance.actions, .{
                                 .p1_max = p1_max,
@@ -317,10 +337,13 @@ 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();
+
                     stats.saved += 1;
 
                     if (p.q < p.p) {
@@ -328,7 +351,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, .{
@@ -358,9 +381,11 @@ pub fn transitions(
                 p2_dmg.min = p2_max;
             }
 
-        }}}}}}}}}}}}}}}}}}
+        }}}}}}}}}}}}}}}}}}}}}}}}}}}}
 
-        if (@TypeOf(writer) != @TypeOf(std.io.null_writer)) {
+        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",
@@ -496,15 +521,6 @@ fn unfix(actual: anytype) data.Battle(data.PRNG) {
     };
 }
 
-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;
@@ -577,8 +593,6 @@ fn format(writer: anytype, actions: Actions, p1: u9, p2: u9) !void {
     try writer.writeAll(output[0..len]);
 }
 
-const NONE = @intFromEnum(Optional(bool).None);
-
 /// Helper functions that efficiently return valid ranges for various RNG events based on the
 /// state of an `Action` and other events to be used to construct a "transitions" function.
 pub const Rolls = struct {
@@ -590,6 +604,108 @@ pub const Rolls = struct {
         return if (action.speed_tie == .None) &PLAYER_NONE else &PLAYERS;
     }
 
+    const OBS_NONE = [_]Optional(Observation){.None};
+    const OBS_STARTED = [_]Optional(Observation){.started};
+    const OBS_CONTINUING = [_]Optional(Observation){.continuing};
+    const OBS_ENDED = [_]Optional(Observation){.ended};
+    const OBS_ALL = [_]Optional(Observation){ .started, .continuing, .ended };
+    const OBS = [_]Optional(Observation){ .continuing, .ended };
+
+    /// Returns a slice with a range of values for sleep given the `action` state and observed
+    /// `durations`.
+    pub fn sleep(action: Action, duration: Duration) []const Optional(Observation) {
+        if (action.sleep == .None) return &OBS_NONE;
+        return if (Sleeps.get(duration.sleeps, 0) == 0 and action.speed_tie != .None)
+            &OBS_ALL
+        else switch (action.sleep) {
+            .started => &OBS_STARTED,
+            else => if (Sleeps.get(duration.sleeps, 0) >= 7) &OBS_ENDED else &OBS,
+        };
+    }
+
+    /// Returns a slice with a range of values for disable given the `action`, observed `durations`,
+    /// and the state of the `parent` (observation of the player's Pokémon sleep status).
+    pub fn disable(
+        action: Action,
+        duration: Duration,
+        parent: Optional(Observation),
+    ) []const Optional(Observation) {
+        if (action.disable == .None) return &OBS_NONE;
+        return if (duration.disable == 0 and action.speed_tie != .None)
+            &OBS_ALL
+        else switch (action.disable) {
+            .started => &OBS_STARTED,
+            else => if (duration.disable >= 8)
+                &OBS_ENDED
+            else if (parent != .None and parent != .started)
+                &OBS_CONTINUING
+            else
+                &OBS,
+        };
+    }
+
+    /// 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 };
+
+    /// FIXME
+    pub fn confusion(
+        action: Action,
+        duration: Duration,
+        sibling: Optional(Observation),
+        parent: Optional(Observation),
+    ) []const Optional(Confusion) {
+        return switch (action.confusion) {
+            .None => &CFZ_NONE,
+            .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 == .continuing and parent == .ended) or duration.confusion < 2)
+                &CFZ_CONTINUING
+            else
+                &CFZ,
+        };
+    }
+
+    /// 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(
+        action: Action,
+        duration: Duration,
+        parent: Optional(bool),
+    ) []const Optional(Observation) {
+        if (parent == .true) return &OBS_NONE;
+        return switch (action.binding) {
+            .None => &OBS_NONE,
+            .started => &OBS_STARTED,
+            else => if (duration.binding >= 4) &OBS_ENDED else &OBS,
+        };
+    }
+
     const BOOL_NONE = [_]Optional(bool){.None};
     const BOOLS = [_]Optional(bool){ .false, .true };
 
@@ -603,7 +719,7 @@ pub const Rolls = struct {
     /// 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) {
-        if (parent == .false) return &BOOL_NONE;
+        if (pkmn.options.showdown and parent == .false) return &BOOL_NONE;
         return if (action.critical_hit == .None) &BOOL_NONE else &BOOLS;
     }
 
@@ -638,9 +754,11 @@ pub const Rolls = struct {
         return @min(255, roll + ((254 - ((@as(u32, dmg.base) * roll) % 255)) / dmg.base));
     }
 
-    /// Returns a slice with the correct range of values for confused.
-    pub fn confused(action: Action) []const Optional(bool) {
-        return if (action.confused == .None) &BOOL_NONE else &BOOLS;
+    /// Returns a slice with the correct range of values for confused given the `action` state and
+    /// the state of the `parent` (observation of the player's Pokémon confusion status).
+    pub fn confused(action: Action, parent: Optional(Confusion)) []const Optional(bool) {
+        const done = parent == .None or parent == .ended;
+        return if (done or action.confused == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for paralysis given the `action` state
@@ -707,6 +825,26 @@ test "Rolls.speedTie" {
     try expectEqualSlices(Optional(Player), &.{.None}, Rolls.speedTie(actions.p2));
 }
 
+test "Rolls.sleep" {
+    return error.SkipZigTest; // TODO
+}
+
+test "Rolls.disable" {
+    return error.SkipZigTest; // TODO
+}
+
+test "Rolls.confusion" {
+    return error.SkipZigTest; // TODO
+}
+
+test "Rolls.atacking" {
+    return error.SkipZigTest; // TODO
+}
+
+test "Rolls.binding" {
+    return error.SkipZigTest; // TODO
+}
+
 test "Rolls.damage" {
     const actions: Actions = .{ .p2 = .{ .damage = 221 } };
     try expectEqual(Rolls.Range{ .min = 0, .max = 1 }, Rolls.damage(actions.p1, .None));
@@ -750,14 +888,23 @@ test "Rolls.criticalHit" {
         &.{ .false, .true },
         Rolls.criticalHit(actions.p1, .None),
     );
-    try expectEqualSlices(Optional(bool), &.{.None}, Rolls.criticalHit(actions.p1, .false));
+    try expectEqualSlices(
+        Optional(bool),
+        if (pkmn.options.showdown) &.{.None} else &.{ .false, .true },
+        Rolls.criticalHit(actions.p1, .false),
+    );
     try expectEqualSlices(Optional(bool), &.{.None}, Rolls.criticalHit(actions.p2, .None));
 }
 
 test "Rolls.confused" {
     const actions: Actions = .{ .p2 = .{ .confused = .true } };
-    try expectEqualSlices(Optional(bool), &.{.None}, Rolls.confused(actions.p1));
-    try expectEqualSlices(Optional(bool), &.{ .false, .true }, Rolls.confused(actions.p2));
+    try expectEqualSlices(Optional(bool), &.{.None}, Rolls.confused(actions.p1, .None));
+    try expectEqualSlices(
+        Optional(bool),
+        &.{ .false, .true },
+        Rolls.confused(actions.p2, .continuing),
+    );
+    try expectEqualSlices(Optional(bool), &.{.None}, Rolls.confused(actions.p2, .ended));
 }
 
 test "Rolls.paralyzed" {

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);
@@ -224,7 +240,7 @@ pub const Action = packed struct(u64) {
 };
 
 /// TODO
-pub const Durations = struct {
+pub const Durations = extern struct {
     /// TODO
     p1: Duration = .{},
     /// TODO
@@ -251,7 +267,7 @@ pub const Durations = struct {
     }
 };
 
-const Sleeps = Array(6, u3);
+pub const Sleeps = Array(6, u3);
 
 /// TODO
 pub const Duration = packed struct(u32) {
@@ -375,7 +391,7 @@ pub fn Chance(comptime Rational: type) type {
 
             // 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
+            // "critical hit" was spurious or not as moves that do 1 or less damage don't roll 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).
             //
@@ -391,7 +407,7 @@ pub fn Chance(comptime Rational: type) type {
                 action.critical_hit = if (self.pending.crit) .true else .false;
             } else assert(!self.pending.glitch);
 
-            if (self.pending.damage_roll > 0) {
+            if (self.pending.damage_roll > 0 and (!self.pending.glitch or self.pending.hit)) {
                 try self.probability.update(1, 39);
                 action.damage = self.pending.damage_roll;
             }
@@ -656,6 +672,7 @@ pub fn Chance(comptime Rational: type) type {
             var d = self.durations.get(player);
             const n = d.attacking;
             if (obs == .ended) {
+                // "3-4 turns" includes the turn for the initial attack *plus* the forced attacks
                 assert(n >= 2 and n <= 3);
                 if (n != 3) try self.probability.update(1, 4 - @as(u4, n));
                 d.attacking = 0;
@@ -682,6 +699,7 @@ pub fn Chance(comptime Rational: type) type {
             const q: u4 = if (n < 3) 8 - ((n - 1) * p) else 2;
 
             if (obs == .ended) {
+                // "2-5 turns" includes the turn for the initial attack *plus* the forced attacks
                 assert(n >= 1 and n <= 4);
                 if (n != 4) try self.probability.update(p, q);
                 d.binding = 0;

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;
@@ -256,7 +252,7 @@ pub const Status = enum(u8) {
 
     pub const TOX = 0b10001000;
 
-    const SLP = 0b111;
+    const SLEEP = 0b111;
 
     /// Whether or not the status `num` is the same as `status`.
     pub fn is(num: u8, status: Status) bool {
@@ -284,7 +280,7 @@ pub const Status = enum(u8) {
 
     /// Returns the duration of a sleep status.
     pub fn duration(num: u8) u3 {
-        return @intCast(num & SLP);
+        return @intCast(num & SLEEP);
     }
 
     /// Returns whether `num` reflects any status.

package/src/lib/gen1/helpers.zig

@@ -1,30 +1,21 @@
-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 Player = common.Player;
-
-const showdown = options.showdown;
-const chance = options.chance;
-
-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;
-const Status = data.Status;
 
 const endian = builtin.cpu.arch.endian();
 
@@ -269,14 +260,7 @@ 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,
+        .Haze,
         .Metronome,
         => true,
         else => false,