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

package/README.md

@@ -52,10 +52,11 @@ Slap patterns are validated by the server and configured in the lobby. The
 descending rank sequence, including Ace-low and Ace-high sequences. The
 "Tens" pattern checks only two directly adjacent number cards that total ten;
 an Ace counts as one. An active player who false-slaps forfeits the configured
-number of cards, up to the number they hold. An eliminated player has no cards
-to forfeit, so a false slap prevents them from slapping the unchanged pile
-again. The cooldown clears when the next card is played, allowing that card to
-be slapped and the eliminated player to re-enter immediately.
+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. 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.2",
+    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 repeated free slaps 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 an eliminated 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 repeated free slaps 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 an eliminated 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);
@@ -529,6 +540,7 @@ function applyAction(state, playerId, action) {
             state.penaltyPileCardCount += cardsForfeited.length;
             if (player.cards.length === 0) {
                 player.isEliminated = true;
+                startEgyptianWarSlapCooldown(state, playerId);
                 if (endIfOnePlayerOwnsRemainingCards(state)) {
                     return state.activityMessage;
                 }

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 an eliminated player who false-slaps 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.
@@ -121,6 +121,6 @@ Checked implementation items do not imply that every multiplayer interaction has
 - [x] Give the CSS table a layered casino-felt, wooden-rail, depth, and drop-shadow treatment while retaining its original oval shape.
 - [x] Draw cards as accessible HTML/CSS playing-card faces; do not depend on external card image assets.
 - [x] Render mirrored card corners, distinct face-card styling, and a Joker with vertical JOKER labels and a decorative center that is distinguishable from a Jack.
-- [x] Render slap hands with the original splayed-hand emoji on desktop and a clearer raised-palm variant on coarse-pointer/mobile devices, scale them and their stopping distance with the rendered card size, keep their shadows visually below the hand at every seat rotation, and layer later collected attempts above the official winner.
+- [x] Render slap hands with the splayed-hand emoji on desktop and the backhand emoji on coarse-pointer/mobile devices, scale them and their stopping distance with the rendered card size, keep their shadows visually below the hand at every seat rotation, and layer later collected attempts above the official winner.
 - [x] Keep the table, player seats, card motion, spectator area, and controls usable on narrow screens and with reduced-motion preferences.
 - Offer chat per game rather than requiring it in every game; games that rely on secrecy or fast rounds can opt out, while social multiplayer games can enable it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masonf539/egyptian-war",
-  "version": "1.0.1-beta.2",
+  "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

@@ -86,11 +86,11 @@ function createEgyptianWarSlapHand() {
 
   const desktopHand = document.createElement("span");
   desktopHand.className = "egyptian-war-slap-hand-desktop";
-  desktopHand.textContent = "💐️";
+  desktopHand.textContent = "\u{1F590}\uFE0F";
 
   const mobileHand = document.createElement("span");
   mobileHand.className = "egyptian-war-slap-hand-mobile";
-  mobileHand.textContent = "✋";
+  mobileHand.textContent = "\u{1F91A}";
 
   handGlyph.append(desktopHand, mobileHand);
   return handGlyph;
@@ -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);
 }