Welcome, guest | Sign In | My Account | Store | Cart

Part of the War Game set, this version of War Game further advanced the program in an environment without curses. Showing another iteration of development, the recipe here program for more fun with a virtual card game and ASCII graphic card representations while playing.

Python, 165 lines
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
from random import randint, seed
from time import time
# region: change
# from window import *
from Zpaw import *
from cards import *
card_list = [card_0, card_1, card_2, card_3, card_4, card_5, card_6, card_7, card_8, card_9]
# endregion

def game():
    print 'Welcome to WAR V5!'
    print
    asking = True
    while asking:
        try:
            players = int(raw_input('How many players are there? '))
            if players < 2:
                print 'There must be at least two players.'
            else:
                asking = False
        except:
            print 'You must enter a number.'
    print
    names = []
    # region: change
    longest_name = 0
    for name in range(players):
        names.append(raw_input('What is the name of player ' + str(name + 1) + '? '))
        if len(names[-1]) > longest_name:
            longest_name = len(names[-1])
    # endregion
    deck = []
    for card in range(10):
        for player in range(players):
            deck.append(card)
    hands = []
    seed(time())
    for player in range(players):
        hand = ([], [])
        for card in range(10):
            index = randint(0, len(deck) - 1)
            hand[0].append(deck[index])
            del deck[index]
        hand[0].sort()
        hands.append(hand)
    for round in range(1, 11):
        table = []
        will_play = []
        high_card = 0
        for player in range(players):
            will_play.append(player)
        for turn in range(players):
            for line in range(50):
                print
            index = randint(0, len(will_play) - 1)
            now_play = will_play[index]
            del will_play[index]
            print 'Round', round
            raw_input('It is ' + names[now_play] + "'s turn to play.")
            print
            # region: change
            if len(table) == 0:
                print 'There are no cards on the table.\n'
            else:
                table_window = window(len(table) * 6, longest_name + 13)
                for card in range(len(table)):
                    # name_page = page(1, len(names[table[card][0]]) + 9)
                    # name_page.mutate(0, 0, names[table[card][0]] + ' played')
                    # table_window.append(name_page, [card * 6, 0])
                    # table_window.append(card_list[table[card][1]], [card * 6, len(names[table[card][0]]) + 8])
                    # table_window += struct(True, card * 6, 0, name_page)
                    # table_window += struct(True, card * 6, len(names[table[card][0]]) + 8, card_list[table[card][1]])
                    table_window += page(1, len(names[table[card][0]]) + 9) \
                                    .mutate(0, 0, names[table[card][0]] + ' played').y(card * 6)
                    table_window += page(0, 0).link(card_list[table[card][1]]) \
                                    .x(len(names[table[card][0]]) + 8).y(card * 6)
                print table_window
            print 'These are your playing cards:'
            playing_window = window(7, len(hands[now_play][0]) * 6)
            for index in range(len(hands[now_play][0])):
                # playing_window.append(card_list[hands[now_play][0][index]], [1, index * 6 + 1])
                # playing_window += struct(True, 1, index * 6 + 1, card_list[hands[now_play][0][index]])
                playing_window += page(0, 0).link(card_list[hands[now_play][0][index]]).x(index * 6 + 1).y(1)
            print playing_window
            if len(hands[now_play][1]) > 0:
                hands[now_play][1].sort()
                print 'These are your captured cards:'
                capture_window = window(7, len(hands[now_play][1]) * 6)
                for index in range(len(hands[now_play][1])):
                    # capture_window.append(card_list[hands[now_play][1][index]], [1, index * 6 + 1])
                    # capture_window += struct(True, 1, index * 6 + 1, card_list[hands[now_play][1][index]])
                    capture_window += page(0, 0).link(card_list[hands[now_play][1][index]]).x(index * 6 + 1).y(1)
                print capture_window
            # endregion
            asking = True
            while asking:
                try:
                    card = int(raw_input('What card do you want to play? '))
                    if card >= 0 and card <= 9:
                        try:
                            hands[now_play][0].remove(card)
                            table.append((now_play, card))
                            if card > high_card:
                                high_card = card
                            asking = False
                        except:
                            print 'You do not have that card.'
                    else:
                        print 'You must enter a value between -1 and 10.'
                except:
                    print 'You must enter a number.'
        for line in range(50):
            print
        #region: change
        table_window = window(len(table) * 6, longest_name + 13)
        for card in range(len(table)):
            # name_page = page(1, len(names[table[card][0]]) + 9)
            # name_page.mutate(0, 0, names[table[card][0]] + ' played')
            # table_window.append(name_page, [card * 6, 0])
            # table_window.append(card_list[table[card][1]], [card * 6, len(names[table[card][0]]) + 8])
            # table_window += struct(True, card * 6, 0, name_page)
            # table_window += struct(True, card * 6, len(names[table[card][0]]) + 8, card_list[table[card][1]])
            table_window += page(1, len(names[table[card][0]]) + 9) \
                            .mutate(0, 0, names[table[card][0]] + ' played').y(card * 6)
            table_window += page(0, 0).link(card_list[table[card][1]]) \
                            .x(len(names[table[card][0]]) + 8).y(card * 6)
        print table_window
        # endregion
        hand_out = []
        for index in range(players):
            if table[index][1] == high_card:
                hand_out.append(table[index][0])
        while len(table) > 0:
            hands[hand_out[randint(0, len(hand_out) - 1)]][1].append(table[0][1])
            del table[0]
        for player in range(players):
            if len(hands[player][1]) > 0:
                   print names[player] + ' has captured ' + str(len(hands[player][1])) + ' cards.'
        print
        raw_input('End Of Round ' + str(round))
    for line in range(50):
        print
    high_score = 0
    scores = []
    for player in range(players):
        total = 0
        for card in range(len(hands[player][1])):
            total += hands[player][1][card]
        if total > high_score:
            high_score = total
        if len(scores) == 0 or scores[len(scores) - 1][1] <= total:
            scores.append((player, total))
        else:
            for index in range(len(scores)):
                if total > scores[index][1]:
                    scores.insert((player, total))
                    break
    for player in range(players):
        print names[scores[player][0]] + ' received ' + str(scores[player][1]) + ' points.'
    print
    for index in range(10):
        raw_input('GAME OVER ... ' + str(9 - index))

if __name__ == '__main__':
    game()

In addition to the previous code, you will need the following modules to run the program.

cards.py

import Zpaw

card_0 = Zpaw.page(5, 5)
card_0.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| 0 |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_1 = Zpaw.page(5, 5)
card_1.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| 1 |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_2 = Zpaw.page(5, 5)
card_2.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| 2 |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_3 = Zpaw.page(5, 5)
card_3.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| 3 |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_4 = Zpaw.page(5, 5)
card_4.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| 4 |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_5 = Zpaw.page(5, 5)
card_5.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| 5 |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_6 = Zpaw.page(5, 5)
card_6.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| 6 |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_7 = Zpaw.page(5, 5)
card_7.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| 7 |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_8 = Zpaw.page(5, 5)
card_8.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| 8 |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_9 = Zpaw.page(5, 5)
card_9.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| 9 |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_10 = Zpaw.page(5, 5)
card_10.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '|1 0|') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_A = Zpaw.page(5, 5)
card_A.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| A |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_J = Zpaw.page(5, 5)
card_J.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| J |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_Q = Zpaw.page(5, 5)
card_Q.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| Q |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

card_K = Zpaw.page(5, 5)
card_K.mutate(0, 0, '+---+') \
                 .mutate(1, 0, '|   |').mutate(2, 0, '| K |') \
                 .mutate(3, 0, '|   |').mutate(4, 0, '+---+')

Zam.py

# Name & Description
# ==================

'''Support module for array and matrix use.

This module provides two classes that emulate one and two
dimentional lists with fixed sizes but mutable internals.'''

# Data & Imports
# ==============

__all__ = ['array', 'matrix']
__version__ = '1.1'

import sys

# Public Names
# ============

class array(object):

    '''array(length) -> new array
    array(length, value) -> initialized from value'''

    def __init__(self, length, value=None):
        '''x.__init__(...) initializes x'''
        self.__data = range(length)
        for index in range(length):
            self.__data[index] = value

    def __repr__(self):
        '''x.__repr__() <==> repr(x)'''
        return repr(self.__data)

    def __len__(self):
        '''x.__len__() <==> len(x)'''
        return len(self.__data)

    def __getitem__(self, key):
        '''x.__getitem__(y) <==> x[y]'''
        return self.__data[key]

    def __setitem__(self, key, value):
        '''x.__setitem__(i, y) <==> x[i]=y'''
        self.__data[key] = value

    def __delitem__(self, key):
        '''x.__delitem__(y) <==> del x[y]'''
        self.__data[key] = None

    def __iter__(self):
        '''x.__iter__() <==> iter(x)'''
        return iter(self.__data)

    def __contains__(self, value):
        '''x.__contains__(y) <==> y in x'''
        return value in self.__data

class matrix(object):

    '''matrix(rows, columns) -> new matrix
    matrix(rows, columns, value) -> initialized from value'''

    def __init__(self, rows, columns, value=None):
        '''x.__init__(...) initializes x'''
        self.__data = array(rows)
        for index in range(rows):
            self.__data[index] = array(columns, value)

    def __repr__(self):
        '''x.__repr__() <==> repr(x)'''
        return repr(self.__data)

    def __len__(self):
        '''x.__len__() <==> len(x)'''
        return len(self.__data)

    def __getitem__(self, key):
        '''x.__getitem__(y) <==> x[y]'''
        return self.__data[key]

    def __setitem__(self, key, value):
        '''x.__setitem__(i, y) <==> x[i]=y'''
        self.__data[key] = array(len(self.__data[key]), value)

    def __delitem__(self, key):
        '''x.__delitem__(y) <==> del x[y]'''
        self.__data[key] = array(len(self.__data[key]))

    def __iter__(self):
        '''x.__iter__() <==> iter(x)'''
        return iter(self.__data)

    def __contains__(self, value):
        '''x.__contains__(y) <==> y in x'''
        for item in self.__data:
            if value in item:
                return True
        return False

# Private Names
# =============

def main():
    print 'Content-Type: text/plain'
    print
    print file(sys.argv[0]).read()

# Execute Main
# ============

if __name__ == '__main__':
    main()

Zpaw.py

import Zam

class page(object):

    def __init__(self, rows, columns, value=None):
        self.__assert_type((int, rows), (int, columns))
        if value:
            self.__assert_type((str, value))
            self.__data = Zam.matrix(rows, columns, value[0])
        else:
            self.__data = Zam.matrix(rows, columns, ' ')
        # These three are new variables (from class struct).
        self.__visible = True
        self.__x = 0
        self.__y = 0

    def __repr__(self):
        return repr(self.__data)

    def __str__(self):
        return '\n'.join([''.join(row) for row in self.__data])

    def size(self): # Return a tuple of matrix's size.
        return len(self.__data), len(self.__data[0])

    def access(self, row, column, length=None): # Get a string of length from row and column.
        self.__assert_type((int, row), (int, column))
        if length:
            self.__assert_type((int, length))
        else:
            length = 1
        string = str()
        for index in range(length):
            try:
                string += self.__data[row][column + index]
            except:
                pass
        return string

    def mutate(self, row, column, value): # Write a character or string where told.
        self.__assert_type((int, row), (int, column), (str, value))
        for index in range(len(value)):
            try:
                self.__data[row][column + index] = value[index]
            except:
                pass
        return self

    def set_row(self, row, value=None): # Set or clear a row to one character.
        self.__assert_type((int, row))
        if value:
            self.__assert_type((str, value))
            self.__data[row] = value[0]
        else:
            self.__data[row] = ' '
        return self

    def set_column(self, column, value=None): # Set or clear a column to one character.
        self.__assert_type((int, column))
        if value:
            self.__assert_type((str, value))
        else:
            value = ' '
        for row in self.__data:
            row[column] = value[0]
        return self

    def visible(self, value=None): # Get or set visible.
        if value is None:
            return self.__visible
        else:
            self.__assert_type((bool, value))
            self.__visible = value
            return self

    def x(self, value=None): # Get or set x.
        if value is None:
            return self.__x
        else:
            self.__assert_type((int, value))
            self.__x = value
            return self

    def y(self, value=None): # Get or set y.
        if value is None:
            return self.__y
        else:
            self.__assert_type((int, value))
            self.__y = value
            return self

    def project(self, value): # Copy value to self with offset.
        for row in range(value.size()[0]):
            for column in range(value.size()[1]):
                try:
                    self.__data \
                                [value.y() + row] \
                                [value.x() + column] = \
                                value.__data[row][column]
                except:
                    pass
        return self

    def page(self): # Casting statement.
        return self

    def link(self, value): # Use and share value's __data.
        if value.__class__ is page:
            self.__data = value.__data
            return self
        else:
            raise ValueError

    def unlink(self):
        temp = Zam.matrix(len(self.__data), len(self.__data[0])) # Create a new matrix.
        for row in range(len(self.__data)): # Copy all of the data to the new matrix.
            for column in range(len(self.__data[0])):
                temp[row][column] = self.__data[row][column]
        self.__data = temp # Finish the conversion.
        return self # Allow more work to be done.

    def __assert_type(self, *tuples):
        for types, objects in tuples:
            if type(objects) is not types:
                raise TypeError

class window(object):

    def __init__(self, height, width, border=None, background=None):
        self.__assert_type((int, height), (int, width))
        if border:
            self.__assert_type((str, border))
            self.__border = border[0]
        else:
            self.__border = ''
        if background:
            self.__assert_type((str, background))
            self.__background = background[0]
        else:
            self.__background = ' '
        self.__height = height
        self.__width = width
        self.__page = page(0, 0)
        self.__list = list()
        self.__refresh()

    def __repr__(self):
        self.__refresh()
        return repr(self.__page)

    def __str__(self):
        self.__refresh()
        return str(self.__page)

    def __len__(self):
        return len(self.__list)

    def __getitem__(self, key):
        self.__assert_type((int, key))
        return self.__list[key]

    def __setitem__(self, key, value):
        self.__assert_type((int, key))
        if value.__class__ is page or value.__class__ is window:
            self.__list[key] = value
        else:
            raise ValueError

    def __delitem__(self, key):
        self.__assert_type((int, key))
        del self.__list[key]

    def __iter__(self):
        return iter(self.__list)

    def __contains__(self, value): # value in self
        return value in self.__list

    def __iadd__(self, value): # self += page || window
        if value.__class__ is page or value.__class__ is window:
            self.__list.append(value)
            return self # this line is required
        else:
            raise ValueError

    def __isub__(self, value): # self -= page || window
        while value in self.__list:
            self.__list.remove(value)
        return self # this line may be required

    def size(self, height=None, width=None): # This needs to be divided into two functions.
        if height or width:
            if height:
                self.__assert_type((int, height))
                self.__height = height
            if width:
                self.__assert_type((int, width))
                self.__width = width
            return self
        return self.__height, self.__width

    def option(self, border=None, background=None): # This needs to be divided into two functions.
        if border is not None or background is not None:
            if border is not None:
                self.__assert_type((str, border))
                if border:
                    self.__border = border[0]
                else:
                    self.__border = border
            if background is not None:
                self.__assert_type((str, background))
                if background:
                    self.__background = background[0]
                else:
                    self.__background = background
            return self
        return self.__border, self.__background

    def visible(self, value=None): # Get or set visible.
        return self.__page.visible(value)

    def x(self, value=None): # Get or set x.
        return self.__page.x(value)

    def y(self, value=None): # Get or set y.
        return self.__page.y(value)

    def page(self): # This is like a casting statement.
        self.__refresh()
        return self.__page

    def __refresh(self):
        temp = page(self.__height, self.__width, self.__background) \
               .visible(self.__page.visible()).x(self.__page.x()).y(self.__page.y())
        self.__page = temp
        for item in self.__list: # Display Pages And Windows
            if item.visible():
                    self.__page.project(item.page())
        if self.__border: # Create Borders
            self.__page.set_row(0, self.__border).set_row(self.__height - 1, self.__border) \
                                   .set_column(0, self.__border).set_column(self.__width - 1, self.__border)

    def __assert_type(self, *tuples):
        for types, objects in tuples:
            if type(objects) is not types:
                raise TypeError

# TEST CODE
if __name__ == '__main__':
    it = window(10, 10)
    print it
    print it.option('#')
    print it.option(background='-')
    it += page(1, 1, '%').x(2).y(2)
    print it
    other = page(2, 2, 'H')
    it += other.x(3).y(3)
    print it
    it -= other
    print it
    del it[0]
    print it
    other = page(2, 2, '%')
    it += other.x(2).y(2)
    print it
    other_2 = page(0, 0)
    it += other_2.y(5).x(2).link(other)
    print it
    other_2.mutate(0, 0, 'H')
    print it
    print it.option('', '')