mirror of
https://github.com/coding-horror/basic-computer-games.git
synced 2025-12-30 22:52:00 -08:00
376 lines
9.6 KiB
Python
376 lines
9.6 KiB
Python
import re
|
|
import random
|
|
|
|
###################
|
|
#
|
|
# static variables
|
|
#
|
|
###################
|
|
|
|
BOARD_WIDTH = 10
|
|
BOARD_HEIGHT = 10
|
|
|
|
SHIPS = [("BATTLESHIP", 5),
|
|
("CRUISER", 3),
|
|
("DESTROYER<A>", 2),
|
|
("DESTROYER<B>", 2)]
|
|
|
|
VALID_MOVES = [[-1, 0], # North
|
|
[-1, 1], # North East
|
|
[0, 1], # East
|
|
[1, 1], # South East
|
|
[1, 0], # South
|
|
[1, -1], # South West
|
|
[0, -1], # West
|
|
[-1, -1]] # North West
|
|
|
|
COORD_REGEX = '[ \t]{0,}(-?[0-9]{1,3})[ \t]{0,},[ \t]{0,}(-?[0-9]{1,2})'
|
|
|
|
####################
|
|
#
|
|
# global variables
|
|
#
|
|
####################
|
|
|
|
# array of BOARD_HEIGHT arrays, BOARD_WIDTH in length,
|
|
# representing the human player and computer
|
|
player_board = []
|
|
computer_board = []
|
|
|
|
# array representing the coordinates
|
|
# for each ship for player and computer
|
|
# array is in the same order as SHIPS
|
|
player_ship_coords = []
|
|
computer_ship_coords = []
|
|
|
|
# keep track of the turn
|
|
current_turn = 0
|
|
|
|
# flag indicating if computer's shots are
|
|
# printed out during computer's turn
|
|
print_computer_shots = False
|
|
|
|
# keep track of the number
|
|
# of available computer shots
|
|
# inital shots are 7
|
|
num_computer_shots = 7
|
|
|
|
# keep track of the number
|
|
# of available player shots
|
|
# initial shots are 7
|
|
num_player_shots = 7
|
|
|
|
####################
|
|
#
|
|
# game functions
|
|
#
|
|
####################
|
|
|
|
# random number functions
|
|
#
|
|
# seed the random number generator
|
|
random.seed()
|
|
|
|
|
|
# random_x_y
|
|
#
|
|
# generate a valid x,y coordinate on the board
|
|
# returns: x,y
|
|
# x: integer between 1 and BOARD_HEIGHT
|
|
# y: integer between 1 and BOARD WIDTH
|
|
def random_x_y():
|
|
x = random.randrange(1, BOARD_WIDTH+1)
|
|
y = random.randrange(1, BOARD_HEIGHT+1)
|
|
return (x, y)
|
|
|
|
|
|
# input_coord
|
|
#
|
|
# ask user for single (x,y) coordinate
|
|
# validate the coordinates are within the bounds
|
|
# of the board width and height. mimic the behavior
|
|
# of the original program which exited with error
|
|
# messages if coordinates where outside of array bounds.
|
|
# if input is not numeric, print error out to user and
|
|
# let them try again.
|
|
def input_coord():
|
|
match = None
|
|
while not match:
|
|
coords = input("? ")
|
|
match = re.match(COORD_REGEX, coords)
|
|
if not match:
|
|
print("!NUMBER EXPECTED - RETRY INPUT LINE")
|
|
x = int(match.group(1))
|
|
y = int(match.group(2))
|
|
|
|
if x > BOARD_HEIGHT or y > BOARD_WIDTH:
|
|
print("!OUT OF ARRAY BOUNDS IN LINE 1540")
|
|
exit()
|
|
|
|
if x <= 0 or y <= 0:
|
|
print("!NEGATIVE ARRAY DIM IN LINE 1540")
|
|
exit()
|
|
|
|
return x, y
|
|
|
|
|
|
# TODO: add an optional starting coordinate for testing
|
|
# purposes
|
|
def generate_ship_coordinates(ship):
|
|
# randomly generate starting x,y coordinates
|
|
start_x, start_y = random_x_y()
|
|
|
|
# using starting coordinates and the ship type,
|
|
# generate a vector of possible directions the ship
|
|
# could be placed. directions are numbered 0-7 along
|
|
# points of the compass (N, NE, E, SE, S, SW, W, NW)
|
|
# clockwise. a vector of valid directions where the
|
|
# ship does not go off the board is determined
|
|
ship_len = SHIPS[ship][1] - 1
|
|
dirs = [False for x in range(8)]
|
|
dirs[0] = (start_x - ship_len) >= 1
|
|
dirs[2] = (start_y + ship_len) <= BOARD_WIDTH
|
|
dirs[1] = dirs[0] and dirs[2]
|
|
dirs[4] = (start_x + ship_len) <= BOARD_HEIGHT
|
|
dirs[3] = dirs[2] and dirs[4]
|
|
dirs[6] = (start_y - ship_len) >= 1
|
|
dirs[5] = dirs[4] and dirs[6]
|
|
dirs[7] = dirs[6] and dirs[0]
|
|
directions = [p for p in range(len(dirs)) if dirs[p]]
|
|
|
|
# using the vector of valid directions, pick a
|
|
# random direction to place the ship
|
|
dir_idx = random.randrange(len(directions))
|
|
direction = directions[dir_idx]
|
|
|
|
# using the starting x,y, direction and ship
|
|
# type, return the coordinates of each point
|
|
# of the ship. VALID_MOVES is a staic array
|
|
# of coordinate offsets to walk from starting
|
|
# coordinate to the end coordinate in the
|
|
# chosen direction
|
|
ship_len = SHIPS[ship][1] - 1
|
|
d_x = VALID_MOVES[direction][0]
|
|
d_y = VALID_MOVES[direction][1]
|
|
|
|
coords = [(start_x, start_y)]
|
|
x_coord = start_x
|
|
y_coord = start_y
|
|
for i in range(ship_len):
|
|
x_coord = x_coord + d_x
|
|
y_coord = y_coord + d_y
|
|
coords.append((x_coord, y_coord))
|
|
return coords
|
|
|
|
|
|
# create_blank_board
|
|
#
|
|
# helper function to create a game board
|
|
# that is blank
|
|
def create_blank_board():
|
|
return [[None for y in range(BOARD_WIDTH)]
|
|
for x in range(BOARD_HEIGHT)]
|
|
|
|
|
|
# print_board
|
|
#
|
|
# print out the game board for testing
|
|
# purposes
|
|
def print_board(board):
|
|
|
|
# print board header (column numbers)
|
|
print(' ', end='')
|
|
for z in range(BOARD_WIDTH):
|
|
print(f'{z+1:3}', end='')
|
|
print('')
|
|
|
|
for x in range(len(board)):
|
|
print(f'{x+1:2}', end='')
|
|
for y in range(len(board[x])):
|
|
if(board[x][y] is None):
|
|
print(f"{' ':3}", end='')
|
|
else:
|
|
print(f"{board[x][y]:3}", end='')
|
|
print('')
|
|
|
|
|
|
# place_ship
|
|
#
|
|
# place a ship on a given board. updates
|
|
# the board's row,column value at the given
|
|
# coordinates to indicate where a ship is
|
|
# on the board.
|
|
#
|
|
# inputs: board - array of BOARD_HEIGHT by BOARD_WIDTH
|
|
# coords - array of sets of (x,y) coordinates of each
|
|
# part of the given ship
|
|
# ship - integer repreesnting the type of ship (given in SHIPS)
|
|
def place_ship(board, coords, ship):
|
|
for coord in coords:
|
|
board[coord[0]-1][coord[1]-1] = ship
|
|
|
|
|
|
# NOTE: A little quirk that exists here and in the orginal
|
|
# game: Ships are allowed to cross each other!
|
|
# For example: 2 destroyers, length 2, one at
|
|
# [(1,1),(2,2)] and other at [(2,1),(1,2)]
|
|
def generate_board():
|
|
board = create_blank_board()
|
|
|
|
ship_coords = []
|
|
for ship in range(len(SHIPS)):
|
|
placed = False
|
|
coords = []
|
|
while not placed:
|
|
coords = generate_ship_coordinates(ship)
|
|
clear = True
|
|
for coord in coords:
|
|
if board[coord[0]-1][coord[1]-1] is not None:
|
|
clear = False
|
|
break
|
|
if clear:
|
|
placed = True
|
|
place_ship(board, coords, ship)
|
|
ship_coords.append(coords)
|
|
return board, ship_coords
|
|
|
|
|
|
# execute_shot
|
|
#
|
|
# given a board and x, y coordinates,
|
|
# execute a shot. returns True if the shot
|
|
# is valid, False if not
|
|
def execute_shot(board, x, y):
|
|
print("execute shot:", x, y)
|
|
|
|
|
|
# initialize
|
|
#
|
|
# function to initialize global variables used
|
|
# during game play.
|
|
def initialize_game():
|
|
|
|
# initialize the global player and computer
|
|
# boards
|
|
global player_board
|
|
player_board = create_blank_board()
|
|
|
|
# generate the ships for the computer's
|
|
# board
|
|
global computer_board
|
|
global computer_ship_coords
|
|
computer_board, computer_ship_coords = generate_board()
|
|
|
|
# print out the title 'screen'
|
|
print('{0:>38}'.format("SALVO"))
|
|
print('{0:>57s}'.format("CREATIVE COMPUTING MORRISTOWN, NEW JERSEY"))
|
|
print('\n\n')
|
|
|
|
# ask the player for ship coordinates
|
|
print("ENTER COORDINATES FOR...")
|
|
ship_coords = []
|
|
for ship in SHIPS:
|
|
print(ship[0])
|
|
list = []
|
|
for i in range(ship[1]):
|
|
x, y = input_coord()
|
|
list.append((x, y))
|
|
ship_coords.append(list)
|
|
|
|
# add ships to the user's board
|
|
for ship in range(len(SHIPS)):
|
|
place_ship(player_board, ship_coords[ship], ship)
|
|
|
|
# see if the player wants the computer's ship
|
|
# locations printed out and if the player wants to
|
|
# start
|
|
input_loop = True
|
|
player_start = "YES"
|
|
while input_loop:
|
|
player_start = input("DO YOU WANT TO START? ")
|
|
if player_start == "WHERE ARE YOUR SHIPS?":
|
|
for ship in range(len(SHIPS)):
|
|
print(SHIPS[ship][0])
|
|
coords = computer_ship_coords[ship]
|
|
for coord in coords:
|
|
x = coord[0]
|
|
y = coord[1]
|
|
print('{0:2}'.format(x), '{0:2}'.format(y))
|
|
else:
|
|
input_loop = False
|
|
|
|
# ask the player if they want the computer's shots
|
|
# printed out each turn
|
|
global print_computer_shots
|
|
see_computer_shots = input("DO YOU WANT TO SEE MY SHOTS? ")
|
|
if see_computer_shots.lower() == "yes":
|
|
print_computer_shots = True
|
|
|
|
global first_turn
|
|
global second_turn
|
|
if player_start.lower() != "yes":
|
|
first_turn = computer_turn
|
|
second_turn = player_turn
|
|
|
|
|
|
####################################
|
|
#
|
|
# Turn Control
|
|
#
|
|
# define functions for executing the turns for
|
|
# the player and the computer. By defining this as
|
|
# functions, we can easily start the game with
|
|
# either computer or player and alternate back and
|
|
# forth, replicating the gotos in the original game
|
|
def player_turn():
|
|
print("YOU HAVE", num_computer_shots, "SHOTS.")
|
|
|
|
shots = []
|
|
for shot in range(num_player_shots):
|
|
valid_shot = False
|
|
while not valid_shot:
|
|
x, y = input_coord()
|
|
valid_shot = execute_shot(player_board, x, y)
|
|
shots.append((x, y))
|
|
|
|
print(shots)
|
|
|
|
|
|
# initialize the first_turn function to the
|
|
# player's turn
|
|
first_turn = player_turn
|
|
|
|
|
|
def computer_turn():
|
|
print("I HAVE", num_computer_shots, "SHOTS.")
|
|
|
|
|
|
# initialize the second_turn to the computer's
|
|
# turn
|
|
second_turn = computer_turn
|
|
|
|
#
|
|
# Turn Control
|
|
#
|
|
######################################
|
|
|
|
######################
|
|
#
|
|
# main game flow
|
|
#
|
|
######################
|
|
|
|
# initialize the player and computer
|
|
# boards
|
|
initialize_game()
|
|
|
|
# execute turns until someone wins or we run
|
|
# out of squares to shoot
|
|
|
|
current_turn = current_turn + 1
|
|
print("\n")
|
|
print("TURN", current_turn)
|
|
|
|
first_turn()
|
|
second_turn()
|