DO-31 fix : 쌍삼 예외사항 적용

Assets/Script/Renju/RenjuDoubleThreeDetector.cs

@@ -1,8 +1,25 @@
 using System.Collections.Generic;
 using UnityEngine;
 
-public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
+/// <summary>
+/// 렌주 쌍삼(3-3) 금수 판정을 위한 개선된 클래스
+/// 렌주 국제 규칙 9.3에 따라 쌍삼의 예외 상황까지 정확히 판별
+/// </summary>
+public class RenjuDoubleThreeDetector : ForbiddenDetectorBase
 {
+    // 열린 3 패턴 정보를 저장하는 구조체
+    private struct OpenThreeInfo
+    {
+        public int direction;       // 방향 인덱스
+        public List<Vector2Int> emptyPositions; // 빈 좌표들 (4를 만들 수 있는 위치)
+
+        public OpenThreeInfo(int dir)
+        {
+            direction = dir;
+            emptyPositions = new List<Vector2Int>();
+        }
+    }
+
     /// <summary>
     /// 쌍삼(3-3) 여부를 검사합니다.
     /// </summary>
@@ -15,36 +32,26 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
         // 임시로 돌 배치
         board[row, col] = Black;
 
-        // 쌍삼 검사
+        // 쌍삼 기본 검사 (열린 3이 2개 이상인지)
-        bool isDoubleThree = CheckDoubleThree(board, row, col);
+        List<OpenThreeInfo> openThrees = FindAllOpenThrees(board, row, col);
-
-        // 쌍삼으로 판정된 경우
-        if (isDoubleThree)
-        {
-            // 4가 만들어지는지 확인
-            bool hasFour = CheckForFour(board, row, col);
-
-            // 4-3 상황
-            if (hasFour)
-            {
-                isDoubleThree = false;
-            }
-        }
 
         // 원래 상태로 되돌림
         board[row, col] = Space;
 
-        return isDoubleThree;
+        // 열린 3이 2개 미만이면 쌍삼이 아님
+        if (openThrees.Count < 2)
+            return false;
+
+        // 렌주 규칙 9.3에 따른 예외 케이스 확인
+        return !CheckDoubleThreeExceptions(board, row, col, openThrees);
     }
 
-
-
     /// <summary>
-    /// 쌍삼(3-3) 여부를 검사합니다.
+    /// 모든 방향에서 열린 3을 찾아 반환합니다.
     /// </summary>
-    private bool CheckDoubleThree(Enums.PlayerType[,] board, int row, int col)
+    private List<OpenThreeInfo> FindAllOpenThrees(Enums.PlayerType[,] board, int row, int col)
     {
-        int openThreeCount = 0;
+        List<OpenThreeInfo> openThrees = new List<OpenThreeInfo>();
 
         // 4개의 방향 쌍에 대해 검사 (대각선 및 직선 포함)
         for (int i = 0; i < 4; i++)
@@ -52,29 +59,42 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
             int dir1 = DirectionPairs[i, 0];
             int dir2 = DirectionPairs[i, 1];
 
-            // 해당 방향에서 열린 3의 개수 계산
+            // 열린 3 정보 획득
-            if (CheckOpenThreeInDirection(board, row, col, dir1, dir2))
+            OpenThreeInfo threeInfo = new OpenThreeInfo(i);
+            if (FindOpenThreeInDirection(board, row, col, dir1, dir2, ref threeInfo))
             {
-                openThreeCount++;
+                openThrees.Add(threeInfo);
-
-                // 이미 열린 3이 2개 이상 발견되면 쌍삼으로 판정
-                // TODO : 44를 만들 수 있는가??
-                if (openThreeCount >= 2)
-                {
-                    return true;
-                }
             }
         }
 
+        return openThrees;
+    }
+
+    /// <summary>
+    /// 특정 방향에서 열린 3을 찾고 관련 정보를 채웁니다.
+    /// </summary>
+    private bool FindOpenThreeInDirection(Enums.PlayerType[,] board, int row, int col, int dir1, int dir2, ref OpenThreeInfo threeInfo)
+    {
+        // 라인 패턴 추출
+        Enums.PlayerType[] linePattern = ExtractLinePattern(board, row, col, dir1, dir2);
+        int centerIndex = 5; // 중앙 인덱스 (현재 위치)
+
+        // 연속된 열린 3 또는 한 칸 떨어진 열린 3 확인
+        if (FindConsecutiveOpenThree(linePattern, centerIndex, ref threeInfo, row, col, dir1, dir2) ||
+            FindGappedOpenThree(linePattern, centerIndex, ref threeInfo, row, col, dir1, dir2))
+        {
+            // 열린 3이 발견됨
+            return true;
+        }
+
         return false;
     }
 
     /// <summary>
-    /// 특정 방향에서 열린 3이 형성되는지 확인합니다.
+    /// 라인 패턴을 추출합니다.
     /// </summary>
-    private bool CheckOpenThreeInDirection(Enums.PlayerType[,] board, int row, int col, int dir1, int dir2)
+    private Enums.PlayerType[] ExtractLinePattern(Enums.PlayerType[,] board, int row, int col, int dir1, int dir2)
     {
-        // 각 방향으로 최대 5칸까지의 범위를 검사 (현재 위치 포함 총 11칸)
         Enums.PlayerType[] linePattern = new Enums.PlayerType[11];
         int centerIndex = 5; // 중앙 인덱스 (현재 위치)
 
@@ -93,7 +113,7 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
             }
             else
             {
-                linePattern[centerIndex + i] = White; // 범위 밖은 막힌 것으로 처리
+                linePattern[centerIndex + i] = White; // 범위 밖은 벽으로 처리하여 일관성 유지
             }
         }
 
@@ -109,33 +129,19 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
             }
             else
             {
-                linePattern[centerIndex - i] = White; // 범위 밖은 막힌 것으로 처리
+                linePattern[centerIndex - i] = White; // 범위 밖은 벽으로 처리하여 일관성 유지
             }
         }
 
-        // 열린 3 패턴 확인
+        return linePattern;
-        return CheckForOpenThree(linePattern, centerIndex);
     }
 
     /// <summary>
-    /// 라인 패턴에서 열린 3 패턴을 확인합니다.
+    /// 연속된 열린 3 패턴을 찾고 관련 정보를 채웁니다.
     /// </summary>
-    private bool CheckForOpenThree(Enums.PlayerType[] linePattern, int centerIndex)
+    private bool FindConsecutiveOpenThree(Enums.PlayerType[] linePattern, int centerIndex, ref OpenThreeInfo threeInfo, int row, int col, int dir1, int dir2)
     {
-
+        // 연속된 3개의 돌 패턴 (●●●)
-        // 둘다 아니면 열린 3이 아님
-        return CheckConsecutiveOpenThree(linePattern, centerIndex) || // 연속된 열린 3 확인
-                CheckGappedOpenThree(linePattern, centerIndex); // 한 칸 떨어진 열린 3 확인
-            // TODO : 한칸 떨어진 열린 3, 여기서 장목이 되는지 체크해서 배제 해야함
-    }
-
-    /// <summary>
-    /// 연속된 열린 3 패턴을 확인합니다.
-    /// </summary>
-    private bool CheckConsecutiveOpenThree(Enums.PlayerType[] linePattern, int centerIndex)
-    {
-        // 연속된 3개의 돌 패턴
-        // 시작 인덱스를 조정하여 센터가 패턴 내에 있는지 확인
         for (int start = centerIndex - 2; start <= centerIndex; start++)
         {
             // 범위 체크
@@ -170,6 +176,27 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
 
                     if (isExtendedLeftOpen && isExtendedRightOpen)
                     {
+                        // 4를 만들 수 있는 위치 저장
+                        if (isLeftOpen)
+                        {
+                            int leftRow = row + Directions[dir2, 0] * (centerIndex - (start - 1));
+                            int leftCol = col + Directions[dir2, 1] * (centerIndex - (start - 1));
+                            if (IsInBounds(leftRow, leftCol))
+                            {
+                                threeInfo.emptyPositions.Add(new Vector2Int(leftCol, leftRow));
+                            }
+                        }
+
+                        if (isRightOpen)
+                        {
+                            int rightRow = row + Directions[dir1, 0] * ((start + 3) - centerIndex);
+                            int rightCol = col + Directions[dir1, 1] * ((start + 3) - centerIndex);
+                            if (IsInBounds(rightRow, rightCol))
+                            {
+                                threeInfo.emptyPositions.Add(new Vector2Int(rightCol, rightRow));
+                            }
+                        }
+
                         return true;
                     }
                 }
@@ -180,15 +207,11 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
     }
 
     /// <summary>
-    /// 한 칸 떨어진 열린 3 패턴을 확인합니다.
+    /// 한 칸 떨어진 열린 3 패턴을 찾고 관련 정보를 채웁니다.
     /// </summary>
-    private bool CheckGappedOpenThree(Enums.PlayerType[] linePattern, int centerIndex)
+    private bool FindGappedOpenThree(Enums.PlayerType[] linePattern, int centerIndex, ref OpenThreeInfo threeInfo, int row, int col, int dir1, int dir2)
     {
-        // 한 칸 떨어진 패턴 확인
+        // 한 칸 떨어진 패턴 확인 (●●○● 또는 ●○●●)
-        // 패턴 1: ●●○● (centerIndex가 어느 위치든 가능)
-        // 패턴 2: ●○●● (centerIndex가 어느 위치든 가능)
-
-        // 윈도우 크기 4로 슬라이딩하면서 검사
         for (int start = Mathf.Max(0, centerIndex - 3); start <= Mathf.Min(linePattern.Length - 4, centerIndex); start++)
         {
             // 패턴 내에 돌과 빈칸 개수 확인
@@ -218,10 +241,46 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
             // 3개의 돌과 1개의 빈칸으로 구성된 패턴
             if (stoneCount == 3 && gapCount == 1)
             {
-                // 빈칸에 돌을 놓았을 때 열린 4가 되는지 확인
+                // 양쪽이 모두 열려있는지 확인
-                if (CheckIfCreatesOpenFour(linePattern, gapPosition))
+                bool isLeftOpen = (start - 1 >= 0) && (linePattern[start - 1] == Space);
+                bool isRightOpen = (start + 4 < linePattern.Length) && (linePattern[start + 4] == Space);
+
+                // 한쪽이라도 열려있으면 잠재적 열린 3
+                if (isLeftOpen || isRightOpen)
                 {
-                    return true;
+                    // 빈칸에 돌을 놓았을 때 열린 4가 되는지 확인
+                    if (CheckIfCreatesOpenFour(linePattern, gapPosition))
+                    {
+                        // 4를 만들 수 있는 위치 저장 (빈칸 위치)
+                        int gapRow = row;
+                        int gapCol = col;
+
+                        // 빈칸의 보드 좌표 계산
+                        int offset = gapPosition - centerIndex;
+                        if (offset > 0)
+                        {
+                            gapRow += Directions[dir1, 0] * offset;
+                            gapCol += Directions[dir1, 1] * offset;
+                        }
+                        else if (offset < 0)
+                        {
+                            gapRow += Directions[dir2, 0] * (-offset);
+                            gapCol += Directions[dir2, 1] * (-offset);
+                        }
+
+                        if (IsInBounds(gapRow, gapCol))
+                        {
+                            threeInfo.emptyPositions.Add(new Vector2Int(gapCol, gapRow));
+                        }
+
+                        // 장목이 되는지 확인 (장목이 되면 열린 3이 아님)
+                        if (CheckIfCreatesOverline(linePattern, gapPosition))
+                        {
+                            return false;
+                        }
+
+                        return true;
+                    }
                 }
             }
         }
@@ -229,6 +288,30 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
         return false;
     }
 
+    /// <summary>
+    /// 특정 방향으로 추가로 열려있는지 확인합니다.
+    /// </summary>
+    private bool IsExtendedOpen(Enums.PlayerType[] linePattern, int startPos, int direction)
+    {
+        // 한 칸 더 확장해서 확인
+        int nextPos = startPos + direction;
+        if (nextPos >= 0 && nextPos < linePattern.Length)
+        {
+            // 다음 칸이 상대 돌이나 벽이면 확장 불가
+            if (linePattern[nextPos] == White)
+            {
+                return false;
+            }
+        }
+        else
+        {
+            // 범위를 벗어나면 확장 불가
+            return false;
+        }
+
+        return true;
+    }
+
     /// <summary>
     /// 빈칸에 돌을 놓았을 때 열린 4가 되는지 확인합니다.
     /// </summary>
@@ -265,9 +348,9 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
                 bool isLeftOpen = (start - 1 >= 0) && (testPattern[start - 1] == Space);
                 bool isRightOpen = (start + 4 < testPattern.Length) && (testPattern[start + 4] == Space);
 
-                if (isLeftOpen && isRightOpen)
+                if (isLeftOpen || isRightOpen)
                 {
-                    return true; // 열린 4가 됨
+                    return true; // 열린 4나 반열린 4가 됨
                 }
             }
         }
@@ -276,42 +359,140 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
     }
 
     /// <summary>
-    /// 특정 방향으로 추가로 열려있는지 확인합니다.
+    /// 빈칸에 돌을 놓았을 때 장목(6목 이상)이 되는지 확인합니다.
     /// </summary>
-    private bool IsExtendedOpen(Enums.PlayerType[] linePattern, int startPos, int direction)
+    private bool CheckIfCreatesOverline(Enums.PlayerType[] linePattern, int position)
     {
-        // 한 칸 더 확장해서 확인
+        // 시뮬레이션: 빈칸에 돌을 놓아봄
-        int nextPos = startPos + direction;
+        Enums.PlayerType[] testPattern = new Enums.PlayerType[linePattern.Length];
-        if (nextPos >= 0 && nextPos < linePattern.Length)
+        System.Array.Copy(linePattern, testPattern, linePattern.Length);
+        testPattern[position] = Black;
+
+        // 놓은 위치 주변의 최대 연속 돌 수 계산
+        int maxLength = 1; // 놓은 돌 포함
+
+        // 오른쪽 방향 연속 돌 세기
+        for (int i = position + 1; i < testPattern.Length && testPattern[i] == Black; i++)
         {
-            // 다음 칸이 상대 돌이나 벽이면 확장 불가
+            maxLength++;
-            if (linePattern[nextPos] == White)
-            {
-                return false;
-            }
-        }
-        else
-        {
-            // 범위를 벗어나면 확장 불가
-            return false;
         }
 
-        return true;
+        // 왼쪽 방향 연속 돌 세기
+        for (int i = position - 1; i >= 0 && testPattern[i] == Black; i--)
+        {
+            maxLength++;
+        }
+
+        // 6목 이상이면 장목
+        return maxLength >= 6;
     }
 
     /// <summary>
-    /// 4가 만들어지는지 확인합니다.
+    /// 렌주 규칙 9.3에 따른 쌍삼 예외 케이스를 확인합니다.
     /// </summary>
-    private bool CheckForFour(Enums.PlayerType[,] board, int row, int col)
+    private bool CheckDoubleThreeExceptions(Enums.PlayerType[,] board, int row, int col, List<OpenThreeInfo> openThrees)
     {
-        // 4개의 방향 쌍에 대해 검사
+        // 예외 케이스 1: 하나의 삼만 열린 사가 될 수 있는 경우 (9.3 a항)
-        for (int i = 0; i < 4; i++)
+        bool canFormOpenFourWithoutDoubleFour = CheckExceptionCanFormOneFour(board, row, col, openThrees);
-        {
-            int dir1 = DirectionPairs[i, 0];
-            int dir2 = DirectionPairs[i, 1];
 
-            // 해당 방향에서 4가 형성되는지 확인
+        // 예외 케이스 2: 9.3 b항 (복잡한 연쇄 체크)
-            if (CheckFourInDirection(board, row, col, dir1, dir2))
+        bool isMeetExceptionB = CheckExceptionB(board, row, col, openThrees);
+
+        // 어느 하나라도 예외 조건을 만족하면 쌍삼이 아님
+        return canFormOpenFourWithoutDoubleFour || isMeetExceptionB;
+    }
+
+    /// <summary>
+    /// 예외 케이스 1: 하나의 삼만 열린 사가 될 수 있고 쌍사가 형성되지 않는 경우 (9.3 a항)
+    /// </summary>
+    private bool CheckExceptionCanFormOneFour(Enums.PlayerType[,] board, int row, int col, List<OpenThreeInfo> openThrees)
+    {
+        int canFormFourCount = 0;
+
+        // 각 열린 3에 대해, 4를 만들 수 있는지 확인
+        foreach (var threeInfo in openThrees)
+        {
+            foreach (var emptyPos in threeInfo.emptyPositions)
+            {
+                // 빈 위치에 돌을 놓았을 때 열린 4가 되는지 확인
+                board[emptyPos.y, emptyPos.x] = Black;
+
+                // 쌍사가 형성되는지 확인
+                bool formsDoubleFour = CheckDoubleFour(board, emptyPos.y, emptyPos.x);
+
+                // 원래 상태로 복원
+                board[emptyPos.y, emptyPos.x] = Space;
+
+                // 쌍사 없이 4를 만들 수 있으면 카운트 증가
+                if (!formsDoubleFour)
+                {
+                    canFormFourCount++;
+                    // 디버깅
+                    // Debug.Log($"Can form four at ({emptyPos.x}, {emptyPos.y}) without double four");
+                }
+            }
+        }
+
+        // 하나의 삼만 쌍사 없이 4로 만들 수 있는 경우
+        return canFormFourCount == 1;
+    }
+
+    /// <summary>
+    /// 예외 케이스 2: 9.3 b항의 복잡한 연쇄 체크
+    /// </summary>
+    private bool CheckExceptionB(Enums.PlayerType[,] board, int row, int col, List<OpenThreeInfo> openThrees)
+    {
+        // 이 부분은 매우 복잡한 렌주 규칙 9.3 b항을 구현해야 합니다.
+        // 기본적인 구현만 제공하며, 필요에 따라 확장 가능합니다.
+
+        // 각 열린 3에 대해, 4를 만들 때 다른 쌍삼이 형성되는지 확인
+        foreach (var threeInfo in openThrees)
+        {
+            bool canFormFourWithoutChainDoubleThree = false;
+
+            foreach (var emptyPos in threeInfo.emptyPositions)
+            {
+                // 빈 위치에 돌을 놓았을 때
+                board[emptyPos.y, emptyPos.x] = Black;
+
+                // 다른 쌍삼이 형성되는지 확인 (연쇄 체크)
+                bool formsOtherDoubleThree = false;
+
+                // 다른 모든 빈 위치에 대해 쌍삼 체크
+                for (int r = 0; r < BoardSize; r++)
+                {
+                    for (int c = 0; c < BoardSize; c++)
+                    {
+                        if (board[r, c] == Space)
+                        {
+                            // 임시로 돌 배치하여 쌍삼 체크
+                            board[r, c] = Black;
+                            bool isDoubleThree = CheckSimpleDoubleThree(board, r, c);
+                            board[r, c] = Space;
+
+                            if (isDoubleThree)
+                            {
+                                formsOtherDoubleThree = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (formsOtherDoubleThree) break;
+                }
+
+                // 원래 상태로 복원
+                board[emptyPos.y, emptyPos.x] = Space;
+
+                // 연쇄 쌍삼이 형성되지 않으면 예외 조건 만족
+                if (!formsOtherDoubleThree)
+                {
+                    canFormFourWithoutChainDoubleThree = true;
+                    break;
+                }
+            }
+
+            // 하나의 삼이라도 연쇄 쌍삼 없이 4를 만들 수 있으면 예외 조건 만족
+            if (canFormFourWithoutChainDoubleThree)
             {
                 return true;
             }
@@ -320,81 +501,152 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
         return false;
     }
 
+    /// <summary>
+    /// 단순 쌍삼 체크 (연쇄 검사용, 재귀 호출 방지)
+    /// </summary>
+    private bool CheckSimpleDoubleThree(Enums.PlayerType[,] board, int row, int col)
+    {
+        int openThreeCount = 0;
+
+        // 4개의 방향 쌍에 대해 검사
+        for (int i = 0; i < 4; i++)
+        {
+            int dir1 = DirectionPairs[i, 0];
+            int dir2 = DirectionPairs[i, 1];
+
+            // 간단한 열린 3 체크
+            if (CheckSimpleOpenThree(board, row, col, dir1, dir2))
+            {
+                openThreeCount++;
+                if (openThreeCount >= 2)
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// 단순 열린 3 체크 (연쇄 검사용)
+    /// </summary>
+    private bool CheckSimpleOpenThree(Enums.PlayerType[,] board, int row, int col, int dir1, int dir2)
+    {
+        Enums.PlayerType[] linePattern = ExtractLinePattern(board, row, col, dir1, dir2);
+        int centerIndex = 5;
+
+        // 연속된 열린 3 패턴 체크
+        for (int start = centerIndex - 2; start <= centerIndex; start++)
+        {
+            if (start < 0 || start + 2 >= linePattern.Length)
+            {
+                continue;
+            }
+
+            bool isConsecutiveThree = true;
+            for (int i = 0; i < 3; i++)
+            {
+                if (linePattern[start + i] != Black)
+                {
+                    isConsecutiveThree = false;
+                    break;
+                }
+            }
+
+            if (isConsecutiveThree)
+            {
+                bool isLeftOpen = (start - 1 >= 0) && (linePattern[start - 1] == Space);
+                bool isRightOpen = (start + 3 < linePattern.Length) && (linePattern[start + 3] == Space);
+
+                if (isLeftOpen && isRightOpen)
+                {
+                    return true;
+                }
+            }
+        }
+
+        // 한 칸 떨어진 열린 3 패턴 체크 (간단 구현)
+        for (int start = centerIndex - 3; start <= centerIndex; start++)
+        {
+            if (start < 0 || start + 3 >= linePattern.Length)
+            {
+                continue;
+            }
+
+            int stoneCount = 0;
+            int gapCount = 0;
+
+            for (int i = 0; i < 4; i++)
+            {
+                if (linePattern[start + i] == Black)
+                {
+                    stoneCount++;
+                }
+                else if (linePattern[start + i] == Space)
+                {
+                    gapCount++;
+                }
+                else
+                {
+                    stoneCount = 0;
+                    break;
+                }
+            }
+
+            if (stoneCount == 3 && gapCount == 1)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// 쌍사 여부를 확인합니다 (예외 처리용)
+    /// </summary>
+    private bool CheckDoubleFour(Enums.PlayerType[,] board, int row, int col)
+    {
+        int fourCount = 0;
+
+        // 4개의 방향 쌍에 대해 검사
+        for (int i = 0; i < 4; i++)
+        {
+            int dir1 = DirectionPairs[i, 0];
+            int dir2 = DirectionPairs[i, 1];
+
+            if (CheckFourInDirection(board, row, col, dir1, dir2))
+            {
+                fourCount++;
+                if (fourCount >= 2)
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     /// <summary>
     /// 특정 방향에서 4가 형성되는지 확인합니다.
-    /// 떨어져 있는 돌도 고려합니다 (한 칸 또는 두 칸 떨어진 패턴 포함).
     /// </summary>
     private bool CheckFourInDirection(Enums.PlayerType[,] board, int row, int col, int dir1, int dir2)
     {
-        // 각 방향으로 최대 5칸까지의 범위를 검사 (현재 위치 포함 총 11칸)
         Enums.PlayerType[] linePattern = ExtractLinePattern(board, row, col, dir1, dir2);
-        int centerIndex = 5; // 중앙 인덱스 (현재 위치)
+        int centerIndex = 5;
 
-        // 모든 가능한 패턴 확인
+        // 윈도우 슬라이딩으로 연속된 4를 검사
-        return CheckFourOneGap(linePattern, centerIndex);
+        for (int start = 0; start <= 7; start++)
-    }
-
-    /// <summary>
-    /// 라인 패턴을 추출합니다. (중복 코드를 방지하기 위한 헬퍼 메서드)
-    /// </summary>
-    private Enums.PlayerType[] ExtractLinePattern(Enums.PlayerType[,] board, int row, int col, int dir1, int dir2)
-    {
-        Enums.PlayerType[] linePattern = new Enums.PlayerType[11];
-        int centerIndex = 5; // 중앙 인덱스 (현재 위치)
-
-        // 현재 위치 설정
-        linePattern[centerIndex] = Black;
-
-        // dir1 방향으로 패턴 채우기
-        for (int i = 1; i <= 5; i++)
-        {
-            int newRow = row + Directions[dir1, 0] * i;
-            int newCol = col + Directions[dir1, 1] * i;
-
-            if (IsInBounds(newRow, newCol))
-            {
-                linePattern[centerIndex + i] = board[newRow, newCol];
-            }
-            else
-            {
-                linePattern[centerIndex + i] = Space; // 범위 밖은 빈칸으로 처리
-            }
-        }
-
-        // dir2 방향으로 패턴 채우기
-        for (int i = 1; i <= 5; i++)
-        {
-            int newRow = row + Directions[dir2, 0] * i;
-            int newCol = col + Directions[dir2, 1] * i;
-
-            if (IsInBounds(newRow, newCol))
-            {
-                linePattern[centerIndex - i] = board[newRow, newCol];
-            }
-            else
-            {
-                linePattern[centerIndex - i] = Space; // 범위 밖은 빈칸으로 처리
-            }
-        }
-
-        return linePattern;
-    }
-
-    /// <summary>
-    /// 한 칸 떨어진 4 패턴을 확인합니다.
-    /// </summary>
-    private bool CheckFourOneGap(Enums.PlayerType[] linePattern, int centerIndex)
-    {
-        // 윈도우 슬라이딩으로 연속된 5칸을 검사 (한 칸 떨어진 패턴을 위해)
-        for (int start = 0; start <= 5; start++)
         {
             // 현재 위치가 이 윈도우에 포함되는지 확인
-            bool currentPositionInWindow = (start <= centerIndex && centerIndex < start + 5);
+            bool currentPositionInWindow = (start <= centerIndex && centerIndex < start + 4);
             if (!currentPositionInWindow) continue;
 
             // 윈도우 내의 돌 개수 세기
             int stoneCount = 0;
-            for (int i = 0; i < 5; i++)
+            for (int i = 0; i < 4; i++)
             {
                 if (linePattern[start + i] == Black)
                 {
@@ -402,8 +654,7 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
                 }
             }
 
-            // 정확히 4개의 돌이 있고, 1개의 빈칸이 있으면 4로 판정
+            // 4개의 돌이 있으면 4로 판정
-            // (현재 위치는 흑으로 이미 설정되어 있음)
             if (stoneCount == 4)
             {
                 return true;

Assets/Trash Can_JY/Renju.unity

@@ -308,6 +308,10 @@ PrefabInstance:
       propertyPath: m_Name
       value: Canvas
       objectReference: {fileID: 0}
+    - target: {fileID: 1250546304786973426, guid: 65aac0e22fe25aa42b9cf7df776a854d, type: 3}
+      propertyPath: m_AnchoredPosition.x
+      value: 0
+      objectReference: {fileID: 0}
     - target: {fileID: 6113787613246818512, guid: 65aac0e22fe25aa42b9cf7df776a854d, type: 3}
       propertyPath: m_Pivot.x
       value: 0