@pkmn/engine 0.1.0-dev.84cc1a02 → 0.1.0-dev.942dbfa4

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

@@ -219,18 +219,18 @@ pub const Item = enum(u8) {
     pub inline fn boost(item: Item) ?Type {
         assert(item != .None);
         if (item == .PolkadotBow) return .Normal;
-        return if (@enumToInt(item) <= 18) @intToEnum(Type, @enumToInt(item) - 1) else null;
+        return if (@intFromEnum(item) <= 18) @enumFromInt(Type, @intFromEnum(item) - 1) else null;
     }
 
     /// Whether or not this item is a Berry.
     pub inline fn berry(item: Item) bool {
         assert(item != .None);
-        return @enumToInt(item) > 30 and @enumToInt(item) <= 40;
+        return @intFromEnum(item) > 30 and @intFromEnum(item) <= 40;
     }
 
     /// Whether or not this item is Mail.
     pub inline fn mail(item: Item) bool {
         assert(item != .None);
-        return @enumToInt(item) > 60 and @enumToInt(item) <= 70;
+        return @intFromEnum(item) > 60 and @intFromEnum(item) <= 70;
     }
 };

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

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

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

@@ -19,13 +19,13 @@ 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
@@ -50,11 +50,11 @@ pub fn Battle(comptime RNG: anytype) type {
         field: Field = .{},
 
         pub inline fn side(self: *Self, player: Player) *Side {
-            return &self.sides[@enumToInt(player)];
+            return &self.sides[@intFromEnum(player)];
         }
 
         pub inline fn foe(self: *Self, player: Player) *Side {
-            return &self.sides[@enumToInt(player.foe())];
+            return &self.sides[@intFromEnum(player.foe())];
         }
 
         pub inline fn active(self: *Self, player: Player) ID {
@@ -208,8 +208,8 @@ const DVs = packed struct {
         const p = @intCast(u6, 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) };
+        if (t >= @intFromEnum(Type.@"???")) t = t + 1;
+        return DVs{ .gender = g, .pow = p, .type = @enumFromInt(Type, t) };
     }
 
     comptime {
@@ -327,7 +327,7 @@ 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 evs = @min(255, @intFromFloat(u16, @ceil(@sqrt(@floatFromInt(f32, exp)))));
             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);
@@ -390,7 +390,7 @@ 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);
@@ -400,7 +400,7 @@ test Move {
 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 +409,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

@@ -158,11 +158,11 @@ pub const Pokemon = struct {
     }
 
     pub fn random(rand: *PSRNG, opt: Options) data.Pokemon {
-        const s = @intToEnum(Species, rand.range(u8, 1, Species.size + 1));
+        const s = @enumFromInt(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 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,7 +184,7 @@ 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(Move, rand.range(u8, 1, 164 + 1));
                 for (0..i) |j| if (ms[j].id == m) continue :sample;
                 break;
             }

package/src/lib/pkmn.zig

@@ -4,10 +4,10 @@ pub const options = @import("common/options.zig");
 pub const Options = options.Options;
 
 /// The minimum size in bytes required to hold all choice options.
-pub const MAX_OPTIONS = gen1.MAX_OPTIONS;
+pub const MAX_CHOICES = gen1.MAX_CHOICES;
 /// 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;
+/// At least as large as `MAX_CHOICES`.
+pub const CHOICES_SIZE = gen1.CHOICES_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
@@ -25,12 +25,12 @@ 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.
+/// Namespace for helpers related to protocol message 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.
+    /// `options.log` 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
@@ -41,8 +41,8 @@ pub const protocol = if (options.internal) struct {
     /// 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`.
+    /// `std.io.null_writer`. Ignores anything sent to it, though protocol
+    /// logging should additionally be turned off entirely with `options.log`.
     pub const NULL = @import("common/protocol.zig").NULL;
 };
 

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>