@pkmn/engine 0.1.0-dev.fb5bf955 → 0.1.0-dev.fc150752

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

@@ -1793,6 +1793,6 @@ pub const Species = enum(u8) {
     /// Returns the `Data` corresponding to the species.
     pub fn get(id: Species) Data {
         assert(id != .None);
-        return DATA[@enumToInt(id) - 1];
+        return DATA[@intFromEnum(id) - 1];
     }
 };

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

@@ -86,17 +86,17 @@ pub const Type = enum(u8) {
 
     /// Whether or not this type is considered to be special as opposed to physical.
     pub inline fn special(self: Type) bool {
-        return @enumToInt(self) >= @enumToInt(Type.Fire);
+        return @intFromEnum(self) >= @intFromEnum(Type.Fire);
     }
 
     /// The `Effectiveness` of type `t2` vs. type `t1`.
     pub inline fn effectiveness(t1: Type, t2: Type) Effectiveness {
-        return CHART[@enumToInt(t1)][@enumToInt(t2)];
+        return CHART[@intFromEnum(t1)][@intFromEnum(t2)];
     }
 
     /// The precedence order of type type.
     pub inline fn precedence(self: Type) u8 {
-        return PRECEDENCE[@enumToInt(self)];
+        return PRECEDENCE[@intFromEnum(self)];
     }
 };
 

package/src/lib/gen2/data.zig

@@ -1,10 +1,13 @@
 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 options = @import("../common/options.zig");
+const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
+const util = @import("../common/util.zig");
 
 const items = @import("data/items.zig");
 const moves = @import("data/moves.zig");
@@ -13,30 +16,37 @@ 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 assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
 const expect = std.testing.expect;
 
-pub const MAX_OPTIONS: usize = 9; // move 1..4, switch 2..6
+pub const MAX_CHOICES: usize = 9; // move 1..4, switch 2..6
 pub const MAX_LOGS: usize = 180; // TODO
 
-pub const OPTIONS_SIZE = if (builtin.mode == .ReleaseSmall)
-    MAX_OPTIONS
+pub const CHOICES_SIZE = if (builtin.mode == .ReleaseSmall)
+    MAX_CHOICES
 else
-    std.math.ceilPowerOfTwo(usize, MAX_OPTIONS) catch unreachable;
+    std.math.ceilPowerOfTwo(usize, MAX_CHOICES) catch unreachable;
 pub const LOGS_SIZE = if (builtin.mode == .ReleaseSmall)
     MAX_LOGS
 else
     std.math.ceilPowerOfTwo(usize, MAX_LOGS) catch unreachable;
 
+///  Null object pattern implementation of pkmn.battle.Options for Generation II.
+pub const NULL = pkmn.battle.options(protocol.NULL, chance.NULL, calc.NULL);
+
 const Choice = data.Choice;
 const ID = data.ID;
 const Player = data.Player;
 const Result = data.Result;
 
-const showdown = options.showdown;
+const PointerType = util.PointerType;
+
+const showdown = pkmn.options.showdown;
 
 pub const PRNG = rng.PRNG(2);
 
@@ -49,20 +59,25 @@ pub fn Battle(comptime RNG: anytype) type {
         turn: u16 = 0,
         field: Field = .{},
 
-        pub inline fn side(self: *Self, player: Player) *Side {
-            return &self.sides[@enumToInt(player)];
+        _1: u8 = 0,
+        _2: if (!showdown) u16 else u32 = 0,
+
+        pub inline fn side(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
+            assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
+            return &self.sides[@intFromEnum(player)];
         }
 
-        pub inline fn foe(self: *Self, player: Player) *Side {
-            return &self.sides[@enumToInt(player.foe())];
+        pub inline fn foe(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
+            assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
+            return &self.sides[@intFromEnum(player.foe())];
         }
 
-        pub inline fn active(self: *Self, player: Player) ID {
-            return player.ident(@intCast(u3, self.side(player).pokemon[0].position));
+        pub inline fn active(self: *const Self, player: Player) ID {
+            return player.ident(@intCast(self.side(player).pokemon[0].position));
         }
 
-        pub fn update(self: *Self, c1: Choice, c2: Choice, log: anytype) !Result {
-            return mechanics.update(self, c1, c2, log);
+        pub fn update(self: *Self, c1: Choice, c2: Choice, options: anytype) !Result {
+            return mechanics.update(self, c1, c2, options);
         }
 
         pub fn choices(self: *Self, player: Player, request: Choice.Type, out: []Choice) u8 {
@@ -71,35 +86,34 @@ pub fn Battle(comptime RNG: anytype) type {
     };
 }
 
-// TODO
 test Battle {
-    try expectEqual(496, @sizeOf(Battle(PRNG)));
+    try expectEqual(512, @sizeOf(Battle(PRNG)));
 }
 
-const Field = packed struct {
+pub const Field = packed struct(u8) {
     weather: Weather = .None,
     weather_duration: u4 = 0,
-
-    comptime {
-        assert(@sizeOf(Field) == 1);
-    }
 };
 
-const Weather = enum(u4) {
+pub const Weather = enum(u4) {
     None,
     Rain,
     Sun,
     Sandstorm,
 };
 
-const Side = extern struct {
+pub const Side = extern struct {
     pokemon: [6]Pokemon = [_]Pokemon{.{}} ** 6,
-    active: ActivePokemon = .{},
-    conditions: Conditions,
+    active: ActivePokemon align(8) = .{},
+    conditions: Conditions = .{},
+    _1: u32 = 0,
+    _2: u16 = 0,
+    // NB: wCurPlayerMove / wCurEnemyMove (?)
+    _3: u8 = 0,
+    // NB: wLastPlayerCounterMove / wLastEnemyCounterMove (wLastPlayerMove / wLastEnemyMove)
     last_used_move: Move = .None,
-    _: u8 = 0,
 
-    const Conditions = packed struct {
+    const Conditions = packed struct(u32) {
         Spikes: bool = false,
         Safeguard: bool = false,
         LightScreen: bool = false,
@@ -109,50 +123,69 @@ const Side = extern struct {
         light_screen: u4 = 0,
         reflect: u4 = 0,
 
-        comptime {
-            assert(@sizeOf(Conditions) == 2);
-        }
+        future_sight: FutureSight = .{},
+
+        const FutureSight = packed struct(u16) {
+            damage: u12 = 0,
+            count: u4 = 0,
+        };
     };
 
     comptime {
-        assert(@sizeOf(Side) == 240);
+        assert(@sizeOf(Side) == 248);
     }
 
-    pub inline fn get(self: *const Side, slot: u8) *Pokemon {
+    pub inline fn get(self: anytype, slot: u8) PointerType(@TypeOf(self), Pokemon) {
+        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
         assert(slot > 0 and slot <= 6);
         const id = self.pokemon[slot - 1].position;
         assert(id > 0 and id <= 6);
         return &self.pokemon[id - 1];
     }
 
-    pub inline fn stored(self: *Side) *Pokemon {
+    pub inline fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
+        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
         return self.get(1);
     }
+
+    pub inline fn lastMove(self: anytype, encore: bool) Move {
+        assert(self.last_used_move != .None or !self.active.volatiles.dirty);
+        if (encore) return self.last_used_move;
+        return if (self.active.volatiles.dirty) .None else self.last_used_move;
+    }
+
+    // TODO
+    // pub inline fn useMove(self: anytype) void {
+    //     assert(side.last_selected_move != .None);
+    //     self.last_used_move = side.last_selected_move;
+    //     self.active.volatiles.dirty = false;
+    // }
 };
 
 // NOTE: DVs (Gender & Hidden Power) and Happiness are stored only in Pokemon
-const ActivePokemon = extern struct {
-    volatiles: Volatile align(4) = .{},
+pub const ActivePokemon = extern struct {
+    volatiles: Volatiles align(4) = .{},
     stats: Stats(u16) = .{},
     moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
     boosts: Boosts = .{},
+    types: Types = .{},
     species: Species = .None,
-    item: Item = .None,
-    last_move: Move = .None,
+
     _: u8 = 0,
 
     comptime {
         assert(@sizeOf(ActivePokemon) == 44);
     }
 
-    pub inline fn move(self: *ActivePokemon, mslot: u8) *MoveSlot {
+    pub inline fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
+        assert(@typeInfo(@TypeOf(self)).Pointer.child == Pokemon);
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
         return &self.moves[mslot - 1];
     }
 };
 
-const Pokemon = extern struct {
+pub const Pokemon = extern struct {
     stats: Stats(u16) = .{},
     moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
     types: Types = .{},
@@ -169,7 +202,8 @@ const Pokemon = extern struct {
         assert(@sizeOf(Pokemon) == 32);
     }
 
-    pub inline fn move(self: *Pokemon, mslot: u8) *MoveSlot {
+    pub inline fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
+        assert(@typeInfo(@TypeOf(self)).Pointer.child == Pokemon);
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
         return &self.moves[mslot - 1];
@@ -182,7 +216,7 @@ pub const Gender = enum(u2) {
     Unknown,
 };
 
-const DVs = packed struct {
+pub const DVs = packed struct(u16) {
     gender: Gender = .Male,
     pow: u6 = 40,
     type: Type = .Dark,
@@ -205,15 +239,11 @@ const DVs = packed struct {
             0xFF => .Unknown,
             else => if ((@as(u8, dvs.atk) << 4 | dvs.spe) < ratio) Gender.Female else Gender.Male,
         };
-        const p = @intCast(u6, 1 + ((5 * @as(u8, (dvs.atk & 0b1000) | ((dvs.def & 0b1000)) >> 1 |
+        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) + 1;
-        if (t >= @enumToInt(Type.@"???")) t = t + 1;
-        return DVs{ .gender = g, .pow = p, .type = @intToEnum(Type, t) };
-    }
-
-    comptime {
-        assert(@sizeOf(DVs) == 2);
+        if (t >= @intFromEnum(Type.@"???")) t = t + 1;
+        return DVs{ .gender = g, .pow = p, .type = @enumFromInt(t) };
     }
 };
 
@@ -238,10 +268,12 @@ test DVs {
     try expectEqual(Gender.Female, dvs.gender);
 }
 
-const MoveSlot = packed struct {
+/// Representation of a Generation II Pokémon's move slot in a battle.
+pub const MoveSlot = extern struct {
+    /// The identifier for the move.
     id: Move = .None,
-    pp_ups: u2 = 3,
-    pp: u6 = 0,
+    /// The remaining PP of the move.
+    pp: u8 = 0,
 
     comptime {
         assert(@sizeOf(MoveSlot) == 2);
@@ -250,7 +282,7 @@ const MoveSlot = packed struct {
 
 pub const Status = gen1.Status;
 
-const Volatile = packed struct {
+pub const Volatiles = packed struct(u128) {
     Bide: bool = false,
     Thrashing: bool = false,
     Flinch: bool = false,
@@ -268,7 +300,7 @@ const Volatile = packed struct {
     Transform: bool = false,
 
     Nightmare: bool = false,
-    Cure: bool = false,
+    Curse: bool = false,
     Protect: bool = false,
     Foresight: bool = false,
     PerishSong: bool = false,
@@ -284,11 +316,11 @@ const Volatile = packed struct {
     trapped: bool = false,
     switched: bool = false,
     switching: bool = false,
+    dirty: bool = false,
 
-    _: u5 = 0,
+    _: u20 = 0,
 
     bind: u4 = 0,
-    future_sight: FutureSight = .{},
     bide: u16 = 0,
     disabled: Disabled = .{},
     rage: u8 = 0,
@@ -296,24 +328,16 @@ const Volatile = packed struct {
     toxic: u8 = 0,
     confusion: u4 = 0,
     encore: u4 = 0,
+    // TODO merge with attacks (ie rollout/thrashing)? need to be zeroed at same time
     fury_cutter: u4 = 0,
     perish_song: u4 = 0,
     protect: u4 = 0,
-    rollout: u4 = 0,
+    attacks: u4 = 0, // bide/thrashing/rollout turns
 
-    const Disabled = packed struct {
+    const Disabled = packed struct(u8) {
         move: u4 = 0,
         duration: u4 = 0,
     };
-
-    const FutureSight = packed struct {
-        damage: u12 = 0,
-        count: u4 = 0,
-    };
-
-    comptime {
-        assert(@sizeOf(Volatile) == 16);
-    }
 };
 
 pub fn Stats(comptime T: type) type {
@@ -327,10 +351,11 @@ pub fn Stats(comptime T: type) type {
 
         pub fn calc(comptime stat: []const u8, base: T, dv: u4, exp: u16, level: u8) T {
             assert(level > 0 and level <= 100);
-            const evs = @min(255, @floatToInt(u16, @ceil(@sqrt(@intToFloat(f32, exp)))));
+            const float: f32 = @floatFromInt(exp);
+            const evs: u16 = @min(255, @as(u16, @intFromFloat(@ceil(@sqrt(float)))));
             const core: u32 = (2 *% (@as(u32, base) +% dv)) +% (evs / 4);
             const factor: u32 = if (std.mem.eql(u8, stat, "hp")) level + 10 else 5;
-            return @intCast(T, core *% @as(u32, level) / 100 +% factor);
+            return @intCast(core *% @as(u32, level) / 100 +% factor);
         }
     };
 }
@@ -347,7 +372,7 @@ test Stats {
     try expectEqual(@as(u16, 279), Stats(u16).calc("spe", base.spe, 15, 63001, 100));
 }
 
-pub const Boosts = packed struct {
+pub const Boosts = packed struct(u32) {
     atk: i4 = 0,
     def: i4 = 0,
     spe: i4 = 0,
@@ -390,17 +415,22 @@ test Item {
 pub const Move = moves.Move;
 
 test Move {
-    try expectEqual(251, @enumToInt(Move.BeatUp));
+    try expectEqual(251, @intFromEnum(Move.BeatUp));
     const move = Move.get(.DynamicPunch);
     try expectEqual(Move.Effect.ConfusionChance, move.effect);
-    try expectEqual(@as(u8, 50), move.accuracy);
-    try expectEqual(@as(u8, 5), move.pp);
+    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 expect(!move.effect.isHighCritical());
+    try expect(Move.get(.KarateChop).effect.isHighCritical());
+    try expect(Move.get(.RazorWind).effect.isHighCritical());
 }
 
 pub const Species = species.Species;
 
 test Species {
-    try expectEqual(152, @enumToInt(Species.Chikorita));
+    try expectEqual(152, @intFromEnum(Species.Chikorita));
     try expectEqual(@as(u8, 100), Species.get(.Celebi).stats.spd);
 }
 
@@ -409,7 +439,7 @@ pub const Types = types.Types;
 pub const Effectiveness = gen1.Effectiveness;
 
 test Types {
-    try expectEqual(13, @enumToInt(Type.Electric));
+    try expectEqual(13, @intFromEnum(Type.Electric));
 
     try expect(!Type.Steel.special());
     try expect(Type.Dark.special());

package/src/lib/gen2/helpers.zig

@@ -48,7 +48,7 @@ pub const Battle = struct {
         comptime rolls: anytype,
         p1: []const Pokemon,
         p2: []const Pokemon,
-    ) data.Battle(rng.FixedRNG(1, rolls.len)) {
+    ) data.Battle(rng.FixedRNG(2, rolls.len)) {
         return .{
             .rng = .{ .rolls = rolls },
             .sides = .{ Side.init(p1), Side.init(p2) },
@@ -72,11 +72,9 @@ pub fn prng(rand: *PSRNG) data.PRNG {
                 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), 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), rand.range(u8, 0, 256),
                 },
         },
     };
@@ -89,7 +87,7 @@ pub const Side = struct {
 
         for (0..ps.len) |i| {
             side.pokemon[i] = Pokemon.init(ps[i]);
-            // FIXME side.order[i] = i + 1;
+            side.pokemon[i].position = @as(u4, @intCast(i)) + 1;
         }
         return side;
     }
@@ -100,7 +98,7 @@ pub const Side = struct {
 
         for (0..n) |i| {
             side.pokemon[i] = Pokemon.random(rand, opt);
-            side.pokemon[i].position = i + 1;
+            side.pokemon[i].position = @as(u4, @intCast(i)) + 1;
         }
 
         return side;
@@ -137,12 +135,9 @@ pub const Pokemon = struct {
         }
         assert(p.moves.len > 0 and p.moves.len <= 4);
         for (p.moves, 0..) |m, j| {
-            pokemon.moves[j] = .{
-                .id = m,
-                .pp_ups = 3,
-                // NB: PP can be at most 61 legally (though can overflow to 63)
-                .pp = @intCast(u8, @min(Move.pp(m) / 5 * 8, 61)),
-            };
+            pokemon.moves[j].id = m;
+            // NB: PP can be at most 61 legally (though can overflow to 63)
+            pokemon.moves[j].pp = @intCast(@min(Move.pp(m) / 5 * 8, 61));
         }
         pokemon.item = p.item;
         if (p.hp) |hp| {
@@ -153,16 +148,16 @@ pub const Pokemon = struct {
         pokemon.status = p.status;
         pokemon.types = species.types;
         pokemon.level = p.level;
-        pokemon.dvs = DVs.from(p.dvs);
+        pokemon.dvs = DVs.from(p.species, p.dvs);
         return pokemon;
     }
 
     pub fn random(rand: *PSRNG, opt: Options) data.Pokemon {
-        const s = @intToEnum(Species, rand.range(u8, 1, Species.size + 1));
+        const s: Species = @enumFromInt(rand.range(u8, 1, Species.size + 1));
         const species = Species.get(s);
         const lvl = if (rand.chance(u8, 1, 20)) rand.range(u8, 1, 99 + 1) else 100;
         // Pokémon Showdown does not support most items without in-battle held item effects
-        const max_item = @enumToInt(if (showdown) Item.FlowerMail else Item.TM50);
+        const max_item = @intFromEnum(if (showdown) Item.FlowerMail else Item.TM50);
         const item = if (rand.chance(u8, 1, 10)) 0 else rand.range(u8, 1, max_item + 1);
 
         var stats: Stats(u16) = .{};
@@ -184,24 +179,23 @@ pub const Pokemon = struct {
         for (0..n) |i| {
             var m: Move = .None;
             sample: while (true) {
-                m = @intToEnum(Move, rand.range(u8, 1, 164 + 1));
+                m = @enumFromInt(rand.range(u8, 1, 164 + 1));
                 for (0..i) |j| if (ms[j].id == m) continue :sample;
                 break;
             }
-            const pp_ups =
+            const pp_ups: u8 =
                 if (!opt.cleric and rand.chance(u8, 1, 10)) rand.range(u2, 0, 2 + 1) else 3;
             // NB: PP can be at most 61 legally (though can overflow to 63)
-            const max_pp = @intCast(u8, Move.pp(m) + @as(u8, pp_ups) * @min(Move.pp(m) / 5, 7));
+            const max_pp: u8 = @intCast(Move.pp(m) + pp_ups * @min(Move.pp(m) / 5, 7));
             ms[i] = .{
                 .id = m,
-                .pp_ups = pp_ups,
                 .pp = if (opt.cleric) max_pp else rand.range(u8, 0, max_pp + 1),
             };
         }
         return .{
             .species = s,
             .types = species.types,
-            .dvs = DVs.from(dvs),
+            .dvs = DVs.from(s, dvs),
             .level = lvl,
             .stats = stats,
             .hp = if (opt.cleric) stats.hp else rand.range(u16, 0, stats.hp + 1),