def __init__(self, name):
self.warships = []
self.highscore = []
self.name = name
self.board = Ocean()
self.board.read_board_from_file()
self.view = Ocean()
self.view.read_board_from_file()
def __init__(self):
self.role = 'server'
self.sock = socket.socket()
self.conn = socket.socket()
self.oceanSize = 5
self.player = Player('Player', Ocean(self.oceanSize))
self.opponent = Player('Opponent', Ocean(self.oceanSize))
self.host = ''
self.port = -1
self.gameState = 'IDLE'
def __init__(self, iq):
self.ocean_fields = []
self._initialize_ocean_fields()
self.get_ships_placement()
# Create board.
self.board = Ocean(self.my_ships, self.ocean_fields)
self.intelligence = iq
def starting_positions_ships(self):
'''
Method to put starting coordinate on board
'''
ocean_player = Ocean()
os.system('clear')
print(ocean_player)
for key in self.player_ships:
print("Enter coordinates of" + " " + key)
print("(1) Horizontal\n(2) Vertical")
is_connect = True
while is_connect:
horizontal = input("Select direction:\n")
if horizontal == "1":
horizontal = True
elif horizontal == "2":
horizontal = False
else:
continue
numbers = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
position_x = input("Enter x position:")
while position_x not in numbers:
position_x = input("Enter x position:")
position_y = input("Enter y position:")
while position_y not in numbers:
position_y = input("Enter y position:")
position_x = int(position_x)
position_y = int(position_y)
positions = (position_x, position_y, self.player_ships[key],
horizontal)
if ocean_player.board[positions[1]][positions[0] -
1].is_empty is False:
print("WRONG CORDS!")
continue
else:
is_connect = False
self.starting_positions.append(positions)
os.system('clear')
ocean_player.preview_ships(*positions)
ocean_player.add_ships(*positions)
print(ocean_player)
return self.starting_positions
def main():
os.system('clear')
ocean1 = Ocean()
ocean2 = Ocean()
ocean1.format_board()
ocean2.format_board()
player1 = Player(ask_name('player1'), ocean1, ocean2)
player2 = Player(ask_name('player2'), ocean2, ocean1)
choose_all_ships(player1, ocean1)
choose_all_ships(player2, ocean2)
while True:
print("{} TURN".format(player1.name.upper()))
change_turns(player1)
print("{} TURN".format(player2.name.upper()))
change_turns(player2)
def create_game():
system("clear")
read_ascii('ship.csv')
players = determine_number_of_players()
player_name = ask_for_name()
ask_for_difficulty()
player_1st = Player(player_name)
player_2nd = Player("AI")
battlefield_1st = Ocean(player_1st)
battlefield_2nd = Ocean(player_2nd)
system("clear")
battlefield_1st.fill_board()
set_up_board(battlefield_1st, player_1st)
battlefield_2nd.fill_board()
set_up_board(battlefield_2nd, player_2nd)
return battlefield_1st, battlefield_2nd, player_1st, player_2nd, players
def __init__(self, name):
self.name = name
# Gets ship.
self.get_ships_placement()
self._initialize_ocean_fields()
# Create players board.
self.board = Ocean(self.my_ships, self.ocean_fields)
board_bar_len = self.board.__str__().split('\n')
# Ustawia długość belki do printów.
Player.board_row_len = len(board_bar_len[0])
def __init__(self, name):
"""
Constructs a *Player* object.
Parameters:
----------
name: str
enemy_ocean_representation: object
player_ocean: object
init_ships_dict: dict
sunken_ships: list
------
"""
self.name = name
self.enemy_ocean_representation = Ocean()
self.player_ocean = Ocean()
self.init_ships_dict()
self.sunken_ships = []
def set_simulation(self):
'''
Game computer - computer
Returns:
player_1, player_2 - Player object
'''
player_type = 'computer'
print('Setting computer player')
user_1 = 'computer'
player_1 = Player(user_1, Ocean())
player_1.generate_ships_for_computer(player_type)
print('Setting second computer player')
user_2 = 'computer_2'
player_2 = Player(user_2, Ocean())
player_2.generate_ships_for_computer(player_type)
return player_1, player_2
def set_multiplayers(self):
'''
Game player - player.
Returns:
player_1, player_2 - Player object
'''
player_type = 'human'
print('Setting First player')
user_1 = DataReader.input_player_name()
player_1 = Player(user_1, Ocean())
print('{} set you ships'.format(player_1.name))
player_1.get_ships_from_player(player_type)
print('Setting second player')
user_2 = DataReader.input_player_name()
player_2 = Player(user2, Ocean())
print('{} set you ships'.format(player_2.name))
player_2.get_ships_from_player(player_type)
return player_1, player_2
def generateOcean(self):
ocean = Ocean()
for shipTuple in sorted(Ship.ship_types.items(),
key=lambda x: x[1],
reverse=True):
ship_added = False
while not ship_added:
chosenY = random.randint(0, 9)
chosenX = random.randint(0, 9)
isVertical = bool(random.getrandbits(1))
ship = Ship(shipTuple[0], isVertical, chosenY, chosenX)
ship_added = ocean.insert_ship(ship)
return ocean
def set_single_players(self):
'''
Game player - computer. Set ships,
Returns:
player_1, player_2 - Player object
'''
player_type = 'human'
print('Setting First player')
user_1 = DataReader.input_player_name()
player_1 = Player(user_1, Ocean())
print('{} set you ships'.format(player_1.name))
player_1.get_ships_from_player(player_type)
player_type = 'computer'
print('Setting computer player')
user_2 = 'computer'
player_2 = Player(user_2, Ocean())
player_2.generate_ships_for_computer(player_type)
return player_1, player_2
def main():
os.system('clear')
display_intro_screen()
player1_name = input('Enter your name: ')
ocean1 = Ocean()
ocean1.load_board()
player1 = Player(player1_name, ocean1)
insert_ships_to_table(ocean1, player1)
print('Now player 2')
player2_name = input('Enter your name: ')
ocean2 = Ocean()
ocean2.load_board()
player2 = Player(player2_name, ocean2)
insert_ships_to_table(ocean2, player2)
os.system('clear')
input('Now its time to start the game! If you\'re ready press Enter: \n')
hide_squares(ocean1)
hide_squares(ocean2)
end_game = False
players_list = [[ocean1, player1], [ocean2, player2]]
rounds = 0
while not end_game:
attacker = players_list[rounds % 2]
deffender = players_list[abs((rounds % 2) - 1)]
os.system('clear')
print(attacker[1].name + ' is now shooting')
end_game = player_round(deffender[0], deffender[1])
rounds += 1
display_end_game_screen()
def run_up(self):
'''
Starting Game.
Returns:
None
'''
mode = self.choose_option()
ocean = Ocean()
player_1, player_2 = self.set_mode(mode)
present_player, next_player = self.choose_first_player(player_1, player_2)
winner, points = self.play_game(present_player, next_player)
self.end_game(winner, points)
def setupGrid(self, n, m, maxtheta=80, oceans=False, inputfile=None):
'''
Sets up the Tube's grid of parcels.
Args:
+ n, m (ints): the width and height of the grid. If inputfile is
provided, the input will be padded to match n and m if one is
greater than the provided dimensions, and if n and m are less
than the provided dimensions they will be ignored.
+ maxtheta (float): the maximum latitude (in degrees) to model to.
Default is 80.
+ oceans (bool): if True, will model oceans (default False). If
inputfile is provided, will read that in for the oceans (where
O's are considered oceans, X's landmasses, and spaces are
ignored.)
For example, if I had the file:
x x o
o x x
o o o
This would generate a 3x3 grid (provided n, m are equal to or
less than 3) with one landmass in cells (0,0), (0,1), (1,1),
and (1,2), with all other cells filled by oceans.
If m or n was larger than 3, the remaining cells would be
padded *by ocean objects*.
+ inputfile (str or None): if None (default) will randomly generate
oceans if oceans is True. If a string, will use that file per
the description above to generate a world.
NOTE: If inputfile is provided, it will override the value of
oceans and will assume oceans are to be generated.
'''
# Read in the inputfile if provided.
if inputfile is not None:
# Make sure inputfile is a string
assert isinstance(inputfile, str), "Infile must be None or" \
"a string"
# Read in the file
with open(inputfile, 'r') as infile:
m = 0
lines = []
# Doing it this way for ease of coding, not expensive anyways
for line in infile.readlines():
m += 1
n = 0
for char in line.strip().split():
if char.lower().strip() == 'x':
val = 1
else:
val = 0
lines.append(val)
n += 1
landgrid = np.array(lines)
elif oceans:
# Randomly generate ocean map
landgrid = np.random.randint(2, size=m * n)
else:
labdgrid = np.ones(m * n)
# Assign attributes
self.n = n # width
self.m = m # height
self.maxtheta = maxtheta # max latitude to use
self.deltheta = self.maxtheta / (0.5 * m) # theta resolution
self.npix = n * m
self.thetas = (np.ones([m, n]) *
np.linspace(maxtheta, -maxtheta, m)[:, np.newaxis])
self.Ls = abs(
np.sin((90 - self.thetas.reshape(self.npix)) * np.pi / 180 +
self.phi))
grid = []
for i, val in enumerate(landgrid):
if landgrid[i] == 1:
grid.append(
Parcel(self.P,
self.gamma,
self.a_vec,
self.A_vec,
self.Ls[i],
T_vec=self.T_vec))
else:
grid.append(Ocean(290))
self.grid = np.reshape(grid, (m, n))
fishAgent.y,
fishAgent.x - Ihm.AGENT_LENGTH * fishAgent.vx,
fishAgent.y - Ihm.AGENT_LENGTH * fishAgent.vy,
fill=fishAgent.color)
def draw(self):
self.canvas.delete(ALL)
for fish in self.environment.fishs:
self.drawFish(fish)
for obstacle in self.environment.obstacles:
self.drawObstacle(obstacle)
def update(self):
self.environment.update()
self.draw()
self.fen.after(25, self.update)
def addObstacle(self, event):
self.environment.addObstacle(event.x, event.y)
def drawObstacle(self, obstacle):
self.canvas.create_oval(obstacle.x,
obstacle.y,
obstacle.x + obstacle.radius,
obstacle.y + obstacle.radius,
fill='black')
ocean = Ocean(100, 500, 500)
ihm = Ihm(ocean)
fishAgent.y,
fishAgent.x - Ihm.AGENT_LENGTH * fishAgent.vx,
fishAgent.y - Ihm.AGENT_LENGTH * fishAgent.vy,
fill='blue')
def draw(self):
self.canvas.delete(ALL)
for fish in self.environment.fishs:
self.drawFish(fish)
for obstacle in self.environment.obstacles:
self.drawObstacle(obstacle)
def update(self):
self.environment.update()
self.draw()
self.fen.after(25, self.update)
def addObstacle(self, event):
self.environment.addObstacle(event.x, event.y)
def drawObstacle(self, obstacle):
self.canvas.create_oval(obstacle.x,
obstacle.y,
obstacle.x + obstacle.radius,
obstacle.y + obstacle.radius,
fill='black')
ocean = Ocean(20, 500, 500)
ihm = Ihm(ocean)
def __init__(self, name):
"""Creates Player object."""
self.name = name
self.player_ocean = Ocean()
self.enemy_ocean = Ocean()
self.canvas.pack()
self.fen = fen
self.canvas.bind_all("a", self.addFish) #attacher une touche
self.canvas.bind("<Button-3>", self.addFish) # attacher la souris
self.fen.after(1000, self.update) # lancer la boucle principale
self.fen.mainloop()
def addFish(self, event):
self.environment.addFish(event.x, event.y, random.random() * 2 * pi)
def drawFish(self, fishAgent):
self.canvas.create_line(fishAgent.x,
fishAgent.y,
fishAgent.x - Ihm.AGENT_LENGTH * fishAgent.vx,
fishAgent.y - Ihm.AGENT_LENGTH * fishAgent.vy,
fill='blue')
def draw(self):
self.canvas.delete(ALL)
for fish in self.environment.fishs:
self.drawFish(fish)
def update(self):
self.environment.update()
self.draw()
self.fen.after(25, self.update)
ocean = Ocean(10, 200, 200)
ihm = Ihm(ocean)
def main():
'''
Function for main menu, create ships, shooting - playing the game
Parameters:
-----------
chose_number = int
'''
os.system('clear')
main_menu()
chose_number = input("Enter number:\n")
if chose_number == '1':
os.system('clear')
new_player1 = input("Enter name of player 1:\n")
new_player2 = input("Enter name of player 2:\n")
ship1 = player.Player(new_player1)
new_ships1 = ship1.starting_positions_ships()
ocean_player1 = Ocean()
for s in new_ships1:
ocean_player1.add_ships(*s)
ship2 = player.Player(new_player2)
new_ships2 = ship2.starting_positions_ships()
ocean_player2 = Ocean()
for s in new_ships2:
ocean_player2.add_ships(*s)
os.system('clear')
print("GOOD LUCK")
while True:
turn = 1
while turn == 1:
radius = range(1, 11)
print("==================================")
print("Your ships", new_player1)
print("==================================")
print(ocean_player1)
shot = (int(input("Enter x:\n")), int(input("Enter y:\n")))
if shot[0] not in radius or shot[1] not in radius:
continue
os.system('clear')
ocean_player1.shot(shot[0], shot[1])
print(ocean_player1)
pauza = input()
os.system('clear')
turn = 2
while turn == 2:
radius = range(1, 11)
print("==================================")
print("Your ships", new_player2)
print("==================================")
print(ocean_player2)
shot = (int(input("Enter x:\n")), int(input("Enter y:\n")))
if shot[0] not in radius or shot[1] not in radius:
continue
os.system('clear')
ocean_player2.shot(shot[0], shot[1])
print(ocean_player2)
pauza = input()
os.system('clear')
break
else:
print('Wrong sign, try again')
def __init__(self, name):
self.name = name
self.ocean = Ocean()
def __init__(self):
self.ocean = Ocean()
def __init__(self, name, name2):
self.player = Player(name)
self.player2 = Player(name2)
self.board = Ocean()
self.board2 = Ocean()
self.canvas.pack()
self.fen = fen
self.canvas.bind_all("a", self.addFish) #attacher une touche
self.canvas.bind("<Button-3>", self.addFish) # attacher la souris
self.fen.after(1000, self.update) # lancer la boucle principale
self.fen.mainloop()
def addFish(self, event):
self.environment.addFish(event.x, event.y, random.random() * 2 * pi)
def drawFish(self, fishAgent):
self.canvas.create_line(fishAgent.x,
fishAgent.y,
fishAgent.x - Ihm.AGENT_LENGTH * fishAgent.vx,
fishAgent.y - Ihm.AGENT_LENGTH * fishAgent.vy,
fill='blue')
def draw(self):
self.canvas.delete(ALL)
for fish in self.environment.fishs:
self.drawFish(fish)
def update(self):
self.environment.update()
self.draw()
self.fen.after(25, self.update)
ocean = Ocean(100, 1000, 1000)
ihm = Ihm(ocean)
def __init__(self, name='computer'):
self.name = name
self.ocean = Ocean()
self.enemy_ocean = Ocean()
self.my_turn = False
