@masonf539/egyptian-war 1.0.1-beta.3 → 1.0.1-beta.4

package/README.md

@@ -54,8 +54,9 @@ descending rank sequence, including Ace-low and Ace-high sequences. The
 an Ace counts as one. An active player who false-slaps forfeits the configured
 number of cards, up to the number they hold. A false slap by an eliminated
 player, or one that forfeits a player's last card, prevents another slap on the
-unchanged pile. The cooldown clears when the next card is played, allowing that
-new card to be slapped and the eliminated player to re-enter immediately.
+unchanged pile. A newly eliminated player may try once on the next played card.
+If an eliminated player false-slaps, they must skip the next two played cards
+and may try again when the third card is placed.
 Invalid reentry attempts use the same visible one-hand slap animation as other
 false slaps; additional attempts during the cooldown do not create extra hands.
 

package/dist/definition.js

@@ -5,7 +5,7 @@ const game_sdk_1 = require("@masonf539/game-sdk");
 exports.egyptianWar = {
     id: "egyptian-war",
     name: "Egyptian War",
-    description: "Play cards into a central pile, survive face-card challenges, and race to slap enabled patterns. False slaps carry penalties, and eliminated players must wait for another card before slapping again. The last player holding all the cards wins.",
+    description: "Play cards into a central pile, survive face-card challenges, and race to slap enabled patterns. False slaps carry penalties, including a two-card wait for eliminated players. The last player holding all the cards wins.",
     isPlayable: true,
     chatEnabled: true,
     minPlayers: 2,
@@ -39,10 +39,10 @@ exports.egyptianWar = {
         "If the challenged player uses every attempt without revealing a face card, Ace, or Joker, the player who most recently played a challenge card wins the pile unless the final card creates a valid slap combination.",
         "When the final failed challenge card creates a valid slap combination, players get a short window of about four seconds to slap; if nobody slaps, the most recent challenge card player wins the pile.",
         "If the challenged player runs out of cards before completing their attempts, the next player with cards inherits the challenge with the remaining attempts.",
-        "A player who runs out of cards is skipped until they reenter by winning a valid slap. An eliminated player who false-slaps cannot slap the unchanged pile again, but may slap as soon as the next card is played.",
+        "A player who runs out of cards is skipped until they reenter by winning a valid slap. They may try once on the next played card. If an eliminated player false-slaps, they skip the next two played cards and may try again on the third.",
         "A player who wins the pile places all of its cards at the bottom of their deck without shuffling and begins the next pile.",
         "When a valid slap combination appears, the first player to slap wins the central pile.",
-        "Slapping without a valid combination forfeits the configured number of cards face down to the bottom of the pile, or all remaining cards if fewer remain. Penalty cards do not create slap combinations. A player with no cards forfeits no cards for a false slap and must wait for another card before trying again.",
+        "Slapping without a valid combination forfeits the configured number of cards face down to the bottom of the pile, or all remaining cards if fewer remain. Penalty cards do not create slap combinations. A player with no cards forfeits no cards for a false slap, skips the next two played cards, and may try again on the third.",
         "When only one player still has cards, that player wins unless the current face-up pile has a valid slap that allows an eliminated player to reenter.",
         "If several players slap at nearly the same moment, the pile goes to one of them by weighted chance that favors the earlier slap. The others forfeit nothing.",
         "The winner is the player who collects every card."
@@ -103,7 +103,7 @@ exports.egyptianWar = {
             type: "number",
             key: "falseSlapPenaltyCards",
             label: "False Slap Penalty",
-            description: "Cards forfeited to the bottom of the pile for an invalid slap. An eliminated player forfeits no cards and must wait for another card before slapping again.",
+            description: "Cards forfeited to the bottom of the pile for an invalid slap. An eliminated player forfeits no cards, skips the next two played cards, and may slap again on the third.",
             defaultValue: 2,
             options: [1, 2, 3],
             unit: "card"
@@ -124,7 +124,7 @@ exports.egyptianWar = {
 };
 exports.egyptianWarManifest = {
     apiVersion: game_sdk_1.gameHubGameApiVersion,
-    packageVersion: "1.0.1-beta.3",
+    packageVersion: "1.0.1-beta.4",
     definition: exports.egyptianWar,
     client: {
         delivery: "embedded",

package/dist/engine.d.ts

@@ -81,12 +81,21 @@ export type EgyptianWarDeparture = "removed" | "left";
 export declare function removeEgyptianWarPlayer(state: EgyptianWarState, playerId: string, departure?: EgyptianWarDeparture): string;
 export declare function isEgyptianWarPileSlappable(pile: readonly Card[], settings: EgyptianWarSettings): boolean;
 export declare function isEgyptianWarStateSlappable(state: Pick<EgyptianWarState, "pile" | "penaltyPileCardCount" | "settings">): boolean;
-export type EgyptianWarSlapCooldownStatus = "none" | "waiting";
-/** Prevent another slap until one more card has been played. */
-export declare function startEgyptianWarSlapCooldown(state: EgyptianWarState, playerId: string): void;
+export type EgyptianWarSlapCooldownStatus = {
+    status: "none";
+} | {
+    status: "waiting";
+    cardPlacementsRemaining: number;
+};
+/**
+ * Prevent another slap until the requested future card opportunity. An offset
+ * of 1 allows the next played card; an offset of 3 skips two cards and allows
+ * the third.
+ */
+export declare function startEgyptianWarSlapCooldown(state: EgyptianWarState, playerId: string, nextEligibleCardOffset?: number): void;
 /**
- * Returns the status of a player's slap cooldown. Once another card has been
- * played, the cooldown clears and that new card may be slapped.
+ * Returns the status of a player's slap cooldown, including the number of card
+ * placements remaining before another attempt is allowed.
  */
 export declare function checkEgyptianWarSlapCooldown(state: EgyptianWarState, playerId: string): EgyptianWarSlapCooldownStatus;
 export declare function applyEgyptianWarAction(state: EgyptianWarState, playerId: string, action: EgyptianWarAction): string;

package/dist/engine.js

@@ -471,27 +471,36 @@ function trackPileVersion(state, run) {
         }
     }
 }
-/** Prevent another slap until one more card has been played. */
-function startEgyptianWarSlapCooldown(state, playerId) {
+/**
+ * Prevent another slap until the requested future card opportunity. An offset
+ * of 1 allows the next played card; an offset of 3 skips two cards and allows
+ * the third.
+ */
+function startEgyptianWarSlapCooldown(state, playerId, nextEligibleCardOffset = 1) {
     const player = state.players.find((candidate) => candidate.id === playerId);
     if (!player)
         return;
-    player.slapCooldownUntilCardPlayCount = (state.cardsPlayedCount ?? 0) + 1;
+    player.slapCooldownUntilCardPlayCount =
+        (state.cardsPlayedCount ?? 0) + nextEligibleCardOffset;
 }
 /**
- * Returns the status of a player's slap cooldown. Once another card has been
- * played, the cooldown clears and that new card may be slapped.
+ * Returns the status of a player's slap cooldown, including the number of card
+ * placements remaining before another attempt is allowed.
  */
 function checkEgyptianWarSlapCooldown(state, playerId) {
     const player = state.players.find((candidate) => candidate.id === playerId);
     const cooldownTarget = player?.slapCooldownUntilCardPlayCount;
     if (!player || cooldownTarget == null)
-        return "none";
+        return { status: "none" };
     const cardsPlayedCount = state.cardsPlayedCount ?? 0;
-    if (cardsPlayedCount < cooldownTarget)
-        return "waiting";
+    if (cardsPlayedCount < cooldownTarget) {
+        return {
+            status: "waiting",
+            cardPlacementsRemaining: cooldownTarget - cardsPlayedCount
+        };
+    }
     player.slapCooldownUntilCardPlayCount = null;
-    return "none";
+    return { status: "none" };
 }
 function applyEgyptianWarAction(state, playerId, action) {
     return trackPileVersion(state, () => applyAction(state, playerId, action));
@@ -510,8 +519,10 @@ function applyAction(state, playerId, action) {
     const player = state.players[playerIndex];
     if (action === "slap") {
         const slapCooldown = checkEgyptianWarSlapCooldown(state, playerId);
-        if (slapCooldown === "waiting") {
-            throw new EgyptianWarRuleError("You must wait until the next card is played before slapping again.");
+        if (slapCooldown.status === "waiting") {
+            const remaining = slapCooldown.cardPlacementsRemaining;
+            throw new EgyptianWarRuleError(`You must wait for ${remaining} more card ` +
+                `${remaining === 1 ? "placement" : "placements"} before slapping again.`);
         }
         const faceUpPile = state.pile.slice(state.penaltyPileCardCount);
         if (faceUpPile.length === 0) {
@@ -519,9 +530,9 @@ function applyAction(state, playerId, action) {
         }
         if (!isEgyptianWarPileSlappable(faceUpPile, state.settings)) {
             if (player.cards.length === 0) {
-                startEgyptianWarSlapCooldown(state, playerId);
+                startEgyptianWarSlapCooldown(state, playerId, 3);
                 state.activityMessage =
-                    `${player.name} slapped too early and must wait until the next card is played before slapping again.`;
+                    `${player.name} slapped too early while out and must sit out the next two cards.`;
                 return state.activityMessage;
             }
             const cardsForfeited = player.cards.splice(0, state.settings.falseSlapPenaltyCards);

package/dist/session.js

@@ -396,11 +396,15 @@ class EgyptianWarSession {
             return;
         }
         const isLiveSlap = action === "slap" && !isTurnTimeout && !isResolvedSlap;
-        if (isLiveSlap &&
-            (0, engine_js_1.checkEgyptianWarSlapCooldown)(this.state, memberId) === "waiting") {
+        const slapCooldown = isLiveSlap
+            ? (0, engine_js_1.checkEgyptianWarSlapCooldown)(this.state, memberId)
+            : { status: "none" };
+        if (slapCooldown.status === "waiting") {
+            const remaining = slapCooldown.cardPlacementsRemaining;
             respond({
                 success: false,
-                message: "You must wait until the next card is played before slapping again."
+                message: `You must wait for ${remaining} more card ` +
+                    `${remaining === 1 ? "placement" : "placements"} before slapping again.`
             });
             return;
         }

package/docs/design.md

@@ -60,7 +60,7 @@ Checked implementation items do not imply that every multiplayer interaction has
 - [x] Keep face-down false-slap penalty cards out of slap-pattern validation so repeated penalties cannot manufacture a valid slap.
 - [x] End the game when only one player has cards and the face-up pile offers no valid slap for an eliminated player to reenter.
 - [x] Never let a challenger answer their own challenge: when nobody but the challenger can continue, the challenger wins the pile (or the slap window opens).
-- [x] Prevent a player who false-slaps while out, or false-slaps away their last card, from repeatedly slapping the unchanged pile; clear that cooldown when the next card is played so they can immediately slap back in.
+- [x] Prevent a player who false-slaps away their last card from retrying the unchanged pile while allowing one attempt on the next played card. When an already eliminated player false-slaps, make them skip two played cards and allow another attempt on the third.
 - [x] Keep slap-pattern information off the wire: the public state carries a `pileVersion` but no slappable flag, and messages about a pending pile are neutral.
 - [x] Have slaps carry the `pileVersion` the player last saw. A slap that lost a short race with a card play (previous version, previous pile slappable, under 350 ms) is ignored without a penalty.
 - [x] Allow a player to leave voluntarily; their cards are held face-down and added to the next pile, just like a host removal. If removing a player leaves nobody holding cards, the remaining cards go to the next player in turn order immediately.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masonf539/egyptian-war",
-  "version": "1.0.1-beta.3",
+  "version": "1.0.1-beta.4",
   "description": "Egyptian War game plugin for GameHub.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/public/client.js

@@ -129,7 +129,7 @@ function renderEgyptianWarSlapRules(settings) {
 
   const eliminatedCooldownItem = document.createElement("li");
   eliminatedCooldownItem.textContent =
-    "Eliminated player false slap: wait for another card before slapping again.";
+    "False slap while out: skip two cards, then slap again on the third.";
   egyptianWarSlapRulesList.appendChild(eliminatedCooldownItem);
 }