@pkmn/engine 0.1.0-dev.02b7f810

package/src/lib/gen2/helpers.zig

@@ -0,0 +1,225 @@
+const std = @import("std");
+
+const common = @import("../common/data.zig");
+const options = @import("../common/options.zig");
+const protocol = @import("../common/protocol.zig");
+const rng = @import("../common/rng.zig");
+
+const gen1 = @import("../gen1/data.zig");
+
+const data = @import("data.zig");
+
+const assert = std.debug.assert;
+
+const expectEqual = std.testing.expectEqual;
+
+const Choice = common.Choice;
+
+const showdown = options.showdown;
+
+const PSRNG = rng.PSRNG;
+
+const DVs = data.DVs;
+const Item = data.Item;
+const Move = data.Move;
+const MoveSlot = data.MoveSlot;
+const Species = data.Species;
+const Stats = data.Stats;
+const Status = data.Status;
+
+pub const Options = struct {
+    cleric: bool = showdown,
+};
+
+pub const Battle = struct {
+    pub fn init(
+        seed: u64,
+        p1: []const Pokemon,
+        p2: []const Pokemon,
+    ) data.Battle(data.PRNG) {
+        var rand = PSRNG.init(seed);
+        return .{
+            .rng = prng(&rand),
+            .sides = .{ Side.init(p1), Side.init(p2) },
+        };
+    }
+
+    pub fn fixed(
+        comptime rolls: anytype,
+        p1: []const Pokemon,
+        p2: []const Pokemon,
+    ) data.Battle(rng.FixedRNG(1, rolls.len)) {
+        return .{
+            .rng = .{ .rolls = rolls },
+            .sides = .{ Side.init(p1), Side.init(p2) },
+        };
+    }
+
+    pub fn random(rand: *PSRNG, opt: Options) data.Battle(data.PRNG) {
+        return .{
+            .rng = prng(rand),
+            .turn = 0,
+            .sides = .{ Side.random(rand, opt), Side.random(rand, opt) },
+        };
+    }
+};
+
+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), rand.range(u8, 0, 256),
+                },
+        },
+    };
+}
+
+pub const Side = struct {
+    pub fn init(ps: []const Pokemon) data.Side {
+        assert(ps.len > 0 and ps.len <= 6);
+        var side = data.Side{};
+
+        for (0..ps.len) |i| {
+            side.pokemon[i] = Pokemon.init(ps[i]);
+            // FIXME side.order[i] = i + 1;
+        }
+        return side;
+    }
+
+    pub fn random(rand: *PSRNG, opt: Options) data.Side {
+        const n = if (rand.chance(u8, 1, 100)) rand.range(u4, 1, 5 + 1) else 6;
+        var side = data.Side{};
+
+        for (0..n) |i| {
+            side.pokemon[i] = Pokemon.random(rand, opt);
+            side.pokemon[i].position = i + 1;
+        }
+
+        return side;
+    }
+};
+
+pub const EXP = 0xFFFF;
+
+pub const Pokemon = struct {
+    species: Species,
+    moves: []const Move,
+    item: Item = .None,
+    hp: ?u16 = null,
+    status: u8 = 0,
+    level: u8 = 100,
+    dvs: gen1.DVs = .{},
+    stats: Stats(u16) = .{ .hp = EXP, .atk = EXP, .def = EXP, .spe = EXP, .spa = EXP, .spd = EXP },
+
+    pub fn init(p: Pokemon) data.Pokemon {
+        var pokemon = data.Pokemon{};
+        pokemon.species = p.species;
+        const species = Species.get(p.species);
+        inline for (@typeInfo(@TypeOf(pokemon.stats)).Struct.fields) |field| {
+            const hp = comptime std.mem.eql(u8, field.name, "hp");
+            const spc =
+                comptime std.mem.eql(u8, field.name, "spa") or std.mem.eql(u8, field.name, "spd");
+            @field(pokemon.stats, field.name) = Stats(u16).calc(
+                field.name,
+                @field(species.stats, field.name),
+                if (hp) p.dvs.hp() else if (spc) p.dvs.spc else @field(p.dvs, field.name),
+                @field(p.stats, field.name),
+                p.level,
+            );
+        }
+        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.item = p.item;
+        if (p.hp) |hp| {
+            pokemon.hp = hp;
+        } else {
+            pokemon.hp = pokemon.stats.hp;
+        }
+        pokemon.status = p.status;
+        pokemon.types = species.types;
+        pokemon.level = p.level;
+        pokemon.dvs = DVs.from(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 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 item = if (rand.chance(u8, 1, 10)) 0 else rand.range(u8, 1, max_item + 1);
+
+        var stats: Stats(u16) = .{};
+        const dvs = gen1.DVs.random(rand);
+        inline for (@typeInfo(@TypeOf(stats)).Struct.fields) |field| {
+            const hp = std.mem.eql(u8, field.name, "hp");
+            const spc = std.mem.eql(u8, field.name, "spa") or std.mem.eql(u8, field.name, "spd");
+            @field(stats, field.name) = Stats(u16).calc(
+                field.name,
+                @field(species.stats, field.name),
+                if (hp) dvs.hp() else if (spc) dvs.spc else @field(dvs, field.name),
+                if (rand.chance(u8, 1, 20)) rand.range(u8, 0, 255 + 1) else 255,
+                lvl,
+            );
+        }
+
+        var ms = [_]MoveSlot{.{}} ** 4;
+        const n = if (rand.chance(u8, 1, 100)) rand.range(u4, 1, 3 + 1) else 4;
+        for (0..n) |i| {
+            var m: Move = .None;
+            sample: while (true) {
+                m = @intToEnum(Move, rand.range(u8, 1, 164 + 1));
+                for (0..i) |j| if (ms[j].id == m) continue :sample;
+                break;
+            }
+            const pp_ups =
+                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));
+            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),
+            .level = lvl,
+            .stats = stats,
+            .hp = if (opt.cleric) stats.hp else rand.range(u16, 0, stats.hp + 1),
+            .status = if (!opt.cleric and rand.chance(u8, 1, 6 + 1))
+                0 | (@as(u8, 1) << rand.range(u3, 1, 6 + 1))
+            else
+                0,
+            .happiness = if (rand.chance(u8, 1, 10 + 1)) rand.range(u8, 0, 255) else 255,
+            .item = item,
+            .moves = ms,
+        };
+    }
+};
+
+pub fn move(slot: u4) Choice {
+    return .{ .type = .Move, .data = slot };
+}
+
+pub fn swtch(slot: u4) Choice {
+    return .{ .type = .Switch, .data = slot };
+}

package/src/lib/gen2/mechanics.zig

@@ -0,0 +1,53 @@
+const std = @import("std");
+
+const common = @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 data = @import("data.zig");
+
+const assert = std.debug.assert;
+
+const expectEqual = std.testing.expectEqual;
+
+const Choice = common.Choice;
+const ID = common.ID;
+const Player = common.Player;
+const Result = common.Result;
+
+const showdown = options.showdown;
+
+const Damage = protocol.Damage;
+const Heal = protocol.Heal;
+
+const Gen12 = rng.Gen12;
+
+const ActivePokemon = data.ActivePokemon;
+const Effectiveness = data.Effectiveness;
+const Move = data.Move;
+const MoveSlot = data.MoveSlot;
+const Pokemon = data.Pokemon;
+const Side = data.Side;
+const Species = data.Species;
+const Stats = data.Stats;
+const Status = data.Status;
+
+pub fn update(battle: anytype, c1: Choice, c2: Choice, log: anytype) !Result {
+    _ = battle;
+    _ = c1;
+    _ = c2;
+    _ = log;
+
+    return Result.Default;
+}
+
+pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Choice) u8 {
+    _ = battle;
+    _ = player;
+    _ = request;
+    _ = out;
+
+    return 0;
+}

package/src/lib/pkmn.zig

@@ -0,0 +1,54 @@
+/// Configurated Options for the pkmn package.
+pub const options = @import("common/options.zig");
+/// Configures the behavior of the pkmn package.
+pub const Options = options.Options;
+
+/// The minimum size in bytes required to hold all choice options.
+pub const MAX_OPTIONS = gen1.MAX_OPTIONS;
+/// The optimal size in bytes required to hold all choice options.
+/// At least as large as `MAX_OPTIONS`.
+pub const OPTIONS_SIZE = gen1.OPTIONS_SIZE;
+/// The maximum number of bytes possibly logged by a single update.
+pub const MAX_LOGS = gen1.MAX_LOGS;
+/// The optimal size in bytes required to hold the largest amount of log data
+/// possible from a single update. At least as large as `MAX_LOGS`.
+pub const LOGS_SIZE = gen1.LOGS_SIZE;
+
+/// Representation of one of the battle's participants.
+pub const Player = @import("common/data.zig").Player;
+/// A choice made by a player during battle.
+pub const Choice = @import("common/data.zig").Choice;
+/// The result of the battle - all results other than 'None' should be
+/// considered terminal.
+pub const Result = @import("common/data.zig").Result;
+
+/// Pokémon Showdown's RNG (backed by a Generation V & VI RNG).
+pub const PSRNG = @import("common/rng.zig").PSRNG;
+
+/// Namespace for helpers related to protocol trace logging.
+pub const protocol = if (options.internal) struct {
+    pub usingnamespace @import("common/protocol.zig");
+} else struct {
+    /// Logs protocol information to its `Writer` during a battle update when
+    /// `options.trace` is enabled.
+    pub const Log = @import("common/protocol.zig").Log;
+    /// Stripped down version of `std.io.FixedBufferStream` optimized for
+    /// efficiently writing the individual protocol bytes. Note that the
+    /// `ByteStream.Writer` is **not** a `std.io.Writer` and should not be
+    /// used for general purpose writing.
+    pub const ByteStream = @import("common/protocol.zig").ByteStream;
+    /// `Log` type backed by the optimized `ByteStream.Writer`. Intended to be
+    /// intialized with a `LOGS_SIZE`-sized buffer.
+    pub const FixedLog = @import("common/protocol.zig").FixedLog;
+    /// Null object pattern implementation of `Log` backed by a
+    /// `std.io.null_writer`. Ignores anything sent to it, though trace logging
+    /// should addtionally be turned off entirely by using `options.trace`.
+    pub const NULL = @import("common/protocol.zig").NULL;
+};
+
+/// Namespace for Generation I Pokémon
+pub const gen1 = struct {
+    pub usingnamespace @import("gen1/data.zig");
+    /// Provides helpers for initializing Generation I Pokémon battles.
+    pub const helpers = @import("gen1/helpers.zig");
+};

package/src/test/display/pkmn.html.tmpl

@@ -0,0 +1,368 @@
+<!doctype html>
+<html lang=en>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="icon" href="https://pkmn.cc/favicon.ico">
+    <title>@pkmn/engine</title>
+    <style>
+      #content {
+        font-family: "Roboto", "Helvetica Neue", "Helvetica", "Arial", sans-serif;
+        margin: 4em auto;
+        max-width: 1300px;
+        line-height: 1.4em;
+        --hp-bar: 151px;
+        --hp-text: 32px;
+      }
+      details > summary {
+        list-style: none;
+      }
+      details > summary::-webkit-details-marker {
+        display: none;
+      }
+      .battle > .details {
+        background: #eee;
+        border-bottom: 3px solid black;
+        padding: 0 0.5em;
+        display: flex;
+        justify-content: space-between;
+      }
+      .inner {
+        display: flex;
+        justify-content: center;
+        flex-direction: column;
+      }
+      .side > .details {
+        padding: 0.5em;
+        display: flex;
+        justify-content: space-between;
+        text-align: center;
+        flex: 0 1 auto;
+      }
+      .active {
+        flex: 1 1 auto;
+      }
+      details {
+        flex: 0 1 auto;
+      }
+      .sides {
+        display: flex;
+      }
+      .side {
+        flex: 1;
+        display: flex;
+        flex-flow: column;
+      }
+      .side.p1 {
+        border-right: 1px solid black;
+      }
+      .battle {
+        border: 3px solid black;
+      }
+      summary {
+        border-top: 1px solid black;
+        text-align: center;
+        padding: 0.25em;
+      }
+      .good {
+        color: green;
+      }
+      .bad {
+        color: red;
+      }
+      .pokemon {
+        position: relative;
+        padding: 0.5em;
+        border-top: 1px solid black;
+        display: flex;
+      }
+      table {
+        border-collapse: collapse;
+        border-style: hidden;
+        border-spacing: 0px;
+        line-height: 1.5em;
+      }
+      th, td {
+        border: 1px solid black;
+        padding: 0 0.5em;
+      }
+      .statbar {
+        display: none;
+        width: calc(var(--hp-bar) + var(--hp-text));
+        padding: 2px 0;
+        line-height: normal;
+      }
+      .statbar .name {
+        display: block;
+        text-align: center;
+        line-height: 1.25em;
+      }
+      .statbar strong {
+        color: #222222;
+        text-shadow:
+          #FFFFFF 1px 1px 0, #FFFFFF 1px -1px 0,
+          #FFFFFF -1px 1px 0, #FFFFFF -1px -1px 0;
+      }
+      .statbar strong small {
+        font-weight: normal;
+      }
+      .statbar .hpbar {
+        position: relative;
+        border: 1px solid #777777;
+        background: #FCFEFF;
+        padding: 1px;
+        height: 8px;
+        margin: 0 0 0 0;
+        width: calc(var(--hp-bar) + var(--hp-text) + 1px);
+        border-radius: 4px;
+      }
+      .statbar .hpbar .hp {
+        height: 4px;
+        border-top: 2px solid #00dd60;
+        background: #00bb51;
+        border-bottom: 2px solid #007734;
+        border-right: 1px solid #007734;
+        border-radius: 3px;
+      }
+      .statbar .hpbar .hp-yellow {
+        border-top-color: #f8e379;
+        background-color: #f5d538;
+        border-bottom-color: #be9f0a;
+        border-right-color: #be9f0a;
+      }
+      .statbar .hpbar .hp-red {
+        border-top-color: #f37f67;
+        background-color: #ee4928;
+        border-bottom-color: #a3260d;
+        border-right-color: #a3260d;
+      }
+      .statbar .hpbar .prevhp {
+        background: #BBEECC;
+        height: 8px;
+        border-radius: 3px;
+      }
+      .statbar .hpbar .prevhp-yellow {
+        background-color: #fcf4ca;
+      }
+      .statbar .hpbar .prevhp-red {
+        background-color: #facec5;
+      }
+      .statbar .hpbar .hptext {
+        position: absolute;
+        background: #777777;
+        color: #EEEEEE;
+        text-shadow: #000000 0 1px 0;
+        font-size: 10px;
+        width: 32px;
+        height: 12px;
+        top: -1px;
+        text-align: center;
+      }
+      .status, .volatile {
+        padding: 0px 1px;
+        border: 1px solid #FF4400;
+        border-radius: 3px;
+      }
+      .status {
+        min-height: 10px;
+        font-size: 7pt;
+        vertical-align: middle;
+        padding: 1px 2px;
+        border: 0;
+        border-radius: 3px;
+        text-transform: uppercase;
+        margin: 0 2px;
+      }
+      .status.brn {
+        background: #EE5533;
+        color: #FFFFFF;
+      }
+      .status.psn {
+        background: #A4009A;
+        color: #FFFFFF;
+      }
+      .status.par {
+        background: #9AA400;
+        color: #FFFFFF;
+      }
+      .status.slp {
+        background: #AA77AA;
+        color: #FFFFFF;
+      }
+      .status.frz {
+        background: #009AA4;
+        color: #FFFFFF;
+      }
+      .volatile {
+        display: inline-block;
+        padding: 0 5px;
+        margin: 2px
+      }
+      .volatile.bad {
+        background: #FFE5E0;
+        color: #FF4400;
+        border-color: #FF4400;
+      }
+      .volatile.good {
+        background: #E5FFE0;
+        color: #33AA00;
+        border-color: #33AA00;
+      }
+      .volatile.neutral {
+        background: #F0F0F0;
+        color: #555555;
+        border-color: #555555;
+      }
+      .rstatbar .hpbar .hptext {
+        right: 0px;
+        border-radius: 0 4px 4px 0;
+      }
+      .moves ul {
+        column-count: 2;
+        column-gap: 2em;
+      }
+      .left {
+        padding-right: 32px;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+      }
+      .stats {
+        display: flex;
+        padding: 0 1em;
+        justify-content: space-between;
+        text-align: center;
+        width: 100%;
+      }
+      .types {
+        display: inherit;
+      }
+      .disabled {
+        color: #AAAAAA;
+      }
+      .log {
+        display: flex;
+        justify-content: center;
+        padding-bottom: 2em;
+      }
+      .position {
+        position: absolute;
+        right: 10px;
+        color: #AAAAAA;
+      }
+      .left .position {
+        display: none;
+      }
+      .right .position {
+        display: block;
+      }
+      .teamicons {
+        display: inline-block;
+      }
+      @media(max-width: 1300px) {
+        #content {
+          font-size: 0.85em;
+          max-width: 95%;
+          margin: 2em auto;
+        }
+      }
+      @media(max-width: 1200px) {
+        .moves ul {
+          column-count: 1;
+        }
+      }
+      @media(max-width: 1100px) {
+        .pokemon {
+          flex-direction: column;
+        }
+        .stats {
+          justify-content: center;
+          padding: 0;
+        }
+        .boosts {
+          margin-left: 5px;
+        }
+        .moves ul {
+          column-count: 2;
+        }
+        .left {
+          padding-right: 0;
+        }
+        .right {
+          padding-top: 1em;
+        }
+        .volatiles {
+          display: flex;
+          justify-content: center;
+          flex-wrap: wrap;
+        }
+        .left .position {
+          display: block;
+        }
+        .right .position {
+          display: none;
+        }
+      }
+      @media(max-width: 800px) {
+        .moves {
+          display: flex;
+          justify-content: center;
+        }
+        .moves ul {
+          column-count: 1;
+          display: inline-block;
+          padding: 0;
+        }
+      }
+      @media(max-width: 680px) {
+        .stats {
+          flex-direction: column;
+          padding: 0;
+        }
+        .boosts {
+          display: flex;
+          justify-content: space-between;
+          margin-top: 0.5em;
+        }
+      }
+      @media(max-width: 550px) {
+        #content {
+          font-size: 0.65em;
+          max-width: 95%;
+          margin: 1em auto;
+          --hp-bar: 101px;
+        }
+      }
+      @media(max-width: 425px) {
+        .stats {
+          font-size: 0.9em;
+        }
+      }
+      h1 {
+        text-align: center;
+      }
+      .error {
+        overflow: auto;
+        scrollbar-width: none;
+        padding: 10px 20px;
+        border: 3px solid #DD4422;
+        background: #FFF8F2;
+      }
+      .error::-webkit-scrollbar {
+        display: none;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="content">{{{ content }}}</div>
+    <script>
+      for (const details of document.getElementsByTagName('details')) {
+        details.addEventListener('toggle', e => {
+          for (const d of details.parentElement.parentElement.getElementsByTagName('details')) {
+            if (d.open !== details.open) d.open = details.open;
+          }
+        });
+      }
+    </script>
+  </body>
+</html>