загружаю код с дз 0 с восстановительного урока

HNS/Excercises/ShipCraft/Переделка/ShipDirection.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class ShipDirection(Enum):
+    VERTICAL = 0
+    HORIZONTAL = 1
+    UNKNOWN = -1

HNS/Excercises/ShipCraft/Переделка/ShipField.py

@@ -1,5 +1,6 @@
 from ShootResult import ShootResult
-from ShipModeDirection import ShipDirection, ShipMode
+from ShipDirection import ShipDirection
+from ShipMode import ShipMode
 
 
 class ShipField:
@@ -18,9 +19,9 @@ class ShipField:
 
         self.ships = [4, 3, 3, 2, 2, 2, 1, 1, 1, 1]
         self.field_size = 10
-        self.field_mode = ShipMode.PUT.value
+        self.field_mode = ShipMode.PUT
         self.ship_size = 4
-        self.ship_direction = ShipDirection.VERTICAL.value
+        self.ship_direction = ShipDirection.VERTICAL
 
     def __getitem__(self, item):
         if item is None:
@@ -37,31 +38,34 @@ class ShipField:
     def action(self, row, col):
         self.clear_marker()
 
-        if self.field_mode == ShipMode.PUT.value:
+        if self.field_mode == ShipMode.PUT:
-            if self.ship_size in self.ships and self.check_possible(row, col):
+            if self.check_ship(row, col):
+                self.get_ship(row, col)
+
+            elif self.ship_size in self.ships and self.check_possible(row, col):
                 self.set_ship(row, col)
 
-        elif self.field_mode == ShipMode.SHOOT.value:
+        elif self.field_mode == ShipMode.SHOOT:
             self.shoot(row, col)
 
     def target(self, row, col):
         self.clear_marker()
 
-        if self.field_mode == ShipMode.PUT.value:
+        if self.field_mode == ShipMode.PUT:
             if self.check_possible(row, col):
-                if self.ship_direction == ShipDirection.VERTICAL.value:
+                if self.ship_direction == ShipDirection.VERTICAL:
                     for r in range(row, row + self.ship_size):
                         if self.ship_size in self.ships:
                             self.field[r * self.field_size + col] = "p"
                         else:
                             self.field[r * self.field_size + col] = "r"
 
-                if self.ship_direction == ShipDirection.HORIZONTAL.value:
+                if self.ship_direction == ShipDirection.HORIZONTAL:
                     for c in range(col, col + self.ship_size):
                         if self.ship_size in self.ships:
                             self.field[row * self.field_size + c] = "p"
                         else:
-                            self.field[r * self.field_size + col] = "r"
+                            self.field[row * self.field_size + c] = "r"
         else:
             self.field[row * self.field_size + col] += "+"
 
@@ -79,13 +83,13 @@ class ShipField:
         if col < 0 or col > self.field_size:
             return
         index = row * self.field_size + col
-        if self.ship_direction == ShipDirection.VERTICAL.value:
+        if self.ship_direction == ShipDirection.VERTICAL:
             if self.field_size - row < self.ship_size:
                 return
             for r in range(row, row + self.ship_size):
                 index = r * self.field_size + col
                 self.field[index] = "1"
-        if self.ship_direction == ShipDirection.HORIZONTAL.value:
+        if self.ship_direction == ShipDirection.HORIZONTAL:
             if self.field_size - col < self.ship_size:
                 return
             for c in range(col, col + self.ship_size):
@@ -96,6 +100,56 @@ class ShipField:
             self.ships.remove(self.ship_size)
         self.print_field()
 
+    def get_ship(self, row, col):
+        if row < 0 or row > self.field_size:
+            return
+        if col < 0 or col > self.field_size:
+            return
+
+        self.field[row * self.field_size + col] = ""
+
+        ship_size = 1
+        ship_direction = ShipDirection.UNKNOWN
+
+        # проверим вертикаль
+        for r in range(row + 1, self.field_size):
+            if self.check_ship(r, col):
+                ship_size += 1
+                ship_direction = ShipDirection.VERTICAL
+                self.field[r * self.field_size + col] = ""
+            else:
+                break
+
+        for r in range(row - 1, -1, -1):
+            if self.check_ship(r, col):
+                ship_size += 1
+                ship_direction = ShipDirection.VERTICAL
+                self.field[row * self.field_size + col] = ""
+            else:
+                break
+
+        if ship_direction == ShipDirection.UNKNOWN:
+
+        # проверим горизонталь
+            for c in range(col + 1, self.field_size):
+                if self.check_ship(row, c):
+                    ship_size += 1
+                    ship_direction = ShipDirection.HORIZONTAL
+                    self.field[row * self.field_size + c] = ""
+                else:
+                    break
+
+            for c in range(col - 1, -1, -1):
+                if self.check_ship(row, c):
+                    ship_size += 1
+                    ship_direction = ShipDirection.HORIZONTAL
+                    self.field[row * self.field_size + c] = ""
+                else:
+                    break
+        self.set_ship_direction(ship_direction)
+        self.set_ship_size(ship_size)
+        self.ships.append(ship_size)
+
     def shoot(self, row, col):
         if row < 0 or row > self.field_size - 1:
             return ShootResult.UNDEFINED
@@ -111,10 +165,18 @@ class ShipField:
         else:
             return ShootResult.UNDEFINED
 
+
+
+    def check_ship(self, row, col):
+    #функция должна возвражать тру, если в заданной клетке есть корабль
+    # в противном случае фолс
+        return self.field[row * self.field_size + col].strip() == "1"
+
+
     def check_possible(self, row, col):
         # Функция должна возвращать True, если можно поставить сюда корабль,
         # в противном случае - False
-        if self.ship_direction == ShipDirection.VERTICAL.value:
+        if self.ship_direction == ShipDirection.VERTICAL:
             # Здесь мы знаем, что корабль помещается на поле.
             if self.field_size - row >= self.ship_size:
                 # Теперь нужно проверить, не заблокировано ли какое-то из полей,
@@ -123,7 +185,7 @@ class ShipField:
                         return False
                 return True
 
-        if self.ship_direction == ShipDirection.HORIZONTAL.value:
+        if self.ship_direction == ShipDirection.HORIZONTAL:
             if self.field_size - col >= self.ship_size:
                 for c in range(col, col + self.ship_size):
                     if not self.check_blocked(row, c):
@@ -157,23 +219,24 @@ class ShipField:
         if value is None:
             return
 
-        if type(value) is str and value.isnumeric():
+        if type(value) is not ShipDirection:
-            value = int(value)
+            return
 
-        if type(value) is int and ShipDirection.VERTICAL.value <= value <= ShipDirection.HORIZONTAL.value:
+        if value != ShipDirection.UNKNOWN:
             self.ship_direction = value
 
+
     def toggle_ship_direction(self):
-        if self.ship_direction == ShipDirection.VERTICAL.value:
+        if self.ship_direction == ShipDirection.VERTICAL:
-            self.ship_direction = ShipDirection.HORIZONTAL.value
+            self.ship_direction = ShipDirection.HORIZONTAL
         else:
-            self.ship_direction = ShipDirection.VERTICAL.value
+            self.ship_direction = ShipDirection.VERTICAL
 
     def toggle_field_mode(self):
-        if self.field_mode == ShipMode.PUT.value:
+        if self.field_mode == ShipMode.PUT:
-            self.field_mode = ShipMode.SHOOT.value
+            self.field_mode = ShipMode.SHOOT
         else:
-            self.field_mode = ShipMode.PUT.value
+            self.field_mode = ShipMode.PUT
 
     def print_field(self):
         print(self.ships)

HNS/Excercises/ShipCraft/Переделка/ShipMode.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ShipMode(Enum):
+    PUT = 0
+    SHOOT = 1
+
+
+
+

HNS/Excercises/ShipCraft/Переделка/ShipModeDirection.py

@@ -1,14 +0,0 @@
-from enum import Enum
-
-
-class ShipMode(Enum):
-    PUT = 0
-    SHOOT = 1
-
-
-class ShipDirection(Enum):
-    VERTICAL = 0
-    HORIZONTAL = 1
-
-
-print(ShipDirection.VERTICAL.value)

HNS/Excercises/ShipCraft/Переделка/Test.py

@@ -1,6 +1,7 @@
 from ShipField import ShipField
 
 
+
 def verify_value(actual, expected):
     if actual == expected:
         print("OK")

HNS/Excercises/ShipCraft/Переделка/test_ShipField.py

@@ -1,7 +1,8 @@
 from unittest import TestCase
 from ShipField import ShipField
 from ShootResult import ShootResult
-from ShipModeDirection import ShipDirection, ShipMode
+from ShipMode import ShipMode
+from ShipDirection import ShipDirection
 
 
 class TestShipField(TestCase):
@@ -46,13 +47,13 @@ class TestShipField(TestCase):
 
     def test_toggle_field_mode(self):
         ship_field = ShipField()  # Заводим объект типа ShipField
-        self.assertEqual(ship_field.field_mode, 0)  # Проверяем, что изначальное значение field_mode равно 0
+        self.assertEqual(ship_field.field_mode, ShipMode.PUT)  # Проверяем, что изначальное значение field_mode равно 0
 
         ship_field.toggle_field_mode()  # Вызываем метод, который тестируем
-        self.assertEqual(ship_field.field_mode, 1)  # Проверяем, что field_mode принял желаемое значение
+        self.assertEqual(ship_field.field_mode, ShipMode.SHOOT)  # Проверяем, что field_mode принял желаемое значение
 
         ship_field.toggle_field_mode()  # Вызываем метод, который тестируем
-        self.assertEqual(ship_field.field_mode, 0)  # Проверяем, что field_mode принял желаемое значение
+        self.assertEqual(ship_field.field_mode, ShipMode.PUT)  # Проверяем, что field_mode принял желаемое значение
 
     def test_action(self):
         self.fail()
@@ -67,7 +68,8 @@ class TestShipField(TestCase):
         ship_field.field[ship_field.field_size - 4] = 'r'
         ship_field.clear_marker()
 
-        self.assertNotIn('p' or 'r', ship_field.field)
+        self.assertNotIn('p', ship_field.field)
+        self.assertNotIn('r', ship_field.field)
 
     def test_shoot_empty(self):
         ship_field = ShipField()
@@ -115,11 +117,11 @@ class TestShipField(TestCase):
         new_field_string = str.join(' ', ship_field.field)
         self.assertEqual(new_field_string, old_field_string)
 
-    def test_check_possible(self):
+    def test_check_possible_false(self):
         # arrangement установка
         ship_field = ShipField()
         ship_field.set_ship_size(4)
-        ship_field.set_ship_direction(ShipDirection.HORIZONTAL.value)
+        ship_field.set_ship_direction(ShipDirection.HORIZONTAL)
         # action действие
         ship_field.set_ship(5, 3)
         # assertion проверка занятых
@@ -132,17 +134,37 @@ class TestShipField(TestCase):
         self.assertEqual(ship_field.check_possible(6, 4), False)
         self.assertEqual(ship_field.check_possible(6, 5), False)
         self.assertEqual(ship_field.check_possible(6, 6), False)
+        # проверка строки выше
+        self.assertEqual(ship_field.check_possible(4, 3), False)
+        self.assertEqual(ship_field.check_possible(4, 4), False)
+        self.assertEqual(ship_field.check_possible(4, 5), False)
+        self.assertEqual(ship_field.check_possible(4, 6), False)
+
+    def test_check_possible_true(self):
+        # arrangement установка
+        ship_field = ShipField()
+        ship_field.set_ship_size(4)
+        ship_field.set_ship_direction(ShipDirection.HORIZONTAL)
+        # action действие
+        ship_field.set_ship(5, 3)
+
         # проверка свободных ниже на 2 строки
         self.assertEqual(ship_field.check_possible(7, 3), True)
         self.assertEqual(ship_field.check_possible(7, 4), True)
         self.assertEqual(ship_field.check_possible(7, 5), True)
         self.assertEqual(ship_field.check_possible(7, 6), True)
+        # проверка свободных ВЫШЕ на 2 строки
+        self.assertEqual(ship_field.check_possible(3, 3), True)
+        self.assertEqual(ship_field.check_possible(3, 4), True)
+        self.assertEqual(ship_field.check_possible(3, 5), True)
+        self.assertEqual(ship_field.check_possible(3, 6), True)
+
 
     def test_check_blocked(self):
         # arrangement установка
         ship_field = ShipField()
         ship_field.set_ship_size(4)
-        ship_field.set_ship_direction(1)
+        ship_field.set_ship_direction(ShipDirection.HORIZONTAL)
         # action действие
         ship_field.set_ship(5, 3)
         # assertion проверка занятых
@@ -163,46 +185,46 @@ class TestShipField(TestCase):
 
     def test_set_ship_direction(self):
         ship_field = ShipField()  # Заводим объект типа ShipField
-        ship_field.set_ship_direction(1)
+        ship_field.set_ship_direction(ShipDirection.HORIZONTAL)
-        self.assertEqual(ship_field.ship_direction, 1)
+        self.assertEqual(ship_field.ship_direction, ShipDirection.HORIZONTAL)
 
-        ship_field.set_ship_direction(0)
+        ship_field.set_ship_direction(ShipDirection.VERTICAL)
-        self.assertEqual(ship_field.ship_direction, 0)
+        self.assertEqual(ship_field.ship_direction, ShipDirection.VERTICAL)
 
     def test_set_ship_direction_outofrange(self):
         ship_field = ShipField()  # Заводим объект типа ShipField
-        ship_field.set_ship_direction(1)
+        ship_field.set_ship_direction(ShipDirection.HORIZONTAL)
 
         ship_field.set_ship_direction(-1)
         ship_field.set_ship_direction(2)
-        self.assertEqual(ship_field.ship_direction, 1)
+        self.assertEqual(ship_field.ship_direction, ShipDirection.HORIZONTAL)
 
     def test_set_ship_direction_wrongtype(self):
         ship_field = ShipField()  # Заводим объект типа ShipField
-        ship_field.set_ship_direction(1)
+        ship_field.set_ship_direction(ShipDirection.HORIZONTAL)
 
         ship_field.set_ship_direction(None)
         ship_field.set_ship_direction([2])
         ship_field.set_ship_direction({})
-        self.assertEqual(ship_field.ship_direction, 1)
+        self.assertEqual(ship_field.ship_direction, ShipDirection.HORIZONTAL)
 
     def test_toggle_ship_direction(self):
         # arrangement установка
         ship_field = ShipField()
-        ship_field.set_ship_direction(0)
+        ship_field.set_ship_direction(ShipDirection.VERTICAL)
         # action действие
         ship_field.toggle_ship_direction()
         # assertion проверка
-        self.assertEqual(ship_field.ship_direction, 1)
+        self.assertEqual(ship_field.ship_direction, ShipDirection.HORIZONTAL)
 
         ship_field.toggle_ship_direction()
-        self.assertEqual(ship_field.ship_direction, 0)
+        self.assertEqual(ship_field.ship_direction, ShipDirection.VERTICAL)
 
     def test_set_ship(self):
         # arrangement установка
         ship_field = ShipField()
         ship_field.set_ship_size(4)
-        ship_field.set_ship_direction(1)
+        ship_field.set_ship_direction(ShipDirection.HORIZONTAL)
         # action действие
         ship_field.set_ship(5, 3)
         # assertion проверка
@@ -215,7 +237,7 @@ class TestShipField(TestCase):
         # arrangement установка
         ship_field = ShipField()
         ship_field.set_ship_size(4)
-        ship_field.set_ship_direction(0)
+        ship_field.set_ship_direction(ShipDirection.VERTICAL)
         old_field_string = str.join(" ", ship_field.field)
         # action действие
         ship_field.set_ship(7, 3)