Python Battleship Game

Question

I have a 2-player game of Battleship written in Python, but I've reused a lot of code for the second player's decisions (particularly in the play_game function). I'm not sure if my question is specific enough for this website, but if so would appreciate some guidance on how this redundancy could be minimised.

__author__ = 'admin'
import sys
def initialise_board(): #create a 10x10 board
 game_board = []
 opponent_board = []
 letters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
 for x in range(len(letters)):
 game_board.append([])
 opponent_board.append([])
 for y in range(1, 11):
 game_board[x].append(str(letters[x])+str(y))
 opponent_board[x].append(str(letters[x])+str(y))
 choose_ships(game_board, opponent_board) #call function to choose ships
def choose_ships(game_board, opponent_board):
 Ships = {'Carrier': 5, 'Battleship': 4, 'Cruiser': 3, 'Submarine': 3, 'Destroyer': 2} #size of each ship
 P1_Ships = [['Carrier', 1], ['Battleship', 1], ['Cruiser', 1], ['Submarine', 1], ['Destroyer', 1]] #number of ships to place
 P2_Ships = [['Carrier', 1], ['Battleship', 1], ['Cruiser', 1], ['Submarine', 1], ['Destroyer', 1]]
 for x in P1_Ships: #place ships
 r = 0
 while x[1] > 0: #check there's ships available
 r += 1
 type = x[0]
 ship_size = Ships[x[0]]
 position = input("Player 1, enter start position of {0}: ".format(x[0])) #choose position (i.e, A1)
 check = place_ship(game_board, ship_size, position, type)
 if check is True:
 x[1] -= 1
 else:
 print("Can't place ship here.")
 for z in P2_Ships: #place ships
 r = 0
 while z[1] > 0: #check there's ships available
 r += 1
 type = z[0]
 ship_size = Ships[z[0]]
 position = input("Player 2, enter start position of {0}: ".format(z[0])) #choose position (i.e, A1)
 check = place_ship(opponent_board, ship_size, position, type)
 if check is True:
 z[1] -= 1
 else:
 print("Can't place ship here.")
 play_game(game_board, opponent_board)
def check_availability(game_board, ship_size, col, row, direction): #check that ship can be placed
 check_ships = ["Carrier", "Battleship", "Cruiser", "Submarine", "Destroyer"]
 if direction == 'up':
 if row - int(ship_size) >= 0: #check ship within boundaries
 for i in range(0, ship_size):
 if game_board[int(row-i)][int(col)-1] not in check_ships: #check for collision
 pass
 else:
 return False
 return True
 else:
 return False
 elif direction == 'down':
 space = row + int(ship_size)
 if space <= 11: #check ship within boundaries
 for i in range(0, ship_size):
 rawr = game_board[int(row+i)][int(col)-1]
 if rawr not in check_ships: #check for collision
 pass
 else:
 return False
 return True
 else:
 return False
 elif direction == 'right':
 if col + int(ship_size) <= 11: #check ship within boundaries
 for i in range(0, ship_size):
 if game_board[int(row)][int(col)+i-1] not in check_ships: #check for collision
 pass
 else:
 return False
 return True
 else:
 return False
 elif direction == 'left':
 if col - int(ship_size) >= 0: #check ship within boundaries
 for i in range(0, ship_size+1):
 if game_board[int(row)][int(col-1)-i] not in check_ships: #check for collision
 pass
 else:
 return False
 return True
 else:
 return False
def place_ship(game_board, ship_size, position, ship_type):
 row = position[0]
 row = ord(row)-65
 if len(position) > 2:
 col = (position[1]+position[2])
 else:
 col = position[1]
 row = int(row)
 col = int(col)
 orientation = int(input("Place ship: \n"
 "1. Vertically \n"
 "2. Horizontally")) #horizontal or vertical
 if orientation == 1:
 direction = int(input("Choose direction: \n"
 "1. Up \n"
 "2. Down")) #up or down
 if direction == 1:
 result = check_availability(game_board, ship_size, col, row, 'up')
 if result is True:
 for i in range(0, ship_size):
 game_board[int(row-i)][int(col)-1] = str(ship_type)
 print(game_board)
 else:
 result = check_availability(game_board, ship_size, col, row, 'down')
 if result is True:
 for i in range(0, ship_size):
 game_board[int(row+i)][int(col)-1] = str(ship_type)
 print(game_board)
 else:
 direction = int(input("Choose direction: \n"
 "1. Right\n"
 "2. Left"))
 if direction == 1:
 result = check_availability(game_board, ship_size, col, row, 'right')
 if result is True:
 for i in range(0, ship_size):
 game_board[int(row)][int(col)+i-1] = str(ship_type)
 print(game_board)
 else:
 result = check_availability(game_board, ship_size, col, row, 'left')
 if result is True:
 for i in range(0, ship_size):
 game_board[int(row)][int(col)-i-1] = str(ship_type)
 print(game_board)
 return result
def play_game(game_board, opponnent_board):
 print("Player 1 starts.")
 P1_turn = True
 P2_turn = False
 check_ships = ["Carrier", "Battleship", "Cruiser", "Submarine", "Destroyer"]
 victory = False
 while True:
 if P1_turn:
 while not victory:
 pos = input("Player 1, enter target: ")
 row = pos[0]
 row = ord(row)-65
 if len(pos) > 2:
 col = (pos[1]+pos[2])
 else:
 col = pos[1]
 row = int(row)
 col = int(col) - 1
 target = opponnent_board[row][col]
 ship_hit = target
 target = str(ship_hit)
 if target in check_ships:
 print("Hit")
 else:
 print("Miss")
 opponnent_board[row][col] = "X"
 destroyed = True
 for y in opponnent_board:
 if destroyed:
 for x in y:
 if x == ship_hit:
 destroyed = False
 break
 else:
 break
 if destroyed:
 if target in check_ships:
 print("{0} DESTROYED.".format(target))
 victory = True
 for y in opponnent_board:
 if victory:
 for j in y:
 if j not in check_ships:
 victory = True
 else:
 victory = False
 break
 if victory:
 print("PLAYER 1 WINS")
 sys.exit()
 P1_turn = False
 P2_turn = True
 break
 elif P2_turn:
 while not victory:
 pos = input("Player 2, enter target: ")
 row = pos[0]
 row = ord(row)-65
 if len(pos) > 2:
 col = (pos[1]+pos[2])
 else:
 col = pos[1]
 row = int(row)
 col = int(col) - 1
 target = game_board[row][col]
 ship_hit = target
 target = str(ship_hit)
 if target in check_ships:
 print("Hit")
 else:
 print("Miss")
 game_board[row][col] = "X"
 destroyed = True
 for y in game_board:
 if destroyed:
 for x in y:
 if x == ship_hit:
 destroyed = False
 break
 else:
 break
 if destroyed:
 if target in check_ships:
 print("{0} DESTROYED.".format(target))
 victory = True
 for y in game_board:
 if victory:
 for j in y:
 if j not in check_ships:
 victory = True
 else:
 victory = False
 break
 if victory:
 print("PLAYER 2 WINS")
 sys.exit()
 P1_turn = True
 P2_turn = False
 break
initialise_board()

Answer 1

You can use loops to reduce repetition between players, here is an example:

P1_Ships = [['Carrier', 1], ['Battleship', 1], ['Cruiser', 1], ['Submarine', 1], ['Destroyer', 1]] #number of ships to place
P2_Ships = [['Carrier', 1], ['Battleship', 1], ['Cruiser', 1], ['Submarine', 1], ['Destroyer', 1]]
for x in P1_Ships: #place ships
 r = 0
 while x[1] > 0: #check there's ships available
 r += 1
 type = x[0]
 ship_size = Ships[x[0]]
 position = input("Player 1, enter start position of {0}: ".format(x[0])) #choose position (i.e, A1)
 check = place_ship(game_board, ship_size, position, type)
 if check is True:
 x[1] -= 1
 else:
 print("Can't place ship here.")
for z in P2_Ships: #place ships
 r = 0
 while z[1] > 0: #check there's ships available
 r += 1
 type = z[0]
 ship_size = Ships[z[0]]
 position = input("Player 2, enter start position of {0}: ".format(z[0])) #choose position (i.e, A1)
 check = place_ship(opponent_board, ship_size, position, type)
 if check is True:
 z[1] -= 1
 else:
 print("Can't place ship here.")

Becomes:

for player, board, ships in ( ("1", game_board, p1_ships), ("2", opponent_board, p2_ships) ):
 # Exercise for the reader

(Please note that the ships are the same for each player so you can just set one equal to the copy of the other.)

Answer 2

When checking the function play_game(), codes for P1_turn and for P2_turn are identical at algorithm level and only different for player identity 1 or 2 and its associated board opponnent_board or game_board.

Minimize redundancy - PART 1

Step 1 - define a function play_turn() to manage the update the board of the player.

The function returns victory to be checked by the exit-condition.

def play_turn(player_id, player_board):
 pos = input("Player {0}, enter target: ".format(player_id))
 row = pos[0]
 row = ord(row)-65
 if len(pos) > 2:
 col = (pos[1]+pos[2])
 else:
 col = pos[1]
 row = int(row)
 col = int(col) - 1
 target = player_board[row][col]
 ship_hit = target
 target = str(ship_hit)
 if target in check_ships:
 print("Hit")
 else:
 print("Miss")
 player_board[row][col] = "X"
 destroyed = True
 for y in player_board:
 if destroyed:
 for x in y:
 if x == ship_hit:
 destroyed = False
 break
 else:
 break
 if destroyed:
 if target in check_ships:
 print("{0} DESTROYED.".format(target))
 victory = True
 for y in player_board:
 if victory:
 for j in y:
 if j not in check_ships:
 victory = True
 else:
 victory = False
 break
 return victory

Step 2 - keep only the while-loop mechanism with the exit condition.

Adding the exit-condition and the P1_turn / P2_turn switching in the play_turn() function is not efficient because it will need to change the if P1_turn: and elif P2_turn: mechanism.

while True:
 if P1_turn:
 while not victory:
 # P1_turn = player 1 and opponnent_board
 victory = play_turn(1,opponnent_board)
 # exit condition player 1
 if victory:
 print("PLAYER 1 WINS")
 sys.exit()
 P1_turn = False
 P2_turn = True
 break
 elif P2_turn:
 while not victory:
 # P2_turn = player 2 and game_board
 victory = play_turn(2,game_board)
 # exit condition player 2
 if victory:
 print("PLAYER 2 WINS")
 sys.exit()
 P1_turn = True
 P2_turn = False
 break

Minimize redundancy - PART 2

It is your turn... Check in the function place_ship() what algorithm is identical and what variable are different.

The function could be called move_ship().

Answer 3

Here is a technique for reducing common code. It uses the facts that 0 * x = 0, 1 * x = x and -1 * x = -x to reduce the tests that seem to be different for the four directions to a single set of tests. This example reduces check_availability to this:

def check_availability(game_board, ship_size, col, row,
 direction): # check that ship can be placed
 check_ships = ["Carrier", "Battleship", "Cruiser", "Submarine",
 "Destroyer"]
 row_sign, col_sign = dict(
 up=(-1, 0),
 down=(1, 0),
 right=(0, 1),
 left=(0, -1),
 )[direction]
 # check ship within boundaries
 bound = row * abs(row_sign) + col * abs(col_sign) + (
 row_sign + col_sign) * int(ship_size)
 if 0 <= bound <= 11:
 for i in range(ship_size):
 # check for collision
 if game_board[int(row) + i * row_sign][
 int(col) + i * col_sign] in check_ships:
 return False
 return True
 else:
 return False

Note, I did not test this, so it may have a sign error or such. Hopefully this is illustrative.