@pkmn/engine 0.1.0-dev.d4119c62 → 0.1.0-dev.d4bd80b1

package/src/lib/gen2/calc.zig

@@ -1,22 +1,22 @@
-const std = @import("std");
-
-const pkmn = @import("../pkmn.zig");
-
+const chance = @import("chance.zig");
 const common = @import("../common/data.zig");
+const Optional = @import("../common/optional.zig").Optional;
+const pkmn = @import("../pkmn.zig");
+const std = @import("std");
 const util = @import("../common/util.zig");
 
-const chance = @import("chance.zig");
-
+const Action = chance.Action;
+const Actions = chance.Actions;
 const assert = std.debug.assert;
-
+const Criticals = chance.Criticals;
+const Damages = chance.Damages;
 const enabled = pkmn.options.calc;
-
+const isPointerTo = util.isPointerTo;
 const Player = common.Player;
-
 const PointerType = util.PointerType;
 
-const Actions = chance.Actions;
-const Action = chance.Action;
+const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
+const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;
 
 /// Information relevant to damage calculation that occured during a Generation II battle `update`.
 pub const Summaries = extern struct {
@@ -31,7 +31,7 @@ pub const Summaries = extern struct {
 
     /// Returns the `Summary` for the given `player`.
     pub fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Summary) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Summaries);
+        assert(isPointerTo(self, Summaries));
         return if (player == .P1) &self.p1 else &self.p2;
     }
 };
@@ -65,33 +65,34 @@ pub const Summary = extern struct {
     }
 };
 
-/// TODO
-pub const Overrides = extern struct {
-    /// TODO
-    actions: Actions = .{},
-};
-
 /// Allows for forcing the value of specific RNG events during a Generation II battle `update` via
 /// `overrides` and tracks `summaries` of information relevant to damage calculation.
 pub const Calc = struct {
     /// Overrides the normal behavior of the RNG during an `update` to force specific outcomes.
-    overrides: Overrides = .{},
+    overrides: Actions = .{},
     /// Information relevant to damage calculation.
     summaries: Summaries = .{},
 
     pub fn overridden(
         self: Calc,
         player: Player,
+        hit: u3,
         comptime field: Action.Field,
-    ) ?std.meta.FieldType(Action, field) {
+    ) ReturnType(field) {
         if (!enabled) return null;
 
-        const overrides =
-            if (player == .P1) self.overrides.actions.p1 else self.overrides.actions.p2;
-        const val = @field(overrides, @tagName(field));
+        const val = switch (field) {
+            .damages => Damages.get(self.overrides.get(player).damages, hit),
+            .critical_hits => Criticals.get(self.overrides.get(player).critical_hits, hit),
+            else => val: {
+                assert(hit == 0);
+                break :val @field(self.overrides.get(player), @tagName(field));
+            },
+        };
+
         return if (switch (@typeInfo(@TypeOf(val))) {
-            .Enum => val != .None,
-            .Int => val != 0,
+            Enum => val != .None,
+            Int => val != 0,
             else => unreachable,
         }) val else null;
     }
@@ -123,9 +124,10 @@ const Null = struct {
     pub fn overridden(
         self: Null,
         player: Player,
+        hit: u3,
         comptime field: Action.Field,
-    ) ?std.meta.FieldType(Action, field) {
-        _ = .{ self, player };
+    ) ReturnType(field) {
+        _ = .{ self, player, hit };
         return null;
     }
 
@@ -141,3 +143,11 @@ const Null = struct {
         _ = .{ self, player };
     }
 };
+
+fn ReturnType(comptime field: Action.Field) type {
+    return ?(switch (field) {
+        .damages => u8,
+        .critical_hits => Optional(bool),
+        else => std.meta.FieldType(Action, field),
+    });
+}