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
Download
Copy to clipboard1 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('', '')
