blackjack-cli 0.3.1__tar.gz

blackjack_cli-0.3.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: blackjack-cli
+Version: 0.3.1
+Summary: This is a cli-based blackjack game! Woo!
+License: GPLv3
+Author: Vlek
+Author-email: derek@mccammond.org
+Requires-Python: >=3.10,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
+Requires-Dist: rich-click (>=1.6.1,<2.0.0)
+Description-Content-Type: text/markdown
+
+# Blackjack
+A node.js Blackjack library
+

blackjack_cli-0.3.1/README.md

@@ -0,0 +1,2 @@
+# Blackjack
+A node.js Blackjack library

blackjack_cli-0.3.1/pyproject.toml

@@ -0,0 +1,43 @@
+[tool.poetry]
+name = "blackjack-cli"
+version = "0.3.1"
+description = "This is a cli-based blackjack game! Woo!"
+authors = ["Vlek <derek@mccammond.org>"]
+license = "GPLv3"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+rich-click = "^1.6.1"
+pyyaml = "^6.0.1"
+
+[tool.poetry.group.dev.dependencies]
+black = "^24.4.2"
+pytest = "^8.2.2"
+coverage = "^7.3.1"
+pre-commit-hooks = "^4.4.0"
+
+[tool.poetry.scripts]
+blackjack = "blackjack_cli.console:bj"
+bj = "blackjack_cli.console:bj"
+hit = "blackjack_cli.console:hit"
+stand = "blackjack_cli.console:stand"
+stay = "blackjack_cli.console:stand"
+
+[tool.coverage.paths]
+source = ["src", "*/site-packages"]
+tests = ["tests", "*/tests"]
+
+[tool.coverage.run]
+parallel = true
+branch = true
+source = ["blackjack-cli"]
+omit = ["tests"]
+
+[tool.coverage.report]
+show_missing = false
+fail_under = 90
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

blackjack_cli-0.3.1/src/blackjack_cli/__init__.py

@@ -0,0 +1,2 @@
+from deck.card import Card
+from deck.deck import Deck

blackjack_cli-0.3.1/src/blackjack_cli/blackjack.py

@@ -0,0 +1,137 @@
+"""
+This is the base logic file for all of the Blackjack game code.
+
+This is going to house things like:
+    - What is a deck?
+    - What is a player/dealer?
+    - Turn order
+"""
+
+from enum import Enum
+from typing_extensions import Self
+
+from deck import Deck, Card, CardHand
+
+
+def blackjackScoringStrategy(cards: list[Card]) -> int:
+    """Returns the score of a given list of cards."""
+
+    # We do a shallow copy so that we do not mess up the order.
+    cards = cards.copy()
+
+    def aceLastSorting(key: Card) -> int:
+        """Puts aces last in a list of cards when sorting."""
+        if key.value == Card.Value.ACE:
+            return 1
+        return 0
+
+    cards.sort(key=aceLastSorting)
+
+    result: int = 0
+
+    for card in cards:
+        if isinstance(card.value.value, int):
+            value: int = card.value.value
+        elif card.value == Card.Value.ACE:
+            if result + 11 > 21:
+                value = 1
+            else:
+                value = 11
+        else:
+            value = 10
+
+        result += value
+    return result
+
+
+class GameState(Enum):
+    Playing = "playing"
+    Win = "wins"
+    Lose = "losses"
+    Blackjack = "blackjacks"
+    Push = "pushes"
+
+
+class Blackjack:
+    def __init__(self) -> None:
+        self.gameState: GameState = GameState.Playing
+
+        # Standard blackjack is played with 4 decks
+        # instead of just one.
+        self.deck: Deck = Deck() * 4
+        self.deck.shuffle()
+
+        self.playersCards: CardHand = CardHand([self.deck.draw(), self.deck.draw()])
+        self.dealersCards: CardHand = CardHand([self.deck.draw(), self.deck.draw()])
+
+        for hand in [self.playersCards, self.dealersCards]:
+            hand.setScoringStrategy(blackjackScoringStrategy)
+
+        playersScore: int = self.playersCards.getScore()
+        dealersScore: int = self.dealersCards.getScore()
+
+        # If one or both blackjack:
+        if playersScore == 21:
+            self.gameState = GameState.Blackjack
+
+            if dealersScore == 21:
+                self.gameState = GameState.Push
+
+    def hit(self) -> GameState:
+        if self.isGameOver():
+            return self.gameState
+
+        self._drawCard(self.playersCards)
+
+        newScore: int = self.playersCards.getScore()
+
+        if newScore > 21:
+            self.gameState = GameState.Lose
+        elif newScore == 21:
+            self.gameState = GameState.Win
+
+        return self.gameState
+
+    def stand(self) -> GameState:
+        if not self.isGameOver():
+            self.performDealersTurn()
+
+        return self.gameState
+
+    def performDealersTurn(self) -> Self:
+        """Performs the dealer's moves and finishes the game."""
+        playersScore: int = self.playersCards.getScore()
+        dealersScore: int = self.dealersCards.getScore()
+
+        # If the player bust or the dealer got blackjack
+        if playersScore > 21 or dealersScore == 21:
+            self.gameState = GameState.Lose
+            return self
+
+        while (dealersScore := self.dealersCards.getScore()) <= 16:
+            self._drawCard(self.dealersCards)
+
+        dealersScore = self.dealersCards.getScore()
+
+        if playersScore > dealersScore or dealersScore > 21:
+            self.gameState = GameState.Win
+        else:
+            if playersScore == dealersScore:
+                self.gameState = GameState.Push
+            else:
+                self.gameState = GameState.Lose
+
+        return self
+
+    def _drawCard(self, hand: CardHand) -> Card | None:
+        """Draws a card and places it into the given hand."""
+        newCard: Card | None = self.deck.draw()
+
+        if newCard is not None:
+            hand.add(newCard)
+
+        return newCard
+
+    def isGameOver(self) -> bool:
+        """Returns whether the game is already over."""
+        return self.gameState != GameState.Playing

blackjack_cli-0.3.1/src/blackjack_cli/config.py

@@ -0,0 +1,54 @@
+"""
+Configuration manager
+
+We need to be able to save configurations to a file in a user-friendly
+way that will be retrievable later.
+
+If people wish to then save these settings and use them across different
+PCs, they should have that option.
+"""
+
+from pathlib import Path
+from click import get_app_dir
+
+import yaml
+
+
+DEFAULT_CONFIG_FOLDER: str = get_app_dir("blackjack")
+DEFAULT_CONFIG_FILE_NAME: str = "blackjack.yaml"
+
+
+class Config:
+    def __init__(
+        self,
+        config_file_path: str = f"{DEFAULT_CONFIG_FOLDER}/{DEFAULT_CONFIG_FILE_NAME}",
+    ) -> None:
+        self._load(config_file_path)
+
+    def _load(self, config_file_path: str) -> None:
+        self.config_file_path: Path = Path(config_file_path).expanduser()
+
+        self.config_folder_path: Path = self.config_file_path.parent
+
+        if not self.config_folder_path.exists():
+            self.config_folder_path.mkdir()
+
+        if self.config_file_path.exists():
+            with self.config_file_path.open() as config_file:
+                self.config: dict[str, object] = yaml.safe_load(config_file)
+        else:
+            self.config: dict[str, object] = {}
+
+    def write(self) -> None:
+        """Writes the configuration to the config file."""
+
+        with open(self.config_file_path, "w") as config_file:
+            config_file.write(yaml.dump(self.config))
+
+    def fileExists(self, filename: str) -> Path | None:
+        """Returns whether the given file name exists in the config folder."""
+        potentialFile: Path = self.config_file_path / filename
+
+        if potentialFile.exists():
+            return potentialFile
+        return

blackjack_cli-0.3.1/src/blackjack_cli/console.py

@@ -0,0 +1,213 @@
+"""
+Entryway into the project for console-based usage.
+"""
+
+import rich_click as click
+import pickle
+from pathlib import Path
+from random import choice
+
+from blackjack_cli.blackjack import Blackjack, GameState
+from blackjack_cli.config import Config
+from blackjack_cli.stats import Stats
+
+from deck import CardHand
+
+
+config = Config()
+
+STATS_FILE_PATH: Path = config.config_folder_path / "stats.json"
+STATE_FILE_PATH: Path = config.config_folder_path / "gamestate.pickle"
+
+playerStats = Stats(STATS_FILE_PATH)
+
+isNewGame: bool = not STATE_FILE_PATH.exists()
+
+if isNewGame:
+    game_instance = Blackjack()
+else:
+    with open(STATE_FILE_PATH, "rb") as sf:
+        game_instance: Blackjack = pickle.load(sf)
+
+
+@click.group()
+def bj() -> None:
+    """Blackjack CLI"""
+    ...
+
+
+@bj.command()
+def hit() -> None:
+    """Starts new game or asks dealer for another card."""
+    gameState: GameState = game_instance.gameState
+
+    if not isNewGame:
+        gameState = game_instance.hit()
+
+    if gameState != GameState.Playing:
+        __print_end_of_game(game_instance)
+        playerStats.save(STATS_FILE_PATH, game_instance.gameState)
+        STATE_FILE_PATH.unlink(missing_ok=True)
+    else:
+        click.echo(
+            f"{__get_hands_string(game_instance.playersCards, game_instance.dealersCards, True)} Hit or Stand?"
+        )
+        __save_state(STATE_FILE_PATH, game_instance)
+
+
+@bj.command()
+def stand() -> None:
+    """Performs the dealer's turn and ends the game."""
+    if isNewGame:
+        click.echo("Type 'hit' to start a new game.")
+        return
+
+    game_instance.stand()
+
+    __print_end_of_game(game_instance)
+    playerStats.save(STATS_FILE_PATH, game_instance.gameState)
+
+    STATE_FILE_PATH.unlink(missing_ok=True)
+
+
+@bj.command()
+def stats() -> None:
+    """Lists the player's game statistics."""
+    click.echo("Player stats:")
+
+    click.echo(playerStats.data)
+
+
+def __save_state(filepath: Path, gameData: Blackjack) -> None:
+    with open(filepath, "wb") as stateFile:
+        stateFile.write(pickle.dumps(gameData))
+
+
+def __print_end_of_game(game: Blackjack) -> None:
+    result_text: str = "You lose"
+
+    match game.gameState:
+        case GameState.Win:
+            result_text = "You win"
+        case GameState.Blackjack:
+            result_text = "Blackjack"
+        case GameState.Push:
+            result_text = "Push"
+
+    previousGameState: GameState = playerStats.data._last_outcome
+    currentStreak: int = playerStats.data._current_streak
+
+    sass: str = __get_sass(
+        game.gameState,
+        previousGameState,
+        currentStreak,
+    )
+
+    click.echo(
+        f"{__get_hands_string(game.playersCards, game.dealersCards, False)} {result_text}! {sass}"
+    )
+
+
+def __get_hands_string(
+    playerHand: CardHand, dealerHand: CardHand, hideDealersSecondCard: bool
+) -> str:
+    """Returns the formatted string for player and dealer."""
+    if hideDealersSecondCard:
+        dealersCards: str = " ".join([str(dealerHand.cards[0]), "?"])
+        dealersScore: str = "?"
+    else:
+        dealersCards = str(dealerHand)
+        dealersScore = __get_score_string(dealerHand)
+
+    return f"Player: {playerHand} ({playerHand.getScore()}). House: {dealersCards} ({dealersScore})."
+
+
+def __get_score_string(hand: CardHand) -> str:
+    """Returns either Blackjack or the score of a hand."""
+    handScore = hand.getScore()
+
+    if handScore == 21 and len(hand.cards) == 2:
+        scoreOutput: str = "Blackjack"
+    else:
+        scoreOutput = str(handScore)
+
+    return scoreOutput
+
+
+def __get_sass(
+    gameState: GameState, lastGameOutcome: GameState, currentStreak: int
+) -> str:
+    """Given game state, returns some flavor text to add to the end of game."""
+    responseBank: list[str]
+
+    loseResponseBank: list[str] = [
+        "Play again?",
+        "The house always wins!",
+        "Maybe next time.",
+        "💩",
+        "Tough luck.",
+        "Womp womp",
+        "You can turn it around next time.",
+    ]
+
+    winResponseBank: list[str] = [
+        "Another win?",
+        "Next time you'll lose! >:C",
+        "I will shuffle better next time. :..<.",
+        "🎆",
+        "🎉",
+        "🔥",
+    ]
+
+    pushResponseBank: list[str] = [
+        "Draw!",
+        "Alright, we will call it a draw.",
+        "Maybe you'll win next time?",
+        "Give it another shot.",
+        "Maybe next time.",
+    ]
+
+    # This is before the streak is incremented in the stats, so what is saved
+    # is our previous streak. Need to increment to include current win/lose
+    currentStreak += 1
+
+    # If a streak continues
+    if gameState == lastGameOutcome:
+        # Winning streak continues
+        if gameState in [GameState.Win, GameState.Blackjack]:
+            responseBank = [
+                f"Continuing the winning streak to {currentStreak}!",
+                f"{currentStreak} times a winner!",
+                f"Will you lose after winning {currentStreak} times?",
+            ] + winResponseBank
+        elif gameState == GameState.Push:
+            responseBank = [
+                f"{currentStreak} pushes? That's rare.",
+            ] + pushResponseBank
+        # Losing streak continues.
+        # Here's where the real sass is!
+        else:
+            responseBank = [
+                f"You increase your losing streak to {currentStreak}!",
+                f"{currentStreak} losses. Maybe you'll win next time?",
+            ] + loseResponseBank
+
+    # A losing streak was broken
+    elif gameState in [GameState.Win, GameState.Blackjack]:
+        responseBank = [
+            "You broke your losing streak!",
+            f"Losing streak of {currentStreak} broken!",
+            "Now to turn this into a winning streak!",
+        ] + winResponseBank
+
+    elif gameState == GameState.Push:
+        responseBank = pushResponseBank
+
+    # A winning streak was broken
+    else:
+        responseBank = [
+            "Wining streak broken!",
+            "Will this lead to a losing streak?",
+        ] + loseResponseBank
+
+    return choice(responseBank)

blackjack_cli-0.3.1/src/blackjack_cli/models/__init__.py

@@ -0,0 +1,3 @@
+from blackjack_cli.models.stats_model import BlackjackStats
+
+__all__ = ["BlackjackStats"]

blackjack_cli-0.3.1/src/blackjack_cli/models/stats_model.py

@@ -0,0 +1,60 @@
+from typing import Any
+from blackjack_cli.blackjack import GameState
+from typing_extensions import Self
+
+
+class BlackjackStats:
+    _wins: int = 0
+    _losses: int = 0
+    _pushes: int = 0
+    _blackjacks: int = 0
+    _longest_win_streak: int = 0
+    _longested_losing_streak: int = 0
+    _longest_push_streak: int = 0
+    _current_streak: int = 0
+    _last_outcome: GameState = GameState.Playing
+    _last_played: str = ""
+
+    def __init__(self) -> None:
+        """Initializes a BlackjackStats object."""
+
+    def deserialize(self, data: dict[str, Any]) -> Self:
+        """Imports a json string, updates class variables."""
+
+        if "_last_outcome" in data:
+            data["_last_outcome"] = GameState(data["_last_outcome"])
+
+        self.__dict__ = data
+
+        return self
+
+    def serialize(self) -> dict[str, Any]:
+        """Exports class data as a saveable dict"""
+
+        result: dict[str, Any] = self.__dict__
+        result["_last_outcome"] = self._last_outcome.value
+
+        return result
+
+    def __str__(self) -> str:
+        """Returns a string representation of the stats values"""
+        result: list[str] = []
+        values: dict[str, Any] = self.__dict__
+
+        keysToOutput: dict[str, str] = {
+            "_wins": "Wins",
+            "_losses": "Losses",
+            "_pushes": "Pushes",
+            "_blackjacks": "Blackjacks",
+            "_longest_win_streak": "Longest winning streak",
+            "_longested_losing_streak": "Longest losing streak",
+            "_longest_push_streak": "Longest push streak",
+            "_current_streak": "Current streak",
+            "_last_played": "Last played",
+        }
+
+        for key, value in keysToOutput.items():
+            if key in values:
+                result.append(f"{value}: {values[key]}")
+
+        return "  " + "\n  ".join(result)

blackjack_cli-0.3.1/src/blackjack_cli/stats.py

@@ -0,0 +1,64 @@
+from pathlib import Path
+import json
+from datetime import date
+
+from blackjack_cli.blackjack import GameState
+from blackjack_cli.models import BlackjackStats
+
+
+class Stats:
+    def __init__(self, statsFilePath: Path) -> None:
+        """Initializes a stats collection object."""
+
+        self.data: BlackjackStats = BlackjackStats()
+
+        if statsFilePath.exists():
+            with open(statsFilePath, "r") as statsFile:
+                self.data.deserialize(json.load(statsFile))
+
+    def save(self, statsFilePath: Path, gameState: GameState) -> None:
+        """Saves the last game's state to the stats file."""
+        self.data._last_played = str(date.today())
+
+        match gameState:
+            case winType if winType in [GameState.Win, GameState.Blackjack]:
+                if winType == GameState.Win:
+                    self.data._wins += 1
+                else:
+                    self.data._blackjacks += 1
+
+                if self.data._last_outcome in [GameState.Win, GameState.Blackjack]:
+                    self.data._current_streak += 1
+
+                    if self.data._longest_win_streak < self.data._current_streak:
+                        self.data._longest_win_streak = self.data._current_streak
+                else:
+                    self.data._current_streak = 1
+
+            case GameState.Lose:
+                self.data._losses += 1
+
+                if self.data._last_outcome == GameState.Lose:
+                    self.data._current_streak += 1
+
+                    if self.data._longested_losing_streak < self.data._current_streak:
+                        self.data._longested_losing_streak = self.data._current_streak
+                else:
+                    self.data._current_streak = 1
+
+            case GameState.Push:
+                self.data._pushes += 1
+                self.data._current_streak = 0
+
+                if self.data._last_outcome == GameState.Push:
+                    self.data._current_streak += 1
+
+                    if self.data._longest_push_streak < self.data._current_streak:
+                        self.data._longest_push_streak = self.data._current_streak
+                else:
+                    self.data._current_streak = 1
+
+        self.data._last_outcome = gameState
+
+        with open(statsFilePath, "w") as statsFile:
+            json.dump(self.data.serialize(), statsFile)