Sec XI - Milestone Project 2 - War Game.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a Card War Game"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a Card War Game \n",
    "\n",
    "# Building the Logic of the Game - \n",
    "\n",
    "# Creating a Card\n",
    "# Creating a Deck or Pack of 52 cards\n",
    "# Shuffling the cards at random\n",
    "# Taking a card out of the Deck\n",
    "# Putting a card or group of cards into the deck\n",
    "# Playing with Computer or another Player\n",
    "\n",
    "from random import shuffle\n",
    "\n",
    "suit = ('Hearts', 'Diamonds', 'Spades', 'Clubs')\n",
    "\n",
    "ranks = ('Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Jack', 'Queen', 'King', 'Ace')\n",
    "\n",
    "values = {'Two':2, 'Three':3, 'Four':4, 'Five':5, 'Six':6, 'Seven':7, 'Eight':8, \n",
    "            'Nine':9, 'Ten':10, 'Jack':11, 'Queen':12, 'King':13, 'Ace':14}\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a Card - Choosing a card and Comparing it with another card\n",
    "\n",
    "class Card"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a Card - Choosing a card and comparing it with another card\n",
    "\n",
    "class Card:\n",
    "    \n",
    "    def __init__(self, suit, ranks):\n",
    "        \n",
    "        self.suit = suit\n",
    "        \n",
    "        self.ranks = ranks\n",
    "        \n",
    "        self.values = values[ranks]\n",
    "        \n",
    "    def __str__(self):\n",
    "        \n",
    "        return self.ranks + \" of \" + self.suit\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#eight_of_spades = Card('Spades','Eight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#type (eight_of_spades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#eight_of_spades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print (eight_of_spades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#eight_of_spades.suit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#eight_of_spades.ranks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#eight_of_spades.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#two_of_diamonds = Card('Diamonds','Two')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print (two_of_diamonds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#two_of_diamonds.values < eight_of_spades.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a Deck or Pack of 52 cards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a Deck or Pack of 52 cards\n",
    "# Print all the 52 cards\n",
    "# Using Shuffle method to shuffle the cards\n",
    "# using Pop method to take a card out from the deck\n",
    "\n",
    "class Deck():\n",
    "    \n",
    "    def __init__(self):\n",
    "        \n",
    "        # Creating variable for all cards. Here all cards are kept\n",
    "        self.all_cards = []\n",
    "        \n",
    "        # Using for loop to go through all suits and ranks , and creating a deck with suits and rank\n",
    "        for suits in suit:\n",
    "            for rank in ranks:\n",
    "                deck_created = Card(suits, rank)\n",
    "                \n",
    "                # Then append it all to self.all_cards\n",
    "                self.all_cards.append(deck_created)\n",
    "    \n",
    "    # Calling shuffle method to shuffle all cards - Calling shuffle method\n",
    "    def shuffle(self):\n",
    "        \n",
    "        shuffle(self.all_cards)\n",
    "        \n",
    "    # Now we need to take one card out of the deck - Calling pop method\n",
    "    def take_card_out(self):\n",
    "        \n",
    "        return self.all_cards.pop()\n",
    "        \n",
    "                \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_all_cards = Deck()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Deck at 0x1e532a5e550>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_all_cards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#type(check_all_cards.all_cards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#len(check_all_cards.all_cards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Before calling shuffle method - Calling the First card\n",
    "\n",
    "#check_all_cards.all_cards[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calling shuffle method\n",
    "\n",
    "#check_all_cards.shuffle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# After calling shuffle method - Calling the First card\n",
    "\n",
    "#print(check_all_cards.all_cards[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Printing all the 52 cards - All Shuffled\n",
    "\n",
    "#for cards in check_all_cards.all_cards:\n",
    "#    print (cards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ace of Clubs\n"
     ]
    }
   ],
   "source": [
    "# Calling pop method\n",
    "\n",
    "print(check_all_cards.all_cards.pop())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(check_all_cards.all_cards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a Player"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a Player\n",
    "# Adding card/s in the deck of a player\n",
    "# Removing card from the deck of a player\n",
    "\n",
    "class Player():\n",
    "    \n",
    "    # Giving a name to the Player and making a Card Deck\n",
    "    def __init__(self, name):\n",
    "        \n",
    "        self.name = name\n",
    "        self.all_cards = []\n",
    "              \n",
    "    \n",
    "    # Adding  Single card or Multiple Cards in the Deck using Extend method\n",
    "    def add_cards(self,new_cards):\n",
    "            \n",
    "        return self.all_cards.extend(new_cards)\n",
    "            \n",
    "            \n",
    "    # Taking a card out from all_cards from above using Pop method    \n",
    "    def take_a_card(self):\n",
    "        \n",
    "        return self.all_cards.pop(0) \n",
    "    \n",
    "    \n",
    "    def __str__(self):\n",
    "        \n",
    "        return f\"Player {self.name} has {len(self.all_cards)} cards\"\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_player = Player('Debasis')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print (new_player)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "#two_of_diamonds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding a Single Card \n",
    "\n",
    "#new_player.add_cards([two_of_diamonds])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print (new_player)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding Multiple Cards\n",
    "\n",
    "#new_player.add_cards([two_of_diamonds, two_of_diamonds,two_of_diamonds, two_of_diamonds])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print (new_player)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Popping a Card \n",
    "\n",
    "#new_player.all_cards.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print (new_player)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "#new_player.take_a_card()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Player Debasis has 0 cards\n"
     ]
    }
   ],
   "source": [
    "print (new_player)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building Logic of the Game"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PART I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating Two Players \n",
    "player_1 = Player(\"One\")     # From Player Class\n",
    "player_2 = Player(\"Two\")\n",
    "\n",
    "# Creating a new Deck\n",
    "new_deck = Deck()            # From Deck Class\n",
    "\n",
    "# Shuffling the Deck\n",
    "new_deck.shuffle()\n",
    "\n",
    "# Dividing the deck into two players. The deck has 52 cards so each player will get 26 cards\n",
    "\n",
    "player_1 = check_all_cards.all_cards[0::2]   # Taken from Deck Class\n",
    "player_2 = check_all_cards.all_cards[1::2]   # Using Slicing Method\n",
    "\n",
    "# Setting Game on to be True - Starting the Game\n",
    "\n",
    "game_on = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(player_1[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(player_2[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26\n"
     ]
    }
   ],
   "source": [
    "print (len(player_1))\n",
    "\n",
    "#for cards in player_1:\n",
    "#    print (cards)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26\n"
     ]
    }
   ],
   "source": [
    "print (len(player_2))\n",
    "\n",
    "#for cards in player_2:\n",
    "#    print(cards)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PART II"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Round 1\n",
      "Round 2\n",
      "Round 3\n",
      "Round 4\n",
      "Round 5\n",
      "Round 6\n",
      "Round 7\n",
      "At War!\n",
      "Round 8\n",
      "Round 9\n",
      "Round 10\n",
      "Round 11\n",
      "Round 12\n",
      "Round 13\n",
      "Round 14\n",
      "Round 15\n",
      "Round 16\n",
      "Round 17\n",
      "Round 18\n",
      "Round 19\n",
      "Round 20\n",
      "Round 21\n",
      "Round 22\n",
      "Round 23\n",
      "Round 24\n",
      "Round 25\n",
      "Round 26\n",
      "Round 27\n",
      "Round 28\n",
      "Round 29\n",
      "Round 30\n",
      "Round 31\n",
      "Round 32\n",
      "Round 33\n",
      "Round 34\n",
      "Round 35\n",
      "At War!\n",
      "Round 36\n",
      "Round 37\n",
      "Player 1 looses. Player 2 wins\n"
     ]
    }
   ],
   "source": [
    "# Playing the Game\n",
    "\n",
    "# Set Up How many Rounds have been Played\n",
    "playing_rounds = 0\n",
    "\n",
    "\n",
    "while game_on:\n",
    "    \n",
    "    # How many Rounds have been played will be added to playing_rounds\n",
    "    playing_rounds += 1\n",
    "    print (f\"Round {playing_rounds}\")\n",
    "    \n",
    "    if len(player_1) == 0:\n",
    "        print (\"Player 1 looses. Player 2 wins\")\n",
    "        game_on = False\n",
    "        break\n",
    "        \n",
    "    if len(player_2) == 0:\n",
    "        print (\"Player 2 looses. Player 1 wins\")\n",
    "        game_on = False\n",
    "        break\n",
    "        \n",
    "\n",
    "    # ELse Game is still on\n",
    "        \n",
    "    # Playing another Round\n",
    "    \n",
    "    # Creating an empty list and appending the cards from player_1's deck to the list. \n",
    "    # This is the list player_1 will be playing on the table\n",
    "    \n",
    "    player_1_cards = []\n",
    "    player_1_cards.append(player_1.pop())\n",
    "    \n",
    "    player_2_cards = []\n",
    "    player_2_cards.append(player_2.pop())\n",
    "    \n",
    "    \n",
    "    # While at war\n",
    "    # Here we will check how the game works - \n",
    "    # Stage I - Card value of Player 1 > card Value of Player 2\n",
    "    # Stage II - Card value of Player 1 < card Value of Player 2 \n",
    "    # Stage III - Card value of Player 1 == card Value of Player 2\n",
    "\n",
    "    \n",
    "    at_war = True\n",
    "    \n",
    "    while at_war:\n",
    "        \n",
    "        # Stage I - Card value of Player 1 > card Value of Player 2\n",
    "        if player_1_cards[-1].values > player_2_cards[-1].values:\n",
    "            \n",
    "            player_1.extend(player_1_cards)\n",
    "            player_1.extend(player_2_cards)\n",
    "            \n",
    "            \n",
    "            at_war = False\n",
    "            \n",
    "                \n",
    "        # Stage II - Card value of Player 1 < card Value of Player 2         \n",
    "        elif player_1_cards[-1].values < player_2_cards[-1].values:\n",
    "            \n",
    "            player_2.extend(player_1_cards)   \n",
    "            player_2.extend(player_2_cards)\n",
    "            \n",
    "            \n",
    "            at_war = False \n",
    "        \n",
    "        \n",
    "       # Stage III - Card value of Player 1 == card Value of Player 2 \n",
    "        else:\n",
    "            print(\"At War!\")\n",
    "            \n",
    "            if len(player_1) < 5:\n",
    "                print(\"Player One unable to play war! Game Over at War\")\n",
    "                print(\"Player Two Wins! Player One Loses!\")\n",
    "                game_on = False\n",
    "                break\n",
    "\n",
    "            elif len(player_2) < 5:\n",
    "                print(\"Player Two unable to play war! Game Over at War\")\n",
    "                print(\"Player One Wins! Player One Loses!\")\n",
    "                game_on = False\n",
    "                break\n",
    "            # Otherwise, we're still at war, so we'll add the next cards\n",
    "            else:\n",
    "                for num in range(5):\n",
    "                    player_1_cards.append(player_1.pop())\n",
    "                    player_2_cards.append(player_2.pop())\n",
    "\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}