@pkmn/engine 0.1.0-dev.f4ba6ebd → 0.1.0-dev.f6545544

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,

package/src/lib/gen1/mechanics.zig

@@ -1,39 +1,29 @@
-const std = @import("std");
-
-const pkmn = @import("../pkmn.zig");
+const DEBUG = @import("../common/debug.zig").print;
 
+const builtin = @import("builtin");
+const chance = @import("chance.zig");
 const common = @import("../common/data.zig");
-const DEBUG = @import("../common/debug.zig").print;
-const optional = @import("../common/optional.zig");
+const data = @import("data.zig");
+const pkmn = @import("../pkmn.zig");
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
-
-const data = @import("data.zig");
-const chance = @import("chance.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
-const expectEqual = std.testing.expectEqual;
-
-const showdown = pkmn.options.showdown;
-
-const Choice = common.Choice;
-const ID = common.ID;
-const Player = common.Player;
-const Result = common.Result;
-
 const Boost = protocol.Boost;
+const Choice = common.Choice;
 const Damage = protocol.Damage;
+const Effectiveness = data.Effectiveness;
+const expectEqual = std.testing.expectEqual;
 const Fail = protocol.Fail;
-const Heal = protocol.Heal;
-
 const Gen12 = rng.Gen12;
-
-const ActivePokemon = data.ActivePokemon;
-const Effectiveness = data.Effectiveness;
+const Heal = protocol.Heal;
+const ID = common.ID;
 const Move = data.Move;
 const MoveSlot = data.MoveSlot;
-const Pokemon = data.Pokemon;
+const Player = common.Player;
+const Result = common.Result;
+const showdown = pkmn.options.showdown;
 const Side = data.Side;
 const Species = data.Species;
 const Stats = data.Stats;
@@ -176,7 +166,10 @@ fn selectMove(
             if (foe_choice.type == .Switch) {
                 const last = side.active.move(battle.lastMove(player).index);
                 if (last.id == .Metronome) side.last_selected_move = last.id;
-                if (last.id == .MirrorMove) return Result.Error;
+                if (last.id == .MirrorMove) {
+                    if (!pkmn.options.mod) return Result.Error;
+                    side.last_selected_move = last.id;
+                }
             }
         }
         return null;
@@ -427,7 +420,7 @@ fn executeMove(
         mslot = @intCast(battle.lastMove(player).index);
         const stored = side.stored();
         // GLITCH: Struggle bypass PP underflow via Hyper Beam / Trapping-switch auto selection
-        auto = isForced(&side.active) or
+        auto = pkmn.options.mod or isForced(&side.active) or
             side.active.volatiles.Binding or side.active.volatiles.Bide or
             side.last_selected_move == .HyperBeam or
             Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP);
@@ -460,6 +453,25 @@ fn executeMove(
         .err => return @as(?Result, Result.Error),
     }
 
+    // Pokémon Showdown incorrectly implements PP deduction when handling the Hyper Beam automatic
+    // selection glitch - if the move was proced due to Metronome / Mirror Move it either subtracts
+    // from the Hyper Beam slot if present or skips PP deduction entirely...
+    if (showdown and !skip_pp and side.last_selected_move == .HyperBeam and
+        side.last_selected_move != side.active.move(mslot).id)
+    {
+        assert(mslot == 1);
+        const has_beam = has_beam: {
+            for (side.active.moves, 0..) |m, i| {
+                if (m.id == .HyperBeam) {
+                    mslot = @intCast(i + 1);
+                    break :has_beam true;
+                }
+            }
+            break :has_beam false;
+        };
+        if (!has_beam) skip_pp = true;
+    }
+
     const can = skip_can or
         try canMove(battle, player, mslot, auto, skip_pp, .None, residual, options);
     if (!can) return null;
@@ -557,18 +569,17 @@ fn beforeMove(
     // This can only happen if a Pokémon started the battle frozen/sleeping and was thawed/woken
     // before the side had a selected a move - we simply need to assume this leads to a desync
     if (side.last_selected_move == .None) {
-        assert(!showdown);
+        assert(!pkmn.options.mod);
         return .err;
     }
 
     if (volatiles.Confusion) {
         assert(volatiles.confusion > 0);
         if (options.calc.overridden(player, .confusion)) |obs| switch (obs) {
-            .started => volatiles.confusion -= 1,
+            .started, .ended => volatiles.confusion = 0,
             .continuing => if (volatiles.confusion > 1) {
                 volatiles.confusion -= 1;
             },
-            .ended => volatiles.confusion = 0,
             .overwritten => {},
             else => unreachable,
         } else {
@@ -707,7 +718,11 @@ fn beforeMove(
             // can be expected to recognize this pattern and pass the information only to the
             // correct player)
             try log.start(.{ battle.active(player), .ConfusionSilent });
-            options.chance.observe(.confusion, player, if (overwritten) .overwritten else .started);
+            options.chance.observe(.confusion, player, if (overwritten)
+                if (pkmn.options.overwrite) .overwritten else .continuing
+            else
+                .started);
+            if (!overwritten) options.calc.confusion(player);
         }
 
         // This shouldn't actually set last_used_move, but Pokémon Showdown sets last
@@ -773,9 +788,14 @@ fn canMove(
 
     if (move.effect == .Thrashing) {
         Effects.thrashing(battle, player, options);
-    } else if (!showdown and move.effect == .Binding) {
-        // Pokémon Showdown handles this after hit/miss checks and damage calculation
-        try Effects.binding(battle, player, false, options);
+    } else if (move.effect == .Binding) {
+        // Pokémon Showdown handles this after hit/miss checks and damage calculation, though clears
+        // Recharging in onTryMove (required for the Hyper Beam automatic selection glitch)
+        if (showdown) {
+            battle.foe(player).active.volatiles.Recharging = false;
+        } else {
+            try Effects.binding(battle, player, false, options);
+        }
     }
 
     return true;
@@ -1035,22 +1055,20 @@ fn doMove(
             try Effects.poison(battle, player, Move.get(.PoisonSting), options);
         }
         try log.hitcount(.{ battle.active(player.foe()), hit });
-    } else if (showdown) {
+    } else if (showdown and move.effect == .Binding) {
         // This should be handled much earlier but Pokémon Showdown does it here... ¯\_(ツ)_/¯
-        if (move.effect == .Binding) {
-            try Effects.binding(battle, player, rewrap, options);
-            if (immune) {
-                battle.last_damage = 0;
-                assert(foe.stored().hp > 0);
-                // Pokémon Showdown logs |-damage| here instead of |-immune| because logic...
-                if (sub) {
-                    try log.activate(.{ battle.active(player.foe()), .Substitute });
-                } else {
-                    try log.damage(.{ battle.active(player.foe()), foe.stored(), .None });
-                    try buildRage(battle, player.foe(), options);
-                }
-                return null;
+        try Effects.binding(battle, player, rewrap, options);
+        if (immune) {
+            battle.last_damage = 0;
+            assert(foe.stored().hp > 0);
+            // Pokémon Showdown logs |-damage| here instead of |-immune| because logic...
+            if (sub) {
+                try log.activate(.{ battle.active(player.foe()), .Substitute });
+            } else {
+                try log.damage(.{ battle.active(player.foe()), foe.stored(), .None });
+                try buildRage(battle, player.foe(), options);
             }
+            return null;
         }
     }
 
@@ -1131,7 +1149,7 @@ fn calcDamage(
     if ((!showdown or !cfz) and (atk > 255 or def > 255)) {
         atk = @max((atk / 4) & 255, 1);
         // GLITCH: not adjusted to be a min of 1 on cartridge (can lead to division-by-zero freeze)
-        def = @max((def / 4) & 255, if (showdown) 1 else 0);
+        def = @max((def / 4) & 255, if (pkmn.options.mod) 1 else 0);
     }
 
     const lvl: u32 = side.stored().level * @as(u2, if (crit) 2 else 1);
@@ -1152,7 +1170,7 @@ fn calcDamage(
     // encountered so we need to make sure that in the event of a miss we commit the status of the
     // crit roll. The alternative to doing this extra work is to *always* commit the crit roll but
     // that results in counter intuitive probabilities in the common case
-    if (pkmn.options.chance and !showdown) {
+    if (pkmn.options.chance and !pkmn.options.mod and move.effect != .Explode) {
         atk = attack(side, !crit, special);
         def = defense(target, !crit, special, false);
         if ((atk > 255 or def > 255) and (def / 4) & 255 == 0) options.chance.glitch();
@@ -1237,13 +1255,13 @@ fn specialDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
         .Psywave => power: {
             const max: u8 = @intCast(@as(u16, side.stored().level) * 3 / 2);
             // GLITCH: Psywave infinite glitch loop
-            if (!showdown and max <= 1) return Result.Error;
+            if (!pkmn.options.mod and max <= 1) return Result.Error;
             break :power try Rolls.psywave(battle, player, max, options);
         },
         else => unreachable,
     };
 
-    if (battle.last_damage == 0) return if (showdown) null else Result.Error;
+    if (battle.last_damage == 0) return if (pkmn.options.mod) null else Result.Error;
 
     const sub = showdown and foe.active.volatiles.Substitute;
     _ = try applyDamage(battle, player.foe(), player.foe(), .None, options);
@@ -1280,12 +1298,16 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
 
     if (!used or !selected) {
         // GLITCH: Counter desync (covered by Desync Clause Mod on Pokémon Showdown)
-        if (!showdown) return Result.Error;
+        if (!pkmn.options.mod) return Result.Error;
         try options.log.fail(.{ battle.active(player), .None });
         return null;
     }
 
-    battle.last_damage *|= 2;
+    // NOTE: llvm/llvm-project#58557
+    battle.last_damage = if (comptime builtin.target.isWasm())
+        @max(battle.last_damage *% 2, std.math.maxInt(u16))
+    else
+        battle.last_damage *| 2;
 
     // Pokémon Showdown calls moveHit before Counter
     if (!showdown and !try checkHit(battle, player, move, options)) return null;
@@ -1317,7 +1339,7 @@ fn applyDamage(
             subbed.active.volatiles.Substitute = false;
             // battle.last_damage is not updated with the amount of HP the Substitute had
             try options.log.end(.{ battle.active(sub_player), .Substitute });
-            options.calc.capped(sub_player);
+            if (reason != .Confusion) options.calc.capped(sub_player);
             return true;
         } else {
             // Safe to truncate since less than subbed.volatiles.substitute which is a u8
@@ -1527,7 +1549,7 @@ fn faint(battle: anytype, player: Player, done: bool, cap: bool, options: anytyp
     assert(!foe_volatiles.MultiHit);
     if (foe_volatiles.Bide) {
         assert(!foe_volatiles.Thrashing and !foe_volatiles.Rage);
-        foe_volatiles.state = if (showdown) 0 else foe_volatiles.state & 255;
+        foe_volatiles.state = if (pkmn.options.mod) 0 else foe_volatiles.state & 255;
         if (foe_volatiles.state != 0) return Result.Error;
     }
 
@@ -1618,12 +1640,12 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
 
     battle.turn += 1;
 
-    if (showdown and pkmn.options.ebc and checkEBC(battle)) {
+    if (pkmn.options.mod and pkmn.options.ebc and checkEBC(battle)) {
         try options.log.tie(.{});
         return Result.Tie;
     }
 
-    if (showdown and battle.turn >= 1000) {
+    if (pkmn.options.mod and battle.turn >= 1000) {
         try options.log.tie(.{});
         return Result.Tie;
     } else if (battle.turn >= 65535) {
@@ -1872,6 +1894,7 @@ pub const Effects = struct {
 
         foe.active.volatiles.confusion = Rolls.confusionDuration(battle, player, options);
         options.chance.observe(.confusion, player.foe(), .started);
+        options.calc.confusion(player.foe());
 
         try options.log.start(.{ battle.active(player.foe()), .Confusion });
     }
@@ -1917,12 +1940,11 @@ pub const Effects = struct {
 
         // Technically this is still considered simply a "miss" on the cartridge,
         // but diverging from Pokémon Showdown here would mostly just be pedantic
-        if (n == 0) {
+        if (n == 0 or (pkmn.options.mod and err)) {
             try options.log.fail(.{ foe_ident, .None });
             return null;
         } else if (err) {
             // GLITCH: Transform + Mirror Move / Metronome PP softlock
-            assert(!showdown);
             return Result.Error;
         }
 
@@ -2000,7 +2022,7 @@ pub const Effects = struct {
         if (foe.active.types.includes(move.type)) return;
         if (!try Rolls.secondaryChance(battle, player, true, options)) return;
         // Freeze Clause Mod
-        if (showdown) for (foe.pokemon) |p| if (Status.is(p.status, .FRZ)) return;
+        if (pkmn.options.mod) for (foe.pokemon) |p| if (Status.is(p.status, .FRZ)) return;
 
         foe_stored.status = Status.init(.FRZ);
         // GLITCH: Hyper Beam recharging status is not cleared
@@ -2341,7 +2363,7 @@ pub const Effects = struct {
         }
 
         // Sleep Clause Mod
-        if (showdown) {
+        if (pkmn.options.mod) {
             for (foe.pokemon) |p| {
                 if (Status.is(p.status, .SLP) and !Status.is(p.status, .EXT)) return;
             }
@@ -2447,7 +2469,7 @@ pub const Effects = struct {
         if (side.active.volatiles.Binding) return;
         side.active.volatiles.Binding = true;
         // GLITCH: Hyper Beam automatic selection glitch if Recharging gets cleared on miss
-        // (Pokémon Showdown unitentionally patches this glitch, preventing automatic selection)
+        // (Pokémon Showdown clears Recharging in onTryMove instead)
         if (!showdown) {
             foe.active.volatiles.Recharging = false;
         } else if (foe.stored().hp == 0) return if (!rewrap) battle.rng.advance(1);
@@ -2944,9 +2966,10 @@ pub const Rolls = struct {
     }
 
     fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "sleepDuration"))
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 1 and val <= 7) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "sleepDuration"))
             battle.rng.sleepDuration(player)
         else if (showdown)
             battle.rng.range(u3, 1, 8)
@@ -2963,9 +2986,10 @@ pub const Rolls = struct {
     }
 
     fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
-        const duration: u4 = if (options.calc.overridden(player, .duration)) |val|
-            val
-        else if (@hasDecl(@TypeOf(battle.rng), "disableDuration"))
+        const duration: u4 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 1 and val <= 8) val else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "disableDuration"))
             battle.rng.disableDuration(player)
         else if (showdown)
             battle.rng.range(u4, 1, 9)
@@ -2978,9 +3002,10 @@ pub const Rolls = struct {
     }
 
     fn confusionDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "confusionDuration"))
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 2 and val <= 5) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "confusionDuration"))
             battle.rng.confusionDuration(player)
         else if (showdown)
             battle.rng.range(u3, 2, 6)
@@ -2993,9 +3018,10 @@ pub const Rolls = struct {
     }
 
     fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "attackingDuration"))
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 2 and val <= 3) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "attackingDuration"))
             battle.rng.attackingDuration(player)
         else if (showdown)
             battle.rng.range(u3, 2, 4)
@@ -3016,9 +3042,10 @@ pub const Rolls = struct {
         options: anytype,
     ) !u3 {
         const roll = if (effect == .Binding) .duration else .multi_hit;
-        const n: u3 = if (options.calc.overridden(player, roll)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "distribution"))
+        const n: u3 = (if (options.calc.overridden(player, roll)) |val|
+            if (val >= 2 and val <= 5) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "distribution"))
             battle.rng.distribution(player)
         else if (showdown)
             DISTRIBUTION[battle.rng.range(u3, 0, DISTRIBUTION.len)]
@@ -3044,15 +3071,13 @@ pub const Rolls = struct {
         options: anytype,
     ) !u4 {
         // TODO: consider throwing error instead of rerolling?
-        const overridden = if (options.calc.overridden(player, .move_slot)) |val|
+        const slot: u4 = (if (options.calc.overridden(player, .move_slot)) |val|
             if (moves[val - 1].id != .None and (check_pp == 0 or moves[val - 1].pp > 0))
                 val
             else
                 null
         else
-            null;
-
-        const slot: u4 = overridden orelse if (@hasDecl(@TypeOf(battle.rng), "moveSlot"))
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "moveSlot"))
             battle.rng.moveSlot(player, moves, check_pp)
         else slot: {
             if (showdown) {
@@ -3210,7 +3235,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             // Struggle (Pokémon Showdown would use 'move 1' here)
             if (n == before) {
                 // GLITCH: Transform + Mirror Move / Metronome PP softlock
-                if (!showdown) {
+                if (!pkmn.options.mod) {
                     while (slot <= 4) : (slot += 1) {
                         if (active.moves[slot - 1].pp != 0) return n;
                     }

package/src/lib/gen2/calc.zig

@@ -1,27 +1,19 @@
-const std = @import("std");
-
-const pkmn = @import("../pkmn.zig");
-
+const chance = @import("chance.zig");
 const common = @import("../common/data.zig");
-const util = @import("../common/util.zig");
-
 const Optional = @import("../common/optional.zig").Optional;
+const pkmn = @import("../pkmn.zig");
+const std = @import("std");
+const util = @import("../common/util.zig");
 
-const chance = @import("chance.zig");
-
+const Action = chance.Action;
+const Actions = chance.Actions;
 const assert = std.debug.assert;
-
+const Criticals = chance.Criticals;
+const Damages = chance.Damages;
 const enabled = pkmn.options.calc;
-
+const isPointerTo = util.isPointerTo;
 const Player = common.Player;
-
 const PointerType = util.PointerType;
-const isPointerTo = util.isPointerTo;
-
-const Actions = chance.Actions;
-const Action = chance.Action;
-const Criticals = chance.Criticals;
-const Damages = chance.Damages;
 
 const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
 const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;

package/src/lib/gen2/chance.zig

@@ -8,7 +8,6 @@ const expectEqual = std.testing.expectEqual;
 
 const options = @import("../common/options.zig");
 const rational = @import("../common/rational.zig");
-const rng = @import("../common/rng.zig");
 const util = @import("../common/util.zig");
 
 const Array = @import("../common/array.zig").Array;
@@ -20,8 +19,6 @@ const data = @import("data.zig");
 const enabled = options.chance;
 const showdown = options.showdown;
 
-const Gen12 = rng.Gen12;
-
 const PointerType = util.PointerType;
 const isPointerTo = util.isPointerTo;
 

package/src/lib/gen2/data/items.zig

@@ -1,11 +1,9 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const data = @import("../../gen2/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const Type = data.Type;
 
 /// Representation of a held item in Generation II Pokémon.

package/src/lib/gen2/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 gen2 = @import("../../gen2/data.zig");
+const rng = @import("../../common/rng.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const percent = rng.Gen12.percent;
 const Type = gen2.Type;
 

package/src/lib/gen2/data/species.zig

@@ -1,11 +1,9 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const gen2 = @import("../../gen2/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const Stats = gen2.Stats;
 const Types = gen2.Types;
 

package/src/lib/gen2/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/gen2/data.zig

@@ -1,24 +1,20 @@
-const std = @import("std");
-const builtin = @import("builtin");
-
-const pkmn = @import("../pkmn.zig");
-
-const data = @import("../common/data.zig");
 const DEBUG = @import("../common/debug.zig").print;
-const protocol = @import("../common/protocol.zig");
-const rng = @import("../common/rng.zig");
-const util = @import("../common/util.zig");
 
+const builtin = @import("builtin");
+const calc = @import("calc.zig");
+const chance = @import("chance.zig");
+const data = @import("../common/data.zig");
+const gen1 = @import("../gen1/data.zig");
 const items = @import("data/items.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 species = @import("data/species.zig");
+const std = @import("std");
 const types = @import("data/types.zig");
-
-const gen1 = @import("../gen1/data.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/gen2/generated.zig

@@ -1,37 +1,32 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const common = @import("../common/data.zig");
-
 const data = @import("data.zig");
 const mechanics = @import("mechanics.zig");
+const std = @import("std");
 
-const Player = common.Player;
-const Result = common.Result;
-
-const Effectiveness = data.Effectiveness;
-const Move = data.Move;
-
-const Effects = mechanics.Effects;
-const State = mechanics.State;
-
-const canMove = mechanics.canMove;
+const adjustDamage = mechanics.adjustDamage;
+const afterMove = mechanics.afterMove;
+const applyDamage = mechanics.applyDamage;
+const buildRage = mechanics.buildRage;
+const calcDamage = mechanics.calcDamage;
 const canCharge = mechanics.canCharge;
+const canMove = mechanics.canMove;
+const checkCriticalHit = mechanics.checkCriticalHit;
+const checkHit = mechanics.checkHit;
 const decrementPP = mechanics.decrementPP;
+const destinyBond = mechanics.destinyBond;
 const doMove = mechanics.doMove;
-const checkHit = mechanics.checkHit;
-const checkCriticalHit = mechanics.checkCriticalHit;
-const calcDamage = mechanics.calcDamage;
-const adjustDamage = mechanics.adjustDamage;
-const randomizeDamage = mechanics.randomizeDamage;
-const applyDamage = mechanics.applyDamage;
-const reportOutcome = mechanics.reportOutcome;
 const effectChance = mechanics.effectChance;
-const afterMove = mechanics.afterMove;
-const buildRage = mechanics.buildRage;
+const Effectiveness = data.Effectiveness;
+const Effects = mechanics.Effects;
 const kingsRock = mechanics.kingsRock;
-const destinyBond = mechanics.destinyBond;
+const Move = data.Move;
+const Player = common.Player;
+const randomizeDamage = mechanics.randomizeDamage;
+const reportOutcome = mechanics.reportOutcome;
+const Result = common.Result;
+const State = mechanics.State;
 
 const SECONDARY = true;
 const KINGS = true;