@pkmn/engine 0.1.0-dev.cbdbb719 → 0.1.0-dev.ce4c0b2a

package/src/lib/gen1/calc.zig

@@ -35,7 +35,11 @@ const isPointerTo = util.isPointerTo;
 const Actions = chance.Actions;
 const Action = chance.Action;
 const Chance = chance.Chance;
+const Confusion = chance.Confusion;
+const Duration = chance.Duration;
 const Durations = chance.Durations;
+const Observation = chance.Observation;
+const Sleeps = chance.Sleeps;
 
 const tty = true; // DEBUG
 const summary = false; // DEBUG
@@ -194,9 +198,11 @@ pub fn transitions(
     var frontier = std.ArrayList(Actions).init(allocator);
     defer frontier.deinit();
 
+    const durations = options.durations;
+
     var opts = pkmn.battle.options(
         protocol.NULL,
-        Chance(Rational(u128)){ .probability = .{}, .durations = options.durations },
+        Chance(Rational(u128)){ .probability = .{}, .durations = durations },
         Calc{},
     );
 
@@ -220,6 +226,7 @@ pub fn transitions(
     assert(frontier.items.len == 1);
     while (i < frontier.items.len) : (i += 1) {
         const f = frontier.items[i];
+        const saved = stats.saved;
 
         try debug(writer, f, .{
             .shape = true,
@@ -235,10 +242,20 @@ pub fn transitions(
         };
 
         for (Rolls.speedTie(f.p1)) |tie| { a.p1.speed_tie = tie; a.p2.speed_tie = tie;
-        for (Rolls.confused(f.p1)) |p1_cfzd| { a.p1.confused = p1_cfzd;
-        for (Rolls.confused(f.p2)) |p2_cfzd| { a.p2.confused = p2_cfzd;
+        for (Rolls.sleep(f.p1, durations.p1)) |p1_slp| { a.p1.sleep = p1_slp;
+        for (Rolls.sleep(f.p2, durations.p2)) |p2_slp| { a.p2.sleep = p2_slp;
+        for (Rolls.disable(f.p1, durations.p1, p1_slp)) |p1_dis| { a.p1.disable = p1_dis;
+        for (Rolls.disable(f.p2, durations.p2, p2_slp)) |p2_dis| { a.p2.disable = p2_dis;
+        for (Rolls.confusion(f.p1, durations.p1, p1_slp)) |p1_cfz| { a.p1.confusion = p1_cfz;
+        for (Rolls.confusion(f.p2, durations.p2, p1_slp)) |p2_cfz| { a.p2.confusion = p2_cfz;
+        for (Rolls.confused(f.p1, p1_cfz)) |p1_cfzd| { a.p1.confused = p1_cfzd;
+        for (Rolls.confused(f.p2, p2_cfz)) |p2_cfzd| { a.p2.confused = p2_cfzd;
         for (Rolls.paralyzed(f.p1, p1_cfzd)) |p1_par| { a.p1.paralyzed = p1_par;
         for (Rolls.paralyzed(f.p2, p2_cfzd)) |p2_par| { a.p2.paralyzed = p2_par;
+        for (Rolls.attacking(f.p1, durations.p1, p1_par)) |p1_atk| { a.p1.attacking = p1_atk;
+        for (Rolls.attacking(f.p2, durations.p2, p2_par)) |p2_atk| { a.p2.attacking = p2_atk;
+        for (Rolls.binding(f.p1, durations.p1, p1_par)) |p1_bind| { a.p1.binding = p1_bind;
+        for (Rolls.binding(f.p2, durations.p2, p2_par)) |p2_bind| { a.p2.binding = p2_bind;
         for (Rolls.hit(f.p1, p1_par)) |p1_hit| { a.p1.hit = p1_hit;
         for (Rolls.hit(f.p2, p2_par)) |p2_hit| { a.p2.hit = p2_hit;
         for (Rolls.psywave(f.p1, p1, p1_hit)) |p1_psywave| { a.p1.psywave = p1_psywave;
@@ -266,7 +283,7 @@ pub fn transitions(
 
                 opts.calc.overrides = a;
                 opts.calc.summaries = .{};
-                opts.chance = .{ .probability = .{}, .durations = options.durations };
+                opts.chance = .{ .probability = .{}, .durations = durations };
                 const q = &opts.chance.probability;
 
                 b = battle;
@@ -283,7 +300,7 @@ pub fn transitions(
                     try Rolls.coalesce(.P2, @as(u8, @intCast(p2_dmg.min)), summaries, cap);
 
                 if (opts.chance.actions.matches(f)) {
-                    if (!opts.chance.actions.eql(a)) {
+                    if (!map(opts.chance.actions).eql(a)) {
                         if (!summary) {
                             try debug(writer, opts.chance.actions, .{
                                 .p1_max = p1_max,
@@ -358,9 +375,11 @@ pub fn transitions(
                 p2_dmg.min = p2_max;
             }
 
-        }}}}}}}}}}}}}}}}}}
+        }}}}}}}}}}}}}}}}}}}}}}}}}}}}
 
-        if (@TypeOf(writer) != @TypeOf(std.io.null_writer)) {
+        assert(stats.saved > saved);
+        const old = @hasDecl(std.fmt, "formatFloatDecimal");
+        if (!old and @TypeOf(writer) != @TypeOf(std.io.null_writer)) {
             p.reduce();
             try writer.print(
                 "  = {s} ({d:.2}%)\n\n",
@@ -496,6 +515,14 @@ fn unfix(actual: anytype) data.Battle(data.PRNG) {
     };
 }
 
+fn map(actions: Actions) Actions {
+    if (!pkmn.options.overwrite) return actions;
+    var a = actions;
+    if (a.p1.confusion == .overwritten) a.p1.confusion = .continuing;
+    if (a.p2.confusion == .overwritten) a.p2.confusion = .continuing;
+    return a;
+}
+
 fn matches(actions: Actions, i: usize, frontier: []Actions) bool {
     for (frontier, 0..) |f, j| {
         // TODO: is skipping this redundant check worth it?
@@ -577,8 +604,6 @@ fn format(writer: anytype, actions: Actions, p1: u9, p2: u9) !void {
     try writer.writeAll(output[0..len]);
 }
 
-const NONE = @intFromEnum(Optional(bool).None);
-
 /// Helper functions that efficiently return valid ranges for various RNG events based on the
 /// state of an `Action` and other events to be used to construct a "transitions" function.
 pub const Rolls = struct {
@@ -590,6 +615,101 @@ pub const Rolls = struct {
         return if (action.speed_tie == .None) &PLAYER_NONE else &PLAYERS;
     }
 
+    const OBS_NONE = [_]Optional(Observation){.None};
+    const OBS_STARTED = [_]Optional(Observation){.started};
+    const OBS_CONTINUING = [_]Optional(Observation){.continuing};
+    const OBS_ENDED = [_]Optional(Observation){.ended};
+    const OBS = [_]Optional(Observation){ .continuing, .ended };
+
+    /// Returns a slice with a range of values for sleep given the `action` state and observed
+    /// `durations`.
+    pub fn sleep(action: Action, duration: Duration) []const Optional(Observation) {
+        return switch (action.sleep) {
+            .None => &OBS_NONE,
+            .started => &OBS_STARTED,
+            else => if (Sleeps.get(duration.sleeps, 0) >= 7) &OBS_ENDED else &OBS,
+        };
+    }
+
+    /// Returns a slice with a range of values for disable given the `action`, observed `durations`,
+    /// and the state of the `parent` (observation of the player's Pokémon sleep status).
+    pub fn disable(
+        action: Action,
+        duration: Duration,
+        parent: Optional(Observation),
+    ) []const Optional(Observation) {
+        // if (parent == .started or parent == .continuing) return &OBS_NONE;
+        _ = parent; // FIXME
+        return switch (action.disable) {
+            .None => &OBS_NONE,
+            .started => &OBS_STARTED,
+            else => if (duration.disable >= 8) &OBS_ENDED else &OBS,
+        };
+    }
+
+    const CFZ_NONE = [_]Optional(Confusion){.None};
+    const CFZ_STARTED = [_]Optional(Confusion){.started};
+    const CFZ_CONTINUING = [_]Optional(Confusion){.continuing};
+    const CFZ_ENDED = [_]Optional(Confusion){.ended};
+    const CFZ = [_]Optional(Confusion){ .continuing, .ended };
+
+    /// Returns a slice with a range of values for confusion given the `action`, observed `durations`,
+    /// and the state of the `parent` (observation of the player's Pokémon sleep status).
+    pub fn confusion(
+        action: Action,
+        duration: Duration,
+        parent: Optional(Observation),
+    ) []const Optional(Confusion) {
+        // if (parent == .started or parent == .continuing) return &CFZ_NONE;
+        _ = parent; // FIXME
+        return switch (action.confusion) {
+            .None => &CFZ_NONE,
+            .started => &CFZ_STARTED,
+            else => if (duration.confusion >= 5)
+                &CFZ_ENDED
+            else if (duration.confusion < 2)
+                &CFZ_CONTINUING
+            else
+                &CFZ,
+        };
+    }
+
+    /// Returns a slice with a range of values for attacking given the `action`, observed
+    /// `durations`, and the state of the `parent` (whether the player's Pokémon was fully
+    /// paralyzed).
+    pub fn attacking(
+        action: Action,
+        duration: Duration,
+        parent: Optional(bool),
+    ) []const Optional(Observation) {
+        if (parent == .true) return &OBS_NONE;
+        return switch (action.attacking) {
+            .None => &OBS_NONE,
+            .started => &OBS_STARTED,
+            else => if (duration.attacking >= 3)
+                &OBS_ENDED
+            else if (duration.attacking < 2)
+                &OBS_CONTINUING
+            else
+                &OBS,
+        };
+    }
+
+    /// Returns a slice with a range of values for binding given the `action`, observed `durations`,
+    /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
+    pub fn binding(
+        action: Action,
+        duration: Duration,
+        parent: Optional(bool),
+    ) []const Optional(Observation) {
+        if (parent == .true) return &OBS_NONE;
+        return switch (action.binding) {
+            .None => &OBS_NONE,
+            .started => &OBS_STARTED,
+            else => if (duration.binding >= 4) &OBS_ENDED else &OBS,
+        };
+    }
+
     const BOOL_NONE = [_]Optional(bool){.None};
     const BOOLS = [_]Optional(bool){ .false, .true };
 
@@ -638,9 +758,12 @@ pub const Rolls = struct {
         return @min(255, roll + ((254 - ((@as(u32, dmg.base) * roll) % 255)) / dmg.base));
     }
 
-    /// Returns a slice with the correct range of values for confused.
-    pub fn confused(action: Action) []const Optional(bool) {
-        return if (action.confused == .None) &BOOL_NONE else &BOOLS;
+    /// Returns a slice with the correct range of values for confused given the `action` state and
+    /// the state of the `parent` (observation of the player's Pokémon confusion status).
+    pub fn confused(action: Action, parent: Optional(Confusion)) []const Optional(bool) {
+        const done = false; // parent == .None or parent == .ended;
+        _ = parent; // FIXME
+        return if (done or action.confused == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for paralysis given the `action` state
@@ -707,6 +830,26 @@ test "Rolls.speedTie" {
     try expectEqualSlices(Optional(Player), &.{.None}, Rolls.speedTie(actions.p2));
 }
 
+test "Rolls.sleep" {
+    return error.SkipZigTest; // TODO
+}
+
+test "Rolls.disable" {
+    return error.SkipZigTest; // TODO
+}
+
+test "Rolls.confusion" {
+    return error.SkipZigTest; // TODO
+}
+
+test "Rolls.atacking" {
+    return error.SkipZigTest; // TODO
+}
+
+test "Rolls.binding" {
+    return error.SkipZigTest; // TODO
+}
+
 test "Rolls.damage" {
     const actions: Actions = .{ .p2 = .{ .damage = 221 } };
     try expectEqual(Rolls.Range{ .min = 0, .max = 1 }, Rolls.damage(actions.p1, .None));
@@ -756,8 +899,9 @@ test "Rolls.criticalHit" {
 
 test "Rolls.confused" {
     const actions: Actions = .{ .p2 = .{ .confused = .true } };
-    try expectEqualSlices(Optional(bool), &.{.None}, Rolls.confused(actions.p1));
-    try expectEqualSlices(Optional(bool), &.{ .false, .true }, Rolls.confused(actions.p2));
+    try expectEqualSlices(Optional(bool), &.{.None}, Rolls.confused(actions.p1, .None));
+    try expectEqualSlices(Optional(bool), &.{ .false, .true }, Rolls.confused(actions.p2, .continuing));
+    // FIXME try expectEqualSlices(Optional(bool), &.{.None}, Rolls.confused(actions.p2, .ended));
 }
 
 test "Rolls.paralyzed" {

package/src/lib/gen1/chance.zig

@@ -251,7 +251,7 @@ pub const Durations = struct {
     }
 };
 
-const Sleeps = Array(6, u3);
+pub const Sleeps = Array(6, u3);
 
 /// TODO
 pub const Duration = packed struct(u32) {
@@ -656,6 +656,7 @@ pub fn Chance(comptime Rational: type) type {
             var d = self.durations.get(player);
             const n = d.attacking;
             if (obs == .ended) {
+                // "3-4 turns" includes the turn for the initial attack *plus* the forced attacks
                 assert(n >= 2 and n <= 3);
                 if (n != 3) try self.probability.update(1, 4 - @as(u4, n));
                 d.attacking = 0;
@@ -682,6 +683,7 @@ pub fn Chance(comptime Rational: type) type {
             const q: u4 = if (n < 3) 8 - ((n - 1) * p) else 2;
 
             if (obs == .ended) {
+                // "2-5 turns" includes the turn for the initial attack *plus* the forced attacks
                 assert(n >= 1 and n <= 4);
                 if (n != 4) try self.probability.update(p, q);
                 d.binding = 0;

package/src/lib/gen1/data.zig

@@ -256,7 +256,7 @@ pub const Status = enum(u8) {
 
     pub const TOX = 0b10001000;
 
-    const SLP = 0b111;
+    const SLEEP = 0b111;
 
     /// Whether or not the status `num` is the same as `status`.
     pub fn is(num: u8, status: Status) bool {
@@ -284,7 +284,7 @@ pub const Status = enum(u8) {
 
     /// Returns the duration of a sleep status.
     pub fn duration(num: u8) u3 {
-        return @intCast(num & SLP);
+        return @intCast(num & SLEEP);
     }
 
     /// Returns whether `num` reflects any status.

package/src/lib/gen1/helpers.zig

@@ -12,10 +12,8 @@ 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;
 
@@ -24,7 +22,6 @@ const Move = data.Move;
 const MoveSlot = data.MoveSlot;
 const Species = data.Species;
 const Stats = data.Stats;
-const Status = data.Status;
 
 const endian = builtin.cpu.arch.endian();
 

package/src/lib/gen1/mechanics.zig

@@ -4,7 +4,6 @@ const pkmn = @import("../pkmn.zig");
 
 const common = @import("../common/data.zig");
 const DEBUG = @import("../common/debug.zig").print;
-const optional = @import("../common/optional.zig");
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
 
@@ -29,11 +28,9 @@ 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;
@@ -344,6 +341,7 @@ fn doTurn(
         player_choice,
         player_rewrap,
         player_skip,
+        true,
         &residual,
         options,
     )) |r| return r;
@@ -366,6 +364,7 @@ fn doTurn(
         foe_choice,
         foe_rewrap,
         foe_skip,
+        false,
         &residual,
         options,
     )) |r| return r;
@@ -393,6 +392,7 @@ fn executeMove(
     choice: Choice,
     rewrap: bool,
     skip: bool,
+    first: bool,
     residual: *bool,
     options: anytype,
 ) !?Result {
@@ -452,7 +452,7 @@ fn executeMove(
 
     var skip_can = false;
     var skip_pp = false;
-    switch (try beforeMove(battle, player, skip, residual, options)) {
+    switch (try beforeMove(battle, player, skip, first, residual, options)) {
         .done => return null,
         .skip_can => skip_can = true,
         .skip_pp => skip_pp = true,
@@ -473,6 +473,7 @@ fn beforeMove(
     battle: anytype,
     player: Player,
     skip: bool,
+    first: bool,
     residual: *bool,
     options: anytype,
 ) !BeforeMove {
@@ -564,7 +565,13 @@ fn beforeMove(
     if (volatiles.Confusion) {
         assert(volatiles.confusion > 0);
         if (options.calc.overridden(player, .confusion)) |obs| switch (obs) {
-            .started => volatiles.confusion -= 1,
+            .started => {
+                if (!first or (options.calc.overridden(player, .confused) orelse .None) != .None) {
+                    volatiles.confusion -= 1;
+                } else {
+                    volatiles.confusion = 0;
+                }
+            },
             .continuing => if (volatiles.confusion > 1) {
                 volatiles.confusion -= 1;
             },
@@ -696,7 +703,7 @@ fn beforeMove(
         try options.chance.attacking(player, if (volatiles.attacks == 0) .ended else .continuing);
 
         if (volatiles.attacks == 0) {
-            const overwritten = volatiles.Confusion;
+            const overwritten = pkmn.options.overwrite and volatiles.Confusion;
 
             volatiles.Thrashing = false;
             volatiles.Confusion = true;

package/src/lib/gen2/calc.zig

@@ -154,7 +154,7 @@ const Null = struct {
 
 fn ReturnType(comptime field: Action.Field) type {
     return ?(switch (field) {
-        .damages => u6,
+        .damages => u8,
         .critical_hits => Optional(bool),
         else => std.meta.FieldType(Action, field),
     });

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;
 
@@ -111,7 +108,7 @@ test Actions {
 /// Observation made about a duration - whether the duration has started, been continued, or ended.
 pub const Observation = enum { started, continuing, ended };
 
-pub const Damages = Array(5, u6);
+pub const Damages = Array(5, u8);
 pub const Criticals = Array(5, Optional(bool));
 
 /// Information about the RNG that was observed during a Generation II battle `update` for a
@@ -164,10 +161,6 @@ pub const Action = packed struct(u128) {
     /// If not 0, the value (2-5) to return for Rolls.distribution for multi hit.
     multi_hit: u3 = 0,
 
-    _: u9 = 0,
-
-    /// If not 0, the value to by one of the Rolls.*Duration rolls.
-    duration: u4 = 0,
     sleep: Optional(Observation) = .None,
     /// TODO
     confusion: Optional(Observation) = .None,
@@ -180,6 +173,8 @@ pub const Action = packed struct(u128) {
     /// TODO
     encore: Optional(Observation) = .None,
 
+    /// If not 0, the value to by one of the Rolls.*Duration rolls.
+    duration: u3 = 0,
     /// If not None, the value to return for Rolls.conversion2.
     conversion_2: Optional(Type) = .None,
 
@@ -292,7 +287,7 @@ pub fn Chance(comptime Rational: type) type {
 
             try self.probability.update(1, 39);
             var a = self.actions.get(player);
-            a.damages = Damages.set(a.damages, i, @intCast(roll - 216));
+            a.damages = Damages.set(a.damages, i, roll);
         }
 
         pub fn confused(self: *Self, player: Player, cfz: bool) Error!void {
@@ -444,7 +439,7 @@ pub fn Chance(comptime Rational: type) type {
             self.actions.get(player).multi_hit = n;
         }
 
-        pub fn duration(self: *Self, player: Player, turns: u4) void {
+        pub fn duration(self: *Self, player: Player, turns: u3) void {
             if (!enabled) return;
 
             self.actions.get(player).duration = if (options.key) 2 else turns;
@@ -514,7 +509,7 @@ test "Chance.damage" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
     try chance.damage(.P1, 0, 219);
-    try expectValue(@as(u6, 3), Damages.get(chance.actions.p1.damages, 0));
+    try expectValue(@as(u8, 219), Damages.get(chance.actions.p1.damages, 0));
     try expectProbability(&chance.probability, 1, 39);
 }
 
@@ -783,7 +778,7 @@ test "Chance.duration" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
     chance.duration(.P1, 2);
-    try expectValue(@as(u4, 2), chance.actions.p1.duration);
+    try expectValue(@as(u3, 2), chance.actions.p1.duration);
 }
 
 pub fn expectProbability(r: anytype, p: u64, q: u64) !void {
@@ -901,7 +896,7 @@ const Null = struct {
         _ = .{ self, player, move, n };
     }
 
-    pub fn duration(self: Null, player: Player, turns: u4) void {
+    pub fn duration(self: Null, player: Player, turns: u3) void {
         _ = .{ self, player, turns };
     }
 };

package/src/lib/gen2/helpers.zig

@@ -2,7 +2,6 @@ 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");
@@ -11,8 +10,6 @@ const data = @import("data.zig");
 
 const assert = std.debug.assert;
 
-const expectEqual = std.testing.expectEqual;
-
 const Choice = common.Choice;
 
 const showdown = options.showdown;
@@ -25,7 +22,6 @@ const Move = data.Move;
 const MoveSlot = data.MoveSlot;
 const Species = data.Species;
 const Stats = data.Stats;
-const Status = data.Status;
 
 const Struct = if (@hasField(std.builtin.Type, "struct")) .@"struct" else .Struct;
 

package/src/lib/gen2/mechanics.zig

@@ -6,7 +6,6 @@ const common = @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 data = @import("data.zig");
 const generated = @import("generated.zig");
@@ -34,17 +33,12 @@ const Start = protocol.Start;
 
 const Gen12 = rng.Gen12;
 
-const PointerType = util.PointerType;
-
 const ActivePokemon = data.ActivePokemon;
 const Boosts = data.Boosts;
 const Effectiveness = data.Effectiveness;
 const Item = data.Item;
 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;
 const TriAttack = data.TriAttack;
@@ -2901,7 +2895,7 @@ pub const Rolls = struct {
     fn damage(battle: anytype, player: Player, i: u3, options: anytype) !u8 {
         _ = .{ player, options };
         const roll = if (options.calc.overridden(player, i, .damages)) |val|
-            @as(u8, val) + 216
+            val
         else roll: {
             if (showdown) break :roll battle.rng.range(u8, 217, 256);
             while (true) {
@@ -3357,11 +3351,11 @@ pub const Rolls = struct {
     }
 
     fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
-        const duration: u4 = if (options.calc.overridden(player, 0, .duration)) |val|
+        const duration: u3 = if (options.calc.overridden(player, 0, .duration)) |val|
             @intCast(val)
         else if (showdown)
             // Pokémon Showdown incorrectly inherits Generation III's Disable duration
-            battle.rng.range(u4, 2, 6)
+            battle.rng.range(u3, 2, 6)
         else duration: {
             while (true) {
                 const r = battle.rng.next() & 7;

package/src/tools/display/dom.ts

@@ -0,0 +1,96 @@
+/** @license MIT modified from Vadim Demedes's https://github.com/vadimdemedes/dom-chef */
+type Attributes = JSX.IntrinsicElements['div'];
+type DocumentFragmentConstructor = typeof DocumentFragment;
+type ElementFunction = (props?: any) => HTMLElement;
+
+declare global {
+  namespace JSX {
+    interface Element extends HTMLElement, DocumentFragment {
+      addEventListener: HTMLElement['addEventListener'];
+      removeEventListener: HTMLElement['removeEventListener'];
+      className: HTMLElement['className'];
+    }
+  }
+}
+
+interface JSXElementClassDocumentFragment extends DocumentFragment, JSX.ElementClass { }
+interface Fragment {
+  prototype: JSXElementClassDocumentFragment;
+  new(): JSXElementClassDocumentFragment;
+}
+
+// https://github.com/preactjs/preact/blob/1bbd687c/src/constants.js#L3
+const IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;
+
+const isFragment = (type: DocumentFragmentConstructor | ElementFunction):
+  type is DocumentFragmentConstructor => type === DocumentFragment;
+
+const setCSSProps = (element: HTMLElement, style: CSSStyleDeclaration) => {
+  for (const [name, value] of Object.entries(style)) {
+    if (name.startsWith('-')) {
+      element.style.setProperty(name, value);
+    } else if (typeof value === 'number' && !IS_NON_DIMENSIONAL.test(name)) {
+      element.style[name as any] = `${value as string}px`;
+    } else {
+      element.style[name as any] = value;
+    }
+  }
+};
+
+const setAttribute = (element: HTMLElement, name: string, value: string) => {
+  if (value !== undefined && value !== null) element.setAttribute(name, value);
+};
+
+const addChildren = (parent: Element | DocumentFragment, children: Node[]) => {
+  for (const child of children) {
+    if (child instanceof Node) {
+      parent.appendChild(child);
+    } else if (Array.isArray(child)) {
+      addChildren(parent, child);
+    } else if (typeof child !== 'boolean' && typeof child !== 'undefined' && child !== null) {
+      parent.appendChild(document.createTextNode(child));
+    }
+  }
+};
+
+// https://github.com/facebook/react/blob/3f899089/packages/react-dom/src/shared/DOMProperty.js#L288-L322
+const FALSIFIABLE_ATTRIBUTES = ['contentEditable', 'draggable', 'spellCheck', 'value'];
+
+export const h = (
+  type: DocumentFragmentConstructor | ElementFunction | string,
+  attributes?: Attributes,
+  ...children: Node[]
+) => {
+  if (typeof type !== 'string') {
+    const element = isFragment(type) ? document.createDocumentFragment() : type(attributes);
+    addChildren(element, children);
+    return element;
+  }
+
+  const element = document.createElement(type);
+  addChildren(element, children);
+  if (!attributes) return element;
+
+  for (let [name, value] of Object.entries(attributes)) {
+    if (name === 'htmlFor') name = 'for';
+
+    if (name === 'class' || name === 'className') {
+      const existingClassname = element.getAttribute('class') ?? '';
+      setAttribute(element, 'class', (existingClassname + ' ' + String(value)).trim());
+    } else if (name === 'style') {
+      setCSSProps(element, value);
+    } else if (name.startsWith('on')) {
+      const eventName = name.slice(2).toLowerCase().replace(/^-/, '');
+      element.addEventListener(eventName, value);
+    } else if (name === 'dangerouslySetInnerHTML' && '__html' in value) {
+      element.innerHTML = value.__html;
+    } else if (name !== 'key' && (FALSIFIABLE_ATTRIBUTES.includes(name) || value !== false)) {
+      setAttribute(element, name, value === true ? '' : value);
+    }
+  }
+
+  return element;
+};
+
+export const Fragment =
+  (typeof DocumentFragment === 'function' ? DocumentFragment : () => {}) as Fragment;