Морской бой. Проверка убитых кораблей

[XeNon_9_9]

Всем привет. Задача такова: дана матрица, в ней надо подсчитать сколько кораблей каждого типа было убито. Для обозначения 0 - ячейка пуста, 1 - нетронутый корабль и -1 - подбитый кораблей.
Пытаюсь как это решить, но что-то не выходит
Пока что проверяет только корабли, которые располагаются горизонтально и то, не очень-то и работает. Может кто-то подскажет как лучше это реализовать?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication2
{
    class Program
    {
 
        static bool[,] newPoint; //Копия матриы field. True - если уже был в этой клетке
        static int count = 0; //Какой тип корабля. Соотвествено 1 - однопалубный
        static int[] palub = { 0, 0, 0, 0 }; //Количество кораблей каждого типа(1 палоубного, 2-х и тд)
 
 
        //Рекурсивно проверяю следеющию клетку от заданной
        static bool CheckRight(int[,] field, int i, int j) 
        {
            if (field[i, j] == 0)
                return true;
            if (field[i, j] == 1)
                return false;
            if (j == field.GetLength(1))
                return true;
 
            newPoint[i, j] = true;
            count++;
 
            return CheckRight(field, i, j + 1);
        }
 
        static void Main(string[] args)
        {
            int[,] field = {
                                {-1, 1, 0, 0,-1, 0, 0, 1, 0, 0, },
                                { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, },
                                { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, },
                                { 0, 0,-1, 0, 0, 0, 1,-1,-1, 1, },
                                { 0, 0,-1, 0, 0, 0, 0, 0, 0, 0, },
                                {-1, 0, 0, 0,-1, 0, 0, 0, 0, 0, },
                                { 0, 0, 0, 0,-1, 0, 0, 0, 0, 0, },
                                { 0, 0, 0, 0,-1, 0, 0,-1, 0, 0, },
                                { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
                                { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
                            };
 
            newPoint = new bool[field.GetLength(0), field.GetLength(1)];
           
            for(int i = 0; i < field.GetLength(0) - 1; i++)
                for (int j = 0; j < field.GetLength(1) - 1; j++)
                {
                    //Если попалась ячейка с подбитым кораблем
                    //Проверяем не было ли до нее ячейки с 1
                    //Проверяем, что снизу и сверху 0
                    if (field[i, j] == -1)
                    {
                        if (j != 0 && i != 0 && i != field.GetLength(1))
                            if (field[i, j - 1] != 1 && field[i + 1, j] == 0 && field[i - 1, j] == 0)
                                if (CheckRight(field, i, j))
                                {
                                    palub[count - 1] += 1;
                                    count = 0;
                                }
 
                        if (i == 0 && j == 0)
                            if (field[i + 1, j] == 0)
                                if (CheckRight(field, i, j))
                                {
                                    palub[count - 1] += 1;
                                    count = 0;
                                }
 
                        if (i == field.GetLength(0) && j == 0)
                            if (field[i - 1, j] == 0)
                                if (CheckRight(field, i, j))
                                {
                                    palub[count - 1] += 1;
                                    count = 0;
                                }
 
                        if (i != 0 && j == 0)
                            if (field[i - 1, j] == 0 && field[i + 1, j] == 0 && field[i - 1, j] == 0)
                                if (CheckRight(field, i, j))
                                {
                                    palub[count - 1] += 1;
                                    count = 0;
                                }
 
                        if(i == 0 && j != 0)
                            if (field[i, j - 1] != 1 && field[i + 1, j] == 0)
                                if (CheckRight(field, i, j))
                                {
                                    palub[count - 1] += 1;
                                    count = 0;
                                }
                    }
 
                    
                }
        
        Console.ReadKey();
        
        }
    }
}

[SaheR]

Когда происходит попадание по какой-либо ячейке, то проверь 4 направления от неё. Где окажется значение, не равное 0, в ту сторону считай количество значений, отличающихся от 0. Учитывай, что может получиться, что проверку нужно будет делать в обе стороны. Если соседних ячеек, отличных от 0, нет - это однопалубник. В ином случае подсчет я выше описал.
Я вижу такой вариант проверки.