diff --git a/Assets/Script/Renju/RenjuDoubleThreeDetector.cs b/Assets/Script/Renju/RenjuDoubleThreeDetector.cs
index 5a7b5d1..1befe0d 100644
--- a/Assets/Script/Renju/RenjuDoubleThreeDetector.cs
+++ b/Assets/Script/Renju/RenjuDoubleThreeDetector.cs
@@ -1,8 +1,25 @@
using System.Collections.Generic;
using UnityEngine;
-public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
+///
+/// 렌주 쌍삼(3-3) 금수 판정을 위한 개선된 클래스
+/// 렌주 국제 규칙 9.3에 따라 쌍삼의 예외 상황까지 정확히 판별
+///
+public class RenjuDoubleThreeDetector : ForbiddenDetectorBase
{
+ // 열린 3 패턴 정보를 저장하는 구조체
+ private struct OpenThreeInfo
+ {
+ public int direction; // 방향 인덱스
+ public List emptyPositions; // 빈 좌표들 (4를 만들 수 있는 위치)
+
+ public OpenThreeInfo(int dir)
+ {
+ direction = dir;
+ emptyPositions = new List();
+ }
+ }
+
///
/// 쌍삼(3-3) 여부를 검사합니다.
///
@@ -15,36 +32,26 @@ public class RenjuDoubleThreeDetector: ForbiddenDetectorBase
// 임시로 돌 배치
board[row, col] = Black;
- // 쌍삼 검사
- bool isDoubleThree = CheckDoubleThree(board, row, col);
-
- // 쌍삼으로 판정된 경우
- if (isDoubleThree)
- {
- // 4가 만들어지는지 확인
- bool hasFour = CheckForFour(board, row, col);
-
- // 4-3 상황
- if (hasFour)
- {
- isDoubleThree = false;
- }
- }
+ // 쌍삼 기본 검사 (열린 3이 2개 이상인지)
+ List openThrees = FindAllOpenThrees(board, row, col);
// 원래 상태로 되돌림
board[row, col] = Space;
- return isDoubleThree;
+ // 열린 3이 2개 미만이면 쌍삼이 아님
+ if (openThrees.Count < 2)
+ return false;
+
+ // 렌주 규칙 9.3에 따른 예외 케이스 확인
+ return !CheckDoubleThreeExceptions(board, row, col, openThrees);
}
-
-
///
- /// 쌍삼(3-3) 여부를 검사합니다.
+ /// 모든 방향에서 열린 3을 찾아 반환합니다.
///
- private bool CheckDoubleThree(Enums.PlayerType[,] board, int row, int col)
+ private List FindAllOpenThrees(Enums.PlayerType[,] board, int row, int col)
{
- int openThreeCount = 0;
+ List openThrees = new List();
// 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의 개수 계산
- if (CheckOpenThreeInDirection(board, row, col, dir1, dir2))
+ // 열린 3 정보 획득
+ OpenThreeInfo threeInfo = new OpenThreeInfo(i);
+ if (FindOpenThreeInDirection(board, row, col, dir1, dir2, ref threeInfo))
{
- openThreeCount++;
-
- // 이미 열린 3이 2개 이상 발견되면 쌍삼으로 판정
- // TODO : 44를 만들 수 있는가??
- if (openThreeCount >= 2)
- {
- return true;
- }
+ openThrees.Add(threeInfo);
}
}
+ return openThrees;
+ }
+
+ ///
+ /// 특정 방향에서 열린 3을 찾고 관련 정보를 채웁니다.
+ ///
+ 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;
}
///
- /// 특정 방향에서 열린 3이 형성되는지 확인합니다.
+ /// 라인 패턴을 추출합니다.
///
- 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 CheckForOpenThree(linePattern, centerIndex);
+ return linePattern;
}
///
- /// 라인 패턴에서 열린 3 패턴을 확인합니다.
+ /// 연속된 열린 3 패턴을 찾고 관련 정보를 채웁니다.
///
- 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이 아님
- return CheckConsecutiveOpenThree(linePattern, centerIndex) || // 연속된 열린 3 확인
- CheckGappedOpenThree(linePattern, centerIndex); // 한 칸 떨어진 열린 3 확인
- // TODO : 한칸 떨어진 열린 3, 여기서 장목이 되는지 체크해서 배제 해야함
- }
-
- ///
- /// 연속된 열린 3 패턴을 확인합니다.
- ///
- private bool CheckConsecutiveOpenThree(Enums.PlayerType[] linePattern, int centerIndex)
- {
- // 연속된 3개의 돌 패턴
- // 시작 인덱스를 조정하여 센터가 패턴 내에 있는지 확인
+ // 연속된 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
}
///
- /// 한 칸 떨어진 열린 3 패턴을 확인합니다.
+ /// 한 칸 떨어진 열린 3 패턴을 찾고 관련 정보를 채웁니다.
///
- 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;
}
+ ///
+ /// 특정 방향으로 추가로 열려있는지 확인합니다.
+ ///
+ 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;
+ }
+
///
/// 빈칸에 돌을 놓았을 때 열린 4가 되는지 확인합니다.
///
@@ -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
}
///
- /// 특정 방향으로 추가로 열려있는지 확인합니다.
+ /// 빈칸에 돌을 놓았을 때 장목(6목 이상)이 되는지 확인합니다.
///
- private bool IsExtendedOpen(Enums.PlayerType[] linePattern, int startPos, int direction)
+ private bool CheckIfCreatesOverline(Enums.PlayerType[] linePattern, int position)
{
- // 한 칸 더 확장해서 확인
- int nextPos = startPos + direction;
- if (nextPos >= 0 && nextPos < linePattern.Length)
+ // 시뮬레이션: 빈칸에 돌을 놓아봄
+ Enums.PlayerType[] testPattern = new Enums.PlayerType[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++)
{
- // 다음 칸이 상대 돌이나 벽이면 확장 불가
- if (linePattern[nextPos] == White)
- {
- return false;
- }
- }
- else
- {
- // 범위를 벗어나면 확장 불가
- return false;
+ maxLength++;
}
- return true;
+ // 왼쪽 방향 연속 돌 세기
+ for (int i = position - 1; i >= 0 && testPattern[i] == Black; i--)
+ {
+ maxLength++;
+ }
+
+ // 6목 이상이면 장목
+ return maxLength >= 6;
}
///
- /// 4가 만들어지는지 확인합니다.
+ /// 렌주 규칙 9.3에 따른 쌍삼 예외 케이스를 확인합니다.
///
- private bool CheckForFour(Enums.PlayerType[,] board, int row, int col)
+ private bool CheckDoubleThreeExceptions(Enums.PlayerType[,] board, int row, int col, List openThrees)
{
- // 4개의 방향 쌍에 대해 검사
- for (int i = 0; i < 4; i++)
- {
- int dir1 = DirectionPairs[i, 0];
- int dir2 = DirectionPairs[i, 1];
+ // 예외 케이스 1: 하나의 삼만 열린 사가 될 수 있는 경우 (9.3 a항)
+ bool canFormOpenFourWithoutDoubleFour = CheckExceptionCanFormOneFour(board, row, col, openThrees);
- // 해당 방향에서 4가 형성되는지 확인
- if (CheckFourInDirection(board, row, col, dir1, dir2))
+ // 예외 케이스 2: 9.3 b항 (복잡한 연쇄 체크)
+ bool isMeetExceptionB = CheckExceptionB(board, row, col, openThrees);
+
+ // 어느 하나라도 예외 조건을 만족하면 쌍삼이 아님
+ return canFormOpenFourWithoutDoubleFour || isMeetExceptionB;
+ }
+
+ ///
+ /// 예외 케이스 1: 하나의 삼만 열린 사가 될 수 있고 쌍사가 형성되지 않는 경우 (9.3 a항)
+ ///
+ private bool CheckExceptionCanFormOneFour(Enums.PlayerType[,] board, int row, int col, List 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;
+ }
+
+ ///
+ /// 예외 케이스 2: 9.3 b항의 복잡한 연쇄 체크
+ ///
+ private bool CheckExceptionB(Enums.PlayerType[,] board, int row, int col, List 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;
}
+ ///
+ /// 단순 쌍삼 체크 (연쇄 검사용, 재귀 호출 방지)
+ ///
+ 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;
+ }
+
+ ///
+ /// 단순 열린 3 체크 (연쇄 검사용)
+ ///
+ 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;
+ }
+
+ ///
+ /// 쌍사 여부를 확인합니다 (예외 처리용)
+ ///
+ 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;
+ }
+
///
/// 특정 방향에서 4가 형성되는지 확인합니다.
- /// 떨어져 있는 돌도 고려합니다 (한 칸 또는 두 칸 떨어진 패턴 포함).
///
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;
- // 모든 가능한 패턴 확인
- return CheckFourOneGap(linePattern, centerIndex);
- }
-
- ///
- /// 라인 패턴을 추출합니다. (중복 코드를 방지하기 위한 헬퍼 메서드)
- ///
- 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;
- }
-
- ///
- /// 한 칸 떨어진 4 패턴을 확인합니다.
- ///
- private bool CheckFourOneGap(Enums.PlayerType[] linePattern, int centerIndex)
- {
- // 윈도우 슬라이딩으로 연속된 5칸을 검사 (한 칸 떨어진 패턴을 위해)
- for (int start = 0; start <= 5; start++)
+ // 윈도우 슬라이딩으로 연속된 4를 검사
+ for (int start = 0; start <= 7; 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;
diff --git a/Assets/Trash Can_JY/Renju.unity b/Assets/Trash Can_JY/Renju.unity
index 1a49ad8..b1afb5d 100644
--- a/Assets/Trash Can_JY/Renju.unity
+++ b/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