@pkmn/engine 0.1.0-dev.89cc1c98 → 0.1.0-dev.8b192003

package/src/lib/gen2/data.zig

@@ -239,7 +239,7 @@ pub const DVs = packed struct(u16) {
         };
         const p: u6 = @intCast(1 + ((5 * @as(u8, (dvs.atk & 0b1000) | ((dvs.def & 0b1000)) >> 1 |
             ((dvs.spe & 0b1000)) >> 2 | ((dvs.spc & 0b1000)) >> 3) + (dvs.spc & 0b0011)) >> 1));
-        var t = @as(u8, dvs.def & 0b0011) + (@as(u8, dvs.atk & 0b0011) << 2);
+        const t = @as(u8, dvs.def & 0b0011) + (@as(u8, dvs.atk & 0b0011) << 2);
         return .{ .gender = g, .pow = p, .type = Type.hiddenPower(t) };
     }
 };
@@ -248,12 +248,12 @@ test DVs {
     var dvs = DVs.from(.Mewtwo, .{ .def = 13 });
     try expectEqual(Gender.Unknown, dvs.gender);
     try expectEqual(Type.Ice, dvs.type);
-    try expectEqual(@as(u8, 70), dvs.power());
+    try expectEqual(70, dvs.power());
 
     dvs = DVs.from(.Pikachu, .{ .spc = 14 });
     try expectEqual(Gender.Male, dvs.gender);
     try expectEqual(Type.Dark, dvs.type);
-    try expectEqual(@as(u8, 69), dvs.power());
+    try expectEqual(69, dvs.power());
 
     dvs = DVs.from(.Cyndaquil, .{ .atk = 1, .def = 3, .spe = 10, .spc = 9 });
     try expectEqual(Gender.Female, dvs.gender);
@@ -314,16 +314,18 @@ pub const Volatiles = packed struct(u128) {
     Encore: bool = false,
     LockOn: bool = false,
     DestinyBond: bool = false,
+    Trapped: bool = false,
 
-    trapped: bool = false,
     switched: bool = false,
+    // TODO: replace with simply looking at Choice on Battle
     switching: bool = false,
+    // TODO: simply store both last moves on side
     dirty: bool = false,
 
     frozen: bool = false,
     minimized: bool = false,
     _: u10 = 0,
-    // TODO?
+    // TODO: is this needed for unmodified stats?
     transform: u4 = 0,
 
     bide: u16 = 0,
@@ -378,9 +380,9 @@ test Stats {
     try expectEqual(0, stats.def);
 
     var base = Species.get(.Gyarados).stats;
-    try expectEqual(@as(u16, 127), Stats(u16).calc("hp", base.hp, 0, 5120, 38));
+    try expectEqual(127, Stats(u16).calc("hp", base.hp, 0, 5120, 38));
     base = Species.get(.Pidgeot).stats;
-    try expectEqual(@as(u16, 279), Stats(u16).calc("spe", base.spe, 15, 63001, 100));
+    try expectEqual(279, Stats(u16).calc("spe", base.spe, 15, 63001, 100));
 }
 
 pub const Boosts = packed struct(u32) {
@@ -426,8 +428,8 @@ test Move {
     try expectEqual(Move.Effect.ConfusionChance, move.effect);
     try expectEqual(rng.Gen12.percent(50), move.accuracy);
     try expectEqual(rng.Gen12.percent(100), move.chance);
-    try expectEqual(@as(u8, 5), Move.pp(.DynamicPunch));
-    try expectEqual(@as(i8, -1), Move.get(.Counter).priority);
+    try expectEqual(5, Move.pp(.DynamicPunch));
+    try expectEqual(-1, Move.get(.Counter).priority);
     try expect(!move.effect.isHighCritical());
     try expect(Move.get(.KarateChop).effect.isHighCritical());
     try expect(Move.get(.RazorWind).effect.isHighCritical());
@@ -437,7 +439,7 @@ pub const Species = species.Species;
 
 test Species {
     try expectEqual(152, @intFromEnum(Species.Chikorita));
-    try expectEqual(@as(u8, 100), Species.get(.Celebi).stats.spd);
+    try expectEqual(100, Species.get(.Celebi).stats.spd);
 }
 
 pub const Type = types.Type;
@@ -450,7 +452,7 @@ test Types {
     try expect(!Type.Steel.special());
     try expect(Type.Dark.special());
 
-    try expectEqual(@as(u8, 3), Type.Water.precedence());
+    try expectEqual(3, Type.Water.precedence());
     try expect(Type.Bug.precedence() > Type.Poison.precedence());
 
     try expectEqual(Effectiveness.Super, Type.effectiveness(.Ghost, .Psychic));

package/src/lib/gen2/generated.zig

@@ -7,8 +7,6 @@ const common = @import("../common/data.zig");
 const data = @import("data.zig");
 const mechanics = @import("mechanics.zig");
 
-const assert = std.debug.assert;
-
 const Player = common.Player;
 const Result = common.Result;
 
@@ -42,7 +40,7 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
     var log = options.log;
 
     var side = battle.side(player);
-    var volatiles = &side.active.volatiles;
+    const volatiles = &side.active.volatiles;
 
     const ident = battle.active(player);
     const foe_ident = battle.active(player.foe());
@@ -97,17 +95,8 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
         },
         .OHKO => {
             if (!try canMove(battle, player, state, options)) return;
-
-            // OHKO calls adjustDamage but only actually cares about immunity
-            assert(move.type == .Normal or move.type == .Ground);
-            const foe = battle.foe(player);
-            const immune = if (move.type == .Normal)
-                foe.active.types.includes(.Ghost) and !foe.active.volatiles.Foresight
-            else
-                foe.active.types.includes(.Ghost);
-            state.effectiveness = if (immune) 0 else Effectiveness.neutral;
-
-            try Effects.ohko(battle, player, state, options);
+            try Effects.ohko.immune(battle, player, state, options);
+            try Effects.ohko.damage(battle, player, state, options);
             try applyDamage(battle, player, state, options);
             try reportOutcome(battle, player, state, options);
             _ = try afterMove(!KINGS, battle, player, state, options);
@@ -118,9 +107,7 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             try calcDamage(battle, player, state, options);
             try adjustDamage(battle, player, state, options);
             try randomizeDamage(battle, player, state, options);
-
-            if (battle.foe(player).active.volatiles.Flying) state.damage *|= 2;
-
+            try Effects.double.flying(battle, player, state, options);
             try checkHit(battle, player, state, options);
             try applyDamage(battle, player, state, options);
             try reportOutcome(battle, player, state, options);
@@ -157,9 +144,7 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             try calcDamage(battle, player, state, options);
             try adjustDamage(battle, player, state, options);
             try randomizeDamage(battle, player, state, options);
-
-            if (battle.foe(player).active.volatiles.minimized) state.damage *|= 2;
-
+            try Effects.double.minimize(battle, player, state, options);
             try checkHit(battle, player, state, options);
             try effectChance(battle, player, state, options);
             try applyDamage(battle, player, state, options);
@@ -188,7 +173,7 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             if (!skip_pp) _ = decrementPP(side, state.move, state.mslot); // TODO if no pp return
             // TODO rampage
             // usedmovetext
-            try log.move(ident, state.move, foe_ident); // FIXME self? from?
+            try log.move(.{ ident, state.move, foe_ident }); // FIXME self? from?
             try checkHit(battle, player, state, options);
             try checkCriticalHit(battle, player, state, options);
             try calcDamage(battle, player, state, options);
@@ -273,7 +258,7 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             try Effects.hyperBeam(battle, player, state, options);
             _ = try afterMove(!KINGS, battle, player, state, options);
         },
-        .Counter => {
+        .MirrorCoat, .Counter => {
             if (!try canMove(battle, player, state, options)) return;
             try Effects.counter(battle, player, state, options);
             try applyDamage(battle, player, state, options);
@@ -308,7 +293,6 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             if (!try canMove(battle, player, state, options)) return;
             try checkCriticalHit(battle, player, state, options);
             try calcDamage(battle, player, state, options);
-            // TODO thunderaccuracy
             try checkHit(battle, player, state, options);
             try effectChance(battle, player, state, options);
             try adjustDamage(battle, player, state, options);
@@ -324,9 +308,7 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             try calcDamage(battle, player, state, options);
             try adjustDamage(battle, player, state, options);
             try randomizeDamage(battle, player, state, options);
-
-            if (battle.foe(player).active.volatiles.Underground) state.damage *|= 2;
-
+            try Effects.double.underground(battle, player, state, options);
             try checkHit(battle, player, state, options);
             try effectChance(battle, player, state, options);
             try applyDamage(battle, player, state, options);
@@ -339,13 +321,10 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             try calcDamage(battle, player, state, options);
             try adjustDamage(battle, player, state, options);
             try checkHit(battle, player, state, options);
-
-            assert(volatiles.Rage);
-            state.damage *|= (volatiles.rage +| 1);
-
+            try Effects.rage.damage(battle, player, state, options);
             try randomizeDamage(battle, player, state, options);
             // TODO failuretext
-            try Effects.rage(battle, player, state, options);
+            try Effects.rage.start(battle, player, state, options);
             try applyDamage(battle, player, state, options);
             try reportOutcome(battle, player, state, options);
             _ = try afterMove(KINGS, battle, player, state, options);
@@ -363,47 +342,32 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             if (!try canMove(battle, player, state, options)) return;
             try Effects.heal(battle, player, state, options);
         },
+        .LightScreen => {
+            if (!try canMove(battle, player, state, options)) return;
+            try Effects.lightScreen(battle, player, state, options);
+        },
         .Haze => {
             if (!try canMove(battle, player, state, options)) return;
             try Effects.haze(battle, player, state, options);
         },
-        .LightScreen, .Reflect => {
+        .Reflect => {
             if (!try canMove(battle, player, state, options)) return;
-            try Effects.screens(battle, player, state, options);
+            try Effects.reflect(battle, player, state, options);
         },
         .FocusEnergy => {
             if (!try canMove(battle, player, state, options)) return;
             try Effects.focusEnergy(battle, player, state, options);
         },
         .Bide => {
-            if (!volatiles.Bide) return;
-
-            assert(volatiles.attacks > 0);
-            // if (options.calc.modify(player, .attacking)) |extend| {
-            //     if (!extend) volatiles.attacks = 0;
-            // } else {
-            volatiles.attacks -= 1;
-            // }
-            try options.chance.attacking(player, volatiles.attacks);
-
-            if (volatiles.attacks != 0) return try options.log.activate(ident, .Bide);
-
-            volatiles.Bide = false;
-            try options.log.end(ident, .Bide);
-
-            state.damage = volatiles.bide *% 2;
-            volatiles.bide = 0;
-
-            if (state.damage == 0) state.miss = true;
-
+            try Effects.bide.store(battle, player, state, options);
             // doturn
             const charging = false; // TODO
             const skip_pp = charging or state.move == .Struggle or
                 (volatiles.BeatUp or volatiles.Thrashing or volatiles.Bide);
             if (!skip_pp) _ = decrementPP(side, state.move, state.mslot); // TODO if no pp return
             // usedmovetext
-            try log.move(ident, state.move, foe_ident); // FIXME self? from?
-            // TODO unleashenergy
+            try log.move(.{ ident, state.move, foe_ident }); // FIXME self? from?
+            try Effects.bide.unleash(battle, player, state, options);
 
             if (state.immune()) {
                 state.damage = 0;
@@ -522,7 +486,7 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             try randomizeDamage(battle, player, state, options);
             try checkHit(battle, player, state, options);
             try effectChance(battle, player, state, options);
-            try Effects.snore(battle, player, state, options);
+            if (!try Effects.snore(battle, player, state, options)) return;
             try applyDamage(battle, player, state, options);
             try reportOutcome(battle, player, state, options);
             if (!try afterMove(!KINGS, battle, player, state, options)) return;
@@ -582,19 +546,19 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             try Effects.sandstorm(battle, player, state, options);
         },
         .Rollout => {
-            // TODO checkcurl
+            try Effects.rollout.check(battle, player, state, options);
             // doturn
             const charging = false; // TODO
             const skip_pp = charging or state.move == .Struggle or
                 (volatiles.BeatUp or volatiles.Thrashing or volatiles.Bide);
             if (!skip_pp) _ = decrementPP(side, state.move, state.mslot); // TODO if no pp return
             // usedmovetext
-            try log.move(ident, state.move, foe_ident); // FIXME self? from?
+            try log.move(.{ ident, state.move, foe_ident }); // FIXME self? from?
             try checkCriticalHit(battle, player, state, options);
             try calcDamage(battle, player, state, options);
             try adjustDamage(battle, player, state, options);
             try checkHit(battle, player, state, options);
-            // TODO rolloutpower
+            try Effects.rollout.power(battle, player, state, options);
             try randomizeDamage(battle, player, state, options);
             try applyDamage(battle, player, state, options);
             try reportOutcome(battle, player, state, options);
@@ -615,12 +579,7 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
         .Swagger => {
             if (!try canMove(battle, player, state, options)) return;
             try checkHit(battle, player, state, options);
-            // TODO switchturn
-            // TODO attackup2
-            // TODO switchturn
-            // TODO failuretext
-            // TODO switchturn
-            // TODO switchturn
+            try Effects.boost(battle, player.foe(), state, options);
             try Effects.confusionChance(battle, player, state, options);
         },
         .FuryCutter => {
@@ -694,14 +653,12 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
         .Magnitude => {
             if (!try canMove(battle, player, state, options)) return;
             try checkCriticalHit(battle, player, state, options);
-            // TODO getmagnitude
+            try Effects.magnitude(battle, player, state, options);
             try calcDamage(battle, player, state, options);
             try adjustDamage(battle, player, state, options);
             try randomizeDamage(battle, player, state, options);
             try checkHit(battle, player, state, options);
-
-            if (battle.foe(player).active.volatiles.Underground) state.damage *|= 2;
-
+            try Effects.double.underground(battle, player, state, options);
             try applyDamage(battle, player, state, options);
             try reportOutcome(battle, player, state, options);
             _ = try afterMove(KINGS, battle, player, state, options);
@@ -755,9 +712,7 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             try calcDamage(battle, player, state, options);
             try adjustDamage(battle, player, state, options);
             try randomizeDamage(battle, player, state, options);
-
-            if (battle.foe(player).active.volatiles.Flying) state.damage *|= 2;
-
+            try Effects.double.flying(battle, player, state, options);
             try checkHit(battle, player, state, options);
             try effectChance(battle, player, state, options);
             try applyDamage(battle, player, state, options);
@@ -773,12 +728,6 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
             if (!try canMove(battle, player, state, options)) return;
             try Effects.sunnyDay(battle, player, state, options);
         },
-        .MirrorCoat => {
-            if (!try canMove(battle, player, state, options)) return;
-            try Effects.mirrorCoat(battle, player, state, options);
-            try applyDamage(battle, player, state, options);
-            _ = try afterMove(KINGS, battle, player, state, options);
-        },
         .PsychUp => {
             if (!try canMove(battle, player, state, options)) return;
             try Effects.psychUp(battle, player, state, options);

package/src/lib/gen2/helpers.zig

@@ -65,17 +65,47 @@ pub const Battle = struct {
 };
 
 pub fn prng(rand: *PSRNG) data.PRNG {
-    // FIXME: what is max range in gen2?
     return .{
         .src = .{
             .seed = if (showdown)
                 rand.newSeed()
-            else
-                .{
-                    rand.range(u8, 0, 256), rand.range(u8, 0, 256), rand.range(u8, 0, 256),
-                    rand.range(u8, 0, 256), rand.range(u8, 0, 256), rand.range(u8, 0, 256),
-                    rand.range(u8, 0, 256), rand.range(u8, 0, 256), rand.range(u8, 0, 256),
-                },
+            else seed: {
+                // GLITCH: The initial RNG seed in Gen II link battles is heavily constrained
+                // https://www.smogon.com/forums/threads/rng-in-rby-link-battles.3746779
+                var seed = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+                // Bytes in seed can only range from 0-252, not 0-255
+                const max: u8 = 253;
+                // Instructions take multiples of 4 cycles to execute
+                var timer: u16 = 4 * rand.range(u16, 0, 16384);
+                var add: u8 = rand.range(u8, 0, 256);
+                var sub: u8 = rand.range(u8, 0, 256);
+                var carry: u8 = 0;
+                var div: u8 = 0;
+
+                var i: u8 = 0;
+                while (i < seed.len) {
+                    div = @intCast(timer >> 8);
+                    // This is effectively @addWithOverflow but with three operands
+                    const result = @as(u16, add) + @as(u16, div) + @as(u16, carry);
+                    add = @intCast(result & 255);
+                    carry = @intFromBool(result > 255);
+                    timer +%= 44;
+                    div = @intCast(timer >> 8);
+                    sub -%= div +% carry;
+
+                    if (sub < max) {
+                        seed[i] = sub;
+                        i += 1;
+                        timer +%= 152;
+                        carry = 1;
+                    } else {
+                        timer +%= 132;
+                        carry = 0;
+                    }
+                }
+                break :seed seed;
+            },
         },
     };
 }