Little documentation for project

Sea_battle/ # Game project file

Sea_battle/ai_py # AI logic for the game

Sea_battle/battleship.py # The main file of the game through which it is launched

Sea_battle/board.py # Representation of logic and implementation of the playing field

Sea_battle/client.py # Client part of the game

Sea_battle/game_save.json # Location where the save is stored

Sea_battle/game.py # Game state management (including saves and save loads)

Sea_battle/player.py # The player's representation of both himself and an AI opponent/second real player.

Sea_battle/server.py # Server part of the game

Sea_battle/ship.py # Ship Logic View

How to run?: Through the terminal in VS Code and/or PyCharm, enter the command "cd C:\Users\Your_name\Desktop\Your_file\SpectrumOfPython\Game-Galore\Sea_battle", then in terminal write "python battleship.py".

How to play: First, select an opponent (AI or a real player, whom you are currently playing), then choose your (and second player, when you play against real man) nickname and game is generated 10x10 field with 4 types of ships. 4 one-cell ships, 3 two-cell ships, 2 three-cell ships and 1 four-cell ship. Your task is to sink all enemy ships while preserving your own. The round goes until victory. You will have to select the field for defeat using numbers from 0 to 9 in a column and line, the enemy bot/player does the same.

In the future, the game will be updated and released on mobile, joystick and computer controls, and graphics and sound will also be developed.

Now... have fun!

import random

class AIPlayer:

def __init__(self, name):

self.name = name

self.previous_moves = set()

def make_move(self, board):

while True:

row = random.randint(0, len(board.grid) - 1)

col = random.randint(0, len(board.grid[0]) - 1)

if (row, col) not in self.previous_moves:

self.previous_moves.add((row, col))

return (row, col)

from game import Game

def main():

game = Game()

game.play()

if __name__ == "__main__":

main()

from ship import Ship

import random

class Board:

def __init__(self):

self.size = 10

self.grid = [[0 for _ in range(self.size)] for _ in range(self.size)]

self.ships = []

self.ship_counts = {

1: 4,

2: 3,

3: 2,

4: 1

}

self.shots_taken = set()

def place_ship(self, ship, start_row, start_col, orientation):

if self.can_place_ship(ship, start_row, start_col, orientation):

ship.place(start_row, start_col, orientation)

self.ships.append(ship)

for position in ship.positions:

row, col = position

self.grid[row][col] = 1

print(f"Placed ship of length {ship.length} at {start_row}, {start_col} in {orientation} orientation.")

else:

print(f"Cannot place ship of length {ship.length} at {start_row}, {start_col} in {orientation} orientation.")

raise ValueError("Cannot place ship here!")

def can_place_ship(self, ship, row, col, orientation):

if orientation == 'horizontal':

if col + ship.length > self.size:

return False

return all(self.grid[row][col + i] == 0 for i in range(ship.length))

elif orientation == 'vertical':

if row + ship.length > self.size:

return False

return all(self.grid[row + i][col] == 0 for i in range(ship.length))

return False

def receive_shot(self, row, col):

print(f"Received shot at ({row}, {col})")

self.shots_taken.add((row, col))

if self.grid[row][col] == 1:

for ship in self.ships:

if self.is_hit(ship, row, col):

ship.hit((row, col))

self.grid[row][col] = 2

if ship.is_sunk():

print(f"Ship sunk at {ship.positions}!")

return True

self.grid[row][col] = -1

print("Miss!")

return False

def is_hit(self, ship, row, col):

return (row, col) in ship.positions

def check_all_ships_sunk(self):

return all(ship.is_sunk() for ship in self.ships)

def display(self, reveal=False):

for row in range(self.size):

for col in range(self.size):

if self.grid[row][col] == 1 and not reveal:

print('0', end=' ')

elif self.grid[row][col] == -1:

print('M', end=' ')

else:

print(self.grid[row][col], end=' ')

print()

def setup_ships(self):

self.ships = []

for length, count in self.ship_counts.items():

for _ in range(count):

ship = Ship(length)

placed = False

while not placed:

start_row = random.randint(0, self.size - 1)

start_col = random.randint(0, self.size - 1)

orientation = random.choice(['horizontal', 'vertical'])

try:

self.place_ship(ship, start_row, start_col, orientation)

placed = True

except ValueError:

continue

def is_location_shot(self, row, col):

return (row, col) in self.shots_taken

import socket

import json

class GameClient:

def __init__(self, host='localhost', port=12345):

self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

self.client_socket.connect((host, port))

def send_move(self, row, col):

move_data = {'action': 'move', 'row': row, 'col': col}

self.client_socket.send(json.dumps(move_data).encode('utf-8'))

def get_game_state(self):

self.client_socket.send("get_state".encode('utf-8'))

data = self.client_socket.recv(1024).decode('utf-8')

return json.loads(data)

def play(self):

while True:

game_state = self.get_game_state()

print(f"Current player: {game_state['current_player']}")

print("Board 1:", game_state['board1'])

print("Board 2:", game_state['board2'])

if game_state['is_game_over']:

print("Game Over!")

break

while True:

try:

row = int(input("Enter row (0-9): "))

col = int(input("Enter column (0-9): "))

if row < 0 or row >= 10 or col < 0 or col >= 10:

print("Coordinates out of bounds! Please enter values between 0 and 9.")

continue

self.send_move(row, col)

break

except ValueError:

print("Invalid input! Please enter integers.")

if __name__ == "__main__":

client = GameClient()

client.play()

import json

import random

from board import Board

from player import HumanPlayer, AIPlayer

from ship import Ship

class Game:

def __init__(self):

opponent_choice = input("Do you want to play against AI or another player? (AI/player): ")

if opponent_choice.lower() == "ai":

self.ai_player = AIPlayer("AI")

self.human_player = HumanPlayer()

self.board1 = Board()

self.board2 = Board()

self.board1.setup_ships()

self.ai_setup_ships()

else:

self.human_player = HumanPlayer()

self.second_player = HumanPlayer()

self.board1 = Board()

self.board2 = Board()

self.board1.setup_ships()

self.board2.setup_ships()

self.current_player = self.human_player

self.is_game_over = False

self.shots_taken = set()

def ai_setup_ships(self):

ships_to_place = [Ship(1) for _ in range(4)] + [Ship(2) for _ in range(3)] + [Ship(3) for _ in range(2)] + [Ship(4) for _ in range(1)]

for ship in ships_to_place:

placed = False

while not placed:

try:

start_row = random.randint(0, self.board2.size - 1)

start_col = random.randint(0, self.board2.size - 1)

orientation = random.choice(['horizontal', 'vertical'])

self.board2.place_ship(ship, start_row, start_col, orientation)

placed = True

except ValueError:

continue

def shoot(self, row, col):

if (row, col) in self.shots_taken:

print("You have already shot at this position!")

return False

self.shots_taken.add((row, col))

target_board = self.board2 if self.current_player == self.human_player else self.board1

print(f"Player {self.current_player.name} is shooting at ({row}, {col})")

hit = target_board.receive_shot(row, col)

if hit:

print("Hit!")

else:

print("Miss!")

self.check_game_over()

return hit

def check_game_over(self):

if self.board2.check_all_ships_sunk():

self.is_game_over = True

print(f"{self.current_player.name} wins!")

self.ask_to_play_again()

def ask_to_play_again(self):

choice = input("Want to play again? (yes/no): ")

if choice.lower() == 'yes':

self.reset_game()

else:

print("Thanks for playing!")

def reset_game(self):

self.board1 = Board()

self.board2 = Board()

self.current_player = self.human_player

self.is_game_over = False

opponent_choice = input("Do you want to play against AI or another player? (AI/player): ")

if opponent_choice.lower() == "ai":

self.ai_player = AIPlayer("AI")

self.board1.setup_ships()

self.ai_setup_ships()

else:

self.second_player = HumanPlayer()

self.board1.setup_ships()

self.board2.setup_ships()

def save_game(self, filename):

game_state = {

'board1': self.board1.grid,

'board2': self.board2.grid,

'current_player': self.current_player.name,

'is_game_over': self.is_game_over

}

with open(filename, 'w') as f:

json.dump(game_state, f)

def load_game(self, filename):

with open(filename, 'r') as f:

game_state = json.load(f)

self.board1.grid = game_state['board1']

self.board2.grid = game_state['board2']

self.current_player = self.human_player if game_state['current_player'] == self.human_player.name else self.ai_player

self.is_game_over = game_state['is_game_over']

def display_boards(self):

print("Your Board:")

self.board1.display(reveal=True)

print("\nOpponent's Board (Hidden view):")

self.board2.display()

def play(self):

while not self.is_game_over:

print(f"Current player: {self.current_player.name}")

self.display_boards()

if self.current_player.is_ai:

row, col = self.current_player.get_move()

print(f"AI chose coordinates: ({row}, {col})")

else:

command = input("Enter 'save' to save or 'load' to load the game, or make a move (row col): ")

if command.lower() == 'save':

self.save_game('game_save.json')

print("Game saved.")

continue

elif command.lower() == 'load':

self.load_game('game_save.json')

print("Game loaded.")

continue

try:

row, col = map(int, command.split())

except ValueError:

print("Invalid input. Please enter coordinates in 'row col' format.")

continue

hit = self.shoot(row, col)

if not hit:

self.current_player = self.ai_player if self.current_player == self.human_player else self.human_player

if __name__ == "__main__":

game = Game()

game.play()