Shadow Era Wiki

Code Summary and Detailed Code

FILE REFERENCES IN THE GAME	TERMS TO LOCATE SHUFFLE REFERENCE
GameModel.cs: Contains the main logic for managing the deck and card operations, including shuffling: `public static void ShuffleDeck(int side)`, `public static void ShuffleDeck()`, `gameData.shuffledDeckThisTurn[side]++`. GameController.cs: Handles game events and triggers deck shuffling and state changes: `GameModel.ShuffleDeck()`, `GameModel.GameStateActivate(GameState.GameStateType.mulliganDraw)`. Gameplay.cs: Manages the flow of the game, including player interactions and calling shuffle methods: `GameModel.ShuffleDeck(1)`. GameState.cs: Defines game states and manages the logic for drawing and shuffling based on state transitions: `case GameStateType.draw:`, `case GameStateType.mulliganDraw:`.	Shuffle Deck GameState ShuffleDeck
SUMMARY OF THE SHUFFLE PROCESS:
`ShuffleDeck(int side)` : Handles the shuffling of the deck for the specified player side. `ShuffleDeck()` : Calls the shuffle method for the current player side. `gameData.shuffledDeckThisTurn[side]++` : Increments the shuffle counter for the current turn for the specified player side. `GameModel.ShuffleDeck()` : Called in the game controller to trigger the shuffle process. `GameModel.GameStateActivate(GameState.GameStateType.mulliganDraw)` : Changes the game state to allow for a mulligan, influencing when the shuffle occurs. `GameModel.ShuffleDeck(1)` : Executes the shuffle for player 1, ensuring that their deck is mixed before drawing. `case GameStateType.draw:` : Logic for handling the draw state, ensuring that the game responds appropriately after a shuffle. `case GameStateType.mulliganDraw:` : Logic for handling the mulligan draw state, ensuring that the shuffle occurs correctly.
DETAILED CODE
This code is a collection of all the functions involved in the shuffle mechanic, though it doesn't exist as a single block in any one file. The complete shuffle logic is primarily found in GameModel.cs.
// GameModel.cs public static void ShuffleDeck(int side) { // Logic for shuffling the deck for the specified player side Random.State state = Random.state; // Save the current random state Random.InitState(num); // Initialize random state with a seed int index = Random.Range(0, model.players[side].deck.Count); // Get a random index OnDeckShuffled(side); // Call deck shuffled event gameData.shuffledDeckThisTurn[side]++; // Increment the shuffle counter Random.state = state; // Restore the previous random state Debug.Log("Shuffled deck for side " + side + ", seed " + num); // Log shuffle info }   public static void ShuffleDeck() { ShuffleDeck(CurSide()); // Calls the shuffle method for the current player side }   // Additional functions related to deck manipulation public static void RemoveDeck(ShadowEraCard card) { // Logic for removing a card from the deck }   // GameController.cs GameModel.ShuffleDeck(); // Called to trigger the shuffle process GameModel.GameStateActivate(GameState.GameStateType.mulliganDraw); // Changes the game state for a mulligan   // Gameplay.cs GameModel.ShuffleDeck(1); // Executes the shuffle for player 1   // GameState.cs case GameStateType.draw: { // Logic for handling the draw state after a shuffle }   case GameStateType.mulliganDraw: { // Logic for handling the mulligan draw state, ensuring shuffle occurs correctly }

Mulligan

*Explanation of `case GameStateType.mulliganDraw:` In card games, a "mulligan" is a mechanism that allows players to redraw their initial cards before the game begins. This gives them the chance to improve their hand by exchanging unwanted cards or all cards in hand. `GameStateType` is an enumeration (enum) that defines different states of the game. Each state represents a specific moment or phase in the course of the game. `mulliganDraw` is one of these states, indicating that the player is in the mulligan phase, where they the game choose for the player to redraw certain cards. The logic within this case is responsible for managing the actions that need to occur when the game is in the mulligan state. This may include operations such as: Shuffling the deck: Before allowing the game to redraw, the game ensures that the deck is shuffled correctly to guarantee the randomness of the new cards. Modifying the state of cards: Ensuring that the cards being redrawn are handled correctly within the system. This does not include: Updating the user interface: Indicating to the player if they can declare "Mulligan" after the shuffle and allowing the selection of all or some cards to redraw.