FioreFlower/Degullmok-client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

DO-31 feat 렌주룰 로직 작성

Browse Source 
일부 엣지 케이스 미적용
This commit is contained in:
fiore 2025-03-18 11:03:22 +09:00
parent de02ad1b27
commit eedc964ea9
15 changed files with 722 additions and 665 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Assets/Script/Common/Constants.cs
View File

@ -2,4 +2,5 @@
{
public const string ServerURL = "http://localhost:3000";
public const string GameServerURL = "ws://localhost:3000";
public const int BoardSize = 15;
}

35
Assets/Script/Game/GameLogic.cs
View File

@ -14,14 +14,13 @@ public class GameLogic : MonoBehaviour
public int lastRow;
public int lastCol;
#region Renju Members
#region Renju Members
// 렌주룰 금수 검사기
private RenjuForbiddenMoveDetector _forbiddenDetector;
// 현재 금수 위치 목록
private List<(Vector2Int position, ForbiddenType type)> _forbiddenMoves = new List<(Vector2Int, ForbiddenType)>();
#endregion
private List<Vector2Int> _forbiddenMoves = new List<Vector2Int>();
#endregion
public GameLogic(StoneController stoneController, Enums.GameType gameType)
{
@ -33,8 +32,10 @@ public class GameLogic : MonoBehaviour
lastRow = -1;
lastCol = -1;
#region Renju Init
// 금수 감지기 초기화
_forbiddenDetector = new RenjuForbiddenMoveDetector();
#endregion
currentTurn = Enums.PlayerType.PlayerA;
@ -45,8 +46,10 @@ public class GameLogic : MonoBehaviour
{
currentTurn = player;
#region Renju Turn Set
// 턴이 변경될 때마다 금수 위치 업데이트
UpdateForbiddenMoves();
#endregion
_stoneController.OnStoneClickedDelegate = (row, col) =>
{
@ -110,31 +113,22 @@ public class GameLogic : MonoBehaviour
_stoneController.SetStoneState(state, row, col);
}
#region Renju Rule Detector
#region Renju Rule Detector
// 금수 위치 업데이트 및 표시
private void UpdateForbiddenMoves()
{
// TODO: 이전 금수 표시 제거
ClearForbiddenMarks();
// 흑돌 차례에만 금수 규칙 적용
if (currentTurn == Enums.PlayerType.PlayerA)
{
// 모든 금수의 위치 찾기
_forbiddenMoves = _forbiddenDetector.FindAllForbiddenMoves(_board);
foreach (var forbiddenMove in _forbiddenMoves)
_forbiddenMoves = _forbiddenDetector.RenjuForbiddenMove(_board);
foreach (var pos in _forbiddenMoves)
{
Vector2Int pos = forbiddenMove.position;
SetStoneNewState(Enums.StoneState.Blocked, pos.x, pos.y);
}
}
else
{
// 백돌 차례면 금수 목록 비우기
_forbiddenMoves.Clear();
}
}
// 이전에 표시된 금수 마크 제거
@ -142,13 +136,12 @@ public class GameLogic : MonoBehaviour
{
foreach (var forbiddenMove in _forbiddenMoves)
{
Vector2Int pos = forbiddenMove.position;
Vector2Int pos = forbiddenMove;
if (_board[pos.x, pos.y] == Enums.PlayerType.None)
{
SetStoneNewState(Enums.StoneState.None, pos.x, pos.y);
}
}
}
#endregion
#endregion
}

96
Assets/Script/Renju/DoubleFourDetector.cs
View File

@ -1,96 +0,0 @@
using UnityEngine;
// 렌주 룰에서 사사 금수 위치를 감지하는 클래스
public class DoubleFourDetector : RenjuDetectorBase
{
/// <summary>
/// 특정 위치에 흑돌을 놓았을 때 4-4 금수가 생기는지 검사
/// </summary>
/// <param name="board">현재 보드 상태</param>
/// <param name="row">행 좌표</param>
/// <param name="col">열 좌표</param>
/// <returns>4-4 금수 여부 (true: 금수, false: 금수 아님)</returns>
public bool IsDoubleFour(Enums.PlayerType[,] board, int row, int col)
{
// 빈 위치가 아니면 검사할 필요 없음
if (!IsEmptyPosition(board, row, col))
{
return false;
}
// 임시 보드 생성
Enums.PlayerType[,] tempBoard = (Enums.PlayerType[,])board.Clone();
// 해당 위치에 흑돌 놓기
tempBoard[row, col] = Enums.PlayerType.PlayerA;
// 4목 개수 카운트
int fourCount = 0;
// 각 방향으로 4목 검사
foreach (Vector2Int dir in directions)
{
int count = CountConsecutiveStones(tempBoard, row, col, dir);
// 정확히 4개의 연속된 돌인 경우
if (count == 4)
{
fourCount++;
// 디버깅 정보
Debug.Log($"4목 발견: ({row}, {col}) 방향: ({dir.x}, {dir.y})");
// 이미 2개의 4목을 찾았으면 4-4 금수임
if (fourCount >= 2)
{
return true;
}
}
}
return false;
}
private int CountConsecutiveStones(Enums.PlayerType[,] board, int row, int col, Vector2Int dir)
{
Enums.PlayerType stone = board[row, col];
if (stone != Enums.PlayerType.PlayerA)
{
return 0;
}
int count = 1; // 현재 돌 포함
int dRow = dir.x;
int dCol = dir.y;
// 정방향 검사
for (int i = 1; i <= 5; i++) // 최대 5칸까지만 검사
{
int r = row + i * dRow;
int c = col + i * dCol;
if (!IsValidPosition(r, c) || board[r, c] != stone)
{
break;
}
count++;
}
// 역방향 검사
for (int i = 1; i <= 5; i++) // 최대 5칸까지만 검사
{
int r = row - i * dRow;
int c = col - i * dCol;
if (!IsValidPosition(r, c) || board[r, c] != stone)
{
break;
}
count++;
}
return count;
}
}

3
Assets/Script/Renju/DoubleFourDetector.cs.meta
View File

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 62718ad321de4ed0b6569d09b8e78716
timeCreated: 1741961153

201
Assets/Script/Renju/DoubleThreeDetector.cs
View File

@ -1,201 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
/// <summary>
/// 렌주 룰에서 삼삼 금수 위치를 감지하는 클래스
/// </summary>
public class DoubleThreeDetector :RenjuDetectorBase
{
// 열린 4 감지기
private OpenFourDetector _openFourDetector = new();
// 디버깅용 방향 이름
private readonly string[] _directionNames = new string[]
{
"가로", "세로", "우하향 대각선", "우상향 대각선"
};
private readonly string[] _rowNames = new[]
{
"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O"
};
/// <summary>
/// 해당 위치가 금수인지 반환하는 함수
/// </summary>
/// <param name="board">현재 보드 상태</param>
/// <param name="row">row 좌표</param>
/// <param name="col">col 좌표</param>
/// <returns>금수 여부</returns>
public bool IsDoubleThree(Enums.PlayerType[,] board, int row, int col)
{
// 빈 위치가 아니면 검사할 필요 없음
if (!IsEmptyPosition(board, row, col))
{
return false;
}
// 임시 보드 생성
Enums.PlayerType[,] tempBoard = (Enums.PlayerType[,])board.Clone();
// 해당 위치에 흑돌 놓기
tempBoard[row, col] = Enums.PlayerType.PlayerA;
// 열린 3의 방향 목록
HashSet<int> openThreeDirectionIndices = new HashSet<int>();
// 각 빈 위치에 대해 가상으로 돌을 놓아보고 열린 4가 되는지 확인
for (int r = 0; r < _boardSize; r++)
{
for (int c = 0; c < _boardSize; c++)
{
// 빈 위치만 검사 (원래 위치 제외)
if (tempBoard[r, c] != Enums.PlayerType.None || (r == row && c == col))
{
continue;
}
// 이 위치에 가상으로 돌을 놓았을 때 열린 4가 되는지 확인
var (isOpenFour, openFourDirs) = _openFourDetector.DetectOpenFour(tempBoard, r, c, Enums.PlayerType.PlayerA);
if (isOpenFour)
{
// 각 방향에 대해 원래 위치와 관련된 열린 3인지 확인
foreach (Vector2Int dir in openFourDirs)
{
// 이 방향에서 원래 위치가 포함된 라인에 열린 4가 만들어지는지 확인
if (IsPositionInSameLine(row, col, r, c, dir))
{
// 방향 인덱스 찾기
int dirIndex = GetDirectionIndex(dir);
if (dirIndex >= 0)
{
openThreeDirectionIndices.Add(dirIndex);
Debug.Log($"위치 ({_rowNames[row]}{col})에서 {_directionNames[dirIndex]} 방향으로 열린 3 발견 - ({_rowNames[r]}{c})에 놓으면 열린 4 형성");
}
}
}
}
}
}
// 서로 다른 방향에서 열린 3이 2개 이상 발견되면 3-3 금수 후보
bool isDoubleThreeCandidate = openThreeDirectionIndices.Count >= 2;
if (isDoubleThreeCandidate)
{
// 각 방향별로 진짜 열린 3인지 확인
foreach (int dirIndex in new List<int>(openThreeDirectionIndices))
{
Vector2Int dir = directions[dirIndex];
// 이 방향에서 실제로 열린 4가 만들어질 수 있는지 확인
bool canFormOpenFour = false;
// 보드의 모든 빈 위치를 검사
for (int r = 0; r < _boardSize; r++)
{
for (int c = 0; c < _boardSize; c++)
{
// 빈 위치만 검사 (원래 위치 제외)
if (tempBoard[r, c] != Enums.PlayerType.None || (r == row && c == col))
{
continue;
}
// 이 위치가 동일한 방향에 있는지 확인
if (IsPositionInSameLine(row, col, r, c, dir))
{
// 이 위치에 흑돌을 놓고 열린 4가 되는지 확인
Enums.PlayerType[,] testBoard = (Enums.PlayerType[,])tempBoard.Clone();
testBoard[r, c] = Enums.PlayerType.PlayerA;
var (isOpenFour, _) = _openFourDetector.DetectOpenFour(testBoard, r, c, Enums.PlayerType.PlayerA);
if (isOpenFour)
{
canFormOpenFour = true;
break;
}
}
}
if (canFormOpenFour)
{
break;
}
}
// 이 방향에서 열린 4를 만들 수 없다면 거짓 열린 3
if (!canFormOpenFour)
{
openThreeDirectionIndices.Remove(dirIndex);
Debug.Log($"위치 ({row},{col})에서 {_directionNames[dirIndex]} 방향은 거짓 열린 3");
}
}
// 실제 열린 3이 2개 이상인 경우만 3-3 금수
bool isDoubleThree = openThreeDirectionIndices.Count >= 2;
if (isDoubleThree)
{
string directions = string.Join(", ", openThreeDirectionIndices.Select(i => _directionNames[i]));
Debug.Log($"위치 ({row},{col})에서 3-3 금수 감지! 진짜 열린 3 방향: {directions}");
}
return isDoubleThree;
}
return false;
}
/// <summary>
/// 두 위치가 같은 라인(직선) 상에 있는지 확인
/// </summary>
private bool IsPositionInSameLine(int row1, int col1, int row2, int col2, Vector2Int dir)
{
int dRow = dir.x;
int dCol = dir.y;
// 행 차이와 열 차이가 방향 벡터의 배수인지 확인
int rowDiff = row2 - row1;
int colDiff = col2 - col1;
// 방향 벡터가 0인 경우 처리
if (dRow == 0)
return colDiff % dCol == 0 && rowDiff == 0;
if (dCol == 0)
return rowDiff % dRow == 0 && colDiff == 0;
// 두 위치의 차이가 방향 벡터의 배수인지 확인
return (rowDiff * dCol == colDiff * dRow);
}
/// <summary>
/// 방향 벡터의 인덱스 찾기
/// </summary>
private int GetDirectionIndex(Vector2Int dir)
{
// 방향 벡터 정규화
Vector2Int normalizedDir = NormalizeDirection(dir);
for (int i = 0; i < directions.Length; i++)
{
if (directions[i].Equals(normalizedDir))
return i;
}
return -1;
}
/// <summary>
/// 방향 벡터 정규화 (항상 x가 양수이거나, x가 0일 때 y가 양수)
/// </summary>
private Vector2Int NormalizeDirection(Vector2Int dir)
{
if (dir.x < 0 || (dir.x == 0 && dir.y < 0))
return new Vector2Int(-dir.x, -dir.y);
return dir;
}
}

3
Assets/Script/Renju/DoubleThreeDetector.cs.meta
View File

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: cb7f46b4a369421aa9fbcb2d1b53c68a
timeCreated: 1741960686

8
Assets/Script/Renju/RenjuDetectorBase.cs → Assets/Script/Renju/ForbiddenDetectorBase.cs
View File

@ -1,6 +1,6 @@
using UnityEngine;
public class RenjuDetectorBase
public class ForbiddenDetectorBase
{
// 방향 배열 (가로, 세로, 대각선)
private protected Vector2Int[] directions =
@ -12,12 +12,12 @@ public class RenjuDetectorBase
};
// 15*15 보드 사이즈
private protected int _boardSize = 15;
private protected int _boardSize = Constants.BoardSize;
/// <summary>
/// 좌표가 보드 범위 내에 있는지 확인
/// </summary>
private protected bool IsValidPosition(int row, int col)
private protected bool IsInBounds(int row, int col)
{
var inBoardSizeRow = row >= 0 && row < _boardSize;
var inBoardSizeCol = col >= 0 && col < _boardSize;
@ -30,7 +30,7 @@ public class RenjuDetectorBase
/// </summary>
private protected bool IsEmptyPosition(Enums.PlayerType[,] board, int row, int col)
{
if (!IsValidPosition(row, col)) return false;
if (!IsInBounds(row, col)) return false;
return board[row, col] == Enums.PlayerType.None;
}

0
Assets/Script/Renju/RenjuDetectorBase.cs.meta → Assets/Script/Renju/ForbiddenDetectorBase.cs.meta
View File

149
Assets/Script/Renju/OpenFourDetector.cs
View File

@ -1,149 +0,0 @@
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 렌주에서 '열린 4'를 감지하는 클래스
/// 열린 4: 한 수를 놓으면 5목을 완성할 수 있는 4개의 연속된 돌
/// </summary>
public class OpenFourDetector : RenjuDetectorBase
{
/// <summary>
/// 특정 위치에 돌을 놓았을 때 열린 4가 형성되는지 확인
/// </summary>
/// <param name="board">현재 보드 상태</param>
/// <param name="row">행 좌표</param>
/// <param name="col">열 좌표</param>
/// <param name="playerType">검사할 플레이어 타입 (PlayerA 또는 PlayerB)</param>
/// <returns>열린 4 형성 여부 및 방향 목록</returns>
public (bool isOpenFour, List<Vector2Int> directions) DetectOpenFour(Enums.PlayerType[,] board, int row, int col,
Enums.PlayerType playerType)
{
if (!IsValidPosition(row, col))
{
return (false, new List<Vector2Int>());
}
// 임시 보드 생성
Enums.PlayerType[,] tempBoard = (Enums.PlayerType[,])board.Clone();
// 원래 값 저장
Enums.PlayerType originalValue = tempBoard[row, col];
// 해당 위치에 검사할 플레이어의 돌 놓기
tempBoard[row, col] = playerType;
List<Vector2Int> openFourDirections = new List<Vector2Int>();
// 각 방향으로 열린 4 검사
foreach (Vector2Int dir in directions)
{
if (HasOpenFourInDirection(tempBoard, row, col, dir, playerType))
{
openFourDirections.Add(dir);
}
}
// 원래 값 복원
tempBoard[row, col] = originalValue;
return (openFourDirections.Count > 0, openFourDirections);
}
/// <summary>
/// 특정 방향으로 열린 4가 있는지 검사
/// </summary>
private bool HasOpenFourInDirection(Enums.PlayerType[,] board, int row, int col, Vector2Int dir, Enums.PlayerType playerType)
{
// 해당 방향으로 연속된 돌 개수 세기
int consecutiveCount = CountConsecutiveStones(board, row, col, dir, playerType);
// 정확히 4개의 연속된 돌이 있는지 확인
if (consecutiveCount != 4)
{
return false;
}
// 양쪽이 열려있는지 확인
bool frontOpen = IsSideOpen(board, row, col, dir, true, playerType);
bool backOpen = IsSideOpen(board, row, col, dir, false, playerType);
// 적어도 한쪽은 열려있어야 '열린 4'
return frontOpen || backOpen;
}
/// <summary>
/// 특정 방향으로 연속된 같은 색 돌의 개수를 세는 함수
/// </summary>
private int CountConsecutiveStones(Enums.PlayerType[,] board, int row, int col, Vector2Int dir, Enums.PlayerType playerType)
{
int count = 1; // 현재 위치 포함
// 정방향으로 연속된 돌 세기
for (int i = 1; i <= 4; i++) // 최대 4칸까지 검사 (5목 이상이면 별도 처리)
{
int r = row + i * dir.x;
int c = col + i * dir.y;
if (!IsValidPosition(r, c) || board[r, c] != playerType)
{
break;
}
count++;
}
// 역방향으로 연속된 돌 세기
for (int i = 1; i <= 4; i++)
{
int r = row - i * dir.x;
int c = col - i * dir.y;
if (!IsValidPosition(r, c) || board[r, c] != playerType)
{
break;
}
count++;
}
return count;
}
/// <summary>
/// 특정 방향의 한쪽이 열려있는지 확인 (빈 칸인지, 상대방 돌이나 경계로 막혀있지 않은지)
/// </summary>
private bool IsSideOpen(Enums.PlayerType[,] board, int row, int col, Vector2Int dir, bool isFrontSide, Enums.PlayerType playerType)
{
// 확인할 방향 설정
int dirMultiplier = isFrontSide ? 1 : -1;
// 연속된 돌의 끝에서 한 칸 더 간 위치 확인
int consecutiveCount = 0;
int currentRow = row;
int currentCol = col;
// 해당 방향으로 연속된 돌 찾기
while (true)
{
int r = currentRow + dirMultiplier * dir.x;
int c = currentCol + dirMultiplier * dir.y;
if (!IsValidPosition(r, c) || board[r, c] != playerType)
{
break;
}
consecutiveCount++;
currentRow = r;
currentCol = c;
}
// 연속된 돌의 끝에서 한 칸 더 간 위치
int nextRow = currentRow + dirMultiplier * dir.x;
int nextCol = currentCol + dirMultiplier * dir.y;
// 해당 위치가 보드 내부이고 빈 칸이면 '열린' 상태
return IsValidPosition(nextRow, nextCol) && board[nextRow, nextCol] == Enums.PlayerType.None;
}
}

3
Assets/Script/Renju/OpenFourDetector.cs.meta
View File

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 9e99fad9f03a4a7794edd7194f6c5e5b
timeCreated: 1742178319

88
Assets/Script/Renju/OverlineDetector.cs
View File

@ -1,88 +0,0 @@
using UnityEngine;
public class OverlineDetector:RenjuDetectorBase
{
/// <summary>
/// 특정 위치에 흑돌을 놓았을 때 장목(6목 이상)이 생기는지 검사
/// </summary>
/// <param name="board">현재 보드 상태</param>
/// <param name="row">행 좌표</param>
/// <param name="col">열 좌표</param>
/// <returns>장목 금수 여부 (true: 금수, false: 금수 아님)</returns>
public bool IsOverline(Enums.PlayerType[,] board, int row, int col)
{
// 빈 위치가 아니면 검사할 필요 없음
if (!IsEmptyPosition(board, row, col))
{
return false;
}
// 임시 보드 생성
Enums.PlayerType[,] tempBoard = (Enums.PlayerType[,])board.Clone();
// 해당 위치에 흑돌 놓기
tempBoard[row, col] = Enums.PlayerType.PlayerA;
// 각 방향으로 연속된 돌 개수 검사
foreach (Vector2Int dir in directions)
{
int count = CountConsecutiveStones(tempBoard, row, col, dir);
// 6목 이상인 경우 장목 금수
if (count >= 6)
{
Debug.Log($"장목 발견: ({row}, {col}) 방향: ({dir.x}, {dir.y}), 연속 돌 개수: {count}");
return true;
}
}
return false;
}
/// <summary>
/// 특정 방향으로 연속된 같은 색 돌의 개수를 세는 함수
/// </summary>
private int CountConsecutiveStones(Enums.PlayerType[,] board, int row, int col, Vector2Int dir)
{
Enums.PlayerType stone = board[row, col];
if (stone != Enums.PlayerType.PlayerA)
{
return 0;
}
int count = 1; // 현재 돌 포함
int dRow = dir.x;
int dCol = dir.y;
// 정방향 검사
for (int i = 1; i <= 5; i++) // 최대 5칸까지만 검사 (5칸 이후로는 6목 이상이 확정)
{
int r = row + i * dRow;
int c = col + i * dCol;
if (!IsValidPosition(r, c) || board[r, c] != stone)
{
break;
}
count++;
}
// 역방향 검사
for (int i = 1; i <= 5; i++) // 최대 5칸까지만 검사
{
int r = row - i * dRow;
int c = col - i * dCol;
if (!IsValidPosition(r, c) || board[r, c] != stone)
{
break;
}
count++;
}
return count;
}
}

3
Assets/Script/Renju/OverlineDetector.cs.meta
View File

@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 0727203eebbc4c3e823fd4ee045cb713
timeCreated: 1741966933

104
Assets/Script/Renju/RenjuForbiddenMoveDetector.cs
View File

@ -6,12 +6,7 @@ using UnityEngine;
/// </summary>
public class RenjuForbiddenMoveDetector
{
// 3-3, 4-4, 장목 감지기
private DoubleThreeDetector _doubleThreeDetector;
private DoubleFourDetector _doubleFourDetector;
private OverlineDetector _overlineDetector;
private int _boardSize = 15;
private RenjuRuleChecker _ruleChecker;
/// <summary>
/// 렌주 금수 감지기 생성자
@ -19,102 +14,23 @@ public class RenjuForbiddenMoveDetector
public RenjuForbiddenMoveDetector()
{
// 각 감지기 초기화
_doubleThreeDetector = new DoubleThreeDetector();
_doubleFourDetector = new DoubleFourDetector();
_overlineDetector = new OverlineDetector();
_ruleChecker = new RenjuRuleChecker();
}
/// <summary>
/// 모든 금수 위치를 찾아 반환하는 함수
/// 렌주 룰로 금수 리스트를 반환하는 함수
/// </summary>
/// <param name="board">현재 보드 상태</param>
/// <returns>금수 위치 목록 (각 위치별 금수 타입 정보 포함)</returns>
public List<(Vector2Int position, ForbiddenType type)> FindAllForbiddenMoves(Enums.PlayerType[,] board)
/// <param name="board">현재 보드의 상태</param>
/// <returns>금수 좌표를 담은 리스트</returns>
public List<Vector2Int> RenjuForbiddenMove(Enums.PlayerType[,] board)
{
List<(Vector2Int, ForbiddenType)> forbiddenMoves = new List<(Vector2Int, ForbiddenType)>();
var doubleThreeList = _ruleChecker.GetForbiddenMoves(board);
// 흑돌 차례에만 금수 규칙 적용
for (int row = 0; row < _boardSize; row++)
foreach (var doubleThreePos in doubleThreeList)
{
for (int col = 0; col < _boardSize; col++)
{
// 빈 위치만 검사
if (board[row, col] != Enums.PlayerType.None)
{
continue;
}
// 금수 타입 확인
ForbiddenType type = CheckForbiddenType(board, row, col);
// 금수인 경우 목록에 추가
if (type != ForbiddenType.None)
{
forbiddenMoves.Add((new Vector2Int(row, col), type));
}
}
Debug.Log("삼삼 금수 좌표 X축 : " + doubleThreePos.x + ", Y축 : " + doubleThreePos.y);
}
return forbiddenMoves;
return doubleThreeList;
}
/// <summary>
/// 특정 위치의 금수 타입 확인
/// </summary>
/// <param name="board">현재 보드 상태</param>
/// <param name="row">행 좌표</param>
/// <param name="col">열 좌표</param>
/// <returns>금수 타입 (None, DoubleThree, DoubleFour, Overline)</returns>
public ForbiddenType CheckForbiddenType(Enums.PlayerType[,] board, int row, int col)
{
// 빈 위치가 아니면 금수가 아님
if (board[row, col] != Enums.PlayerType.None)
{
return ForbiddenType.None;
}
// 장목 검사 (장목이 가장 우선)
if (_overlineDetector.IsOverline(board, row, col))
{
return ForbiddenType.Overline;
}
// 4-4 검사
if (_doubleFourDetector.IsDoubleFour(board, row, col))
{
return ForbiddenType.DoubleFour;
}
// 3-3 검사
if (_doubleThreeDetector.IsDoubleThree(board, row, col))
{
return ForbiddenType.DoubleThree;
}
// 금수 아님
return ForbiddenType.None;
}
/// <summary>
/// 특정 위치가 금수인지 간단히 확인
/// </summary>
/// <param name="board">현재 보드 상태</param>
/// <param name="row">행 좌표</param>
/// <param name="col">열 좌표</param>
/// <returns>금수 여부 (true: 금수, false: 금수 아님)</returns>
public bool IsForbiddenMove(Enums.PlayerType[,] board, int row, int col)
{
return CheckForbiddenType(board, row, col) != ForbiddenType.None;
}
}
/// <summary>
/// 금수 타입 열거형
/// </summary>
public enum ForbiddenType
{
None, // 금수 아님
DoubleThree, // 3-3 금수
DoubleFour, // 4-4 금수
Overline // 장목 금수
}

690
Assets/Script/Renju/RenjuRuleChecker.cs Normal file
View File

@ -0,0 +1,690 @@
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
public class RenjuRuleChecker: ForbiddenDetectorBase
{
// 8방향을 나타내는 델타 배열 (가로, 세로, 대각선 방향)
private static readonly int[,] directions = new int[8, 2]
{
{ 1, 0 }, // 오른쪽
{ 1, 1 }, // 오른쪽 아래
{ 0, 1 }, // 아래
{ -1, 1 }, // 왼쪽 아래
{ -1, 0 }, // 왼쪽
{ -1, -1 }, // 왼쪽 위
{ 0, -1 }, // 위
{ 1, -1 } // 오른쪽 위
};
// 기본 삼(3) 패턴 (흑돌 = 1, 빈칸 = 0)
private static readonly int[][] threePatterns = new int[][]
{
new int[] { 0, 1, 1, 1, 0 }, // _OOO_
new int[] { 0, 1, 1, 0, 1, 0 }, // _OO_O_
new int[] { 0, 1, 0, 1, 1, 0 } // _O_OO_
};
// 기본 사(4) 패턴 (흑돌 = 1, 빈칸 = 0)
private static readonly int[][] fourPatterns = new int[][]
{
new int[] { 0, 1, 1, 1, 1, 0 }, // _OOOO_
new int[] { 0, 1, 1, 1, 0, 1, 0 }, // _OOO_O_
new int[] { 0, 1, 1, 0, 1, 1, 0 }, // _OO_OO_
new int[] { 0, 1, 0, 1, 1, 1, 0 } // _O_OOO_
};
// 디버그 모드 활성화 (문제 해결 시 사용)
private bool debugMode = false;
/// <summary>
/// 현재 보드 상태에서 흑돌(PlayerA)이 둘 수 없는 금수 위치 목록을 반환합니다.
/// </summary>
/// <param name="board">현재 보드 상태</param>
/// <returns>금수 위치 목록</returns>
public List<Vector2Int> GetForbiddenMoves(Enums.PlayerType[,] board)
{
int width = board.GetLength(0);
int height = board.GetLength(1);
List<Vector2Int> forbiddenMoves = new List<Vector2Int>();
// 빈 칸마다 금수인지 확인
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
// 빈 칸만 검사
if (board[x, y] != Enums.PlayerType.None)
continue;
// 해당 위치에 흑돌을 임시로 놓았다고 가정
Enums.PlayerType[,] simulatedBoard = (Enums.PlayerType[,])board.Clone();
simulatedBoard[x, y] = Enums.PlayerType.PlayerA;
// 장목(6목 이상) 확인
if (IsOverline(simulatedBoard, x, y))
{
forbiddenMoves.Add(new Vector2Int(x, y));
continue;
}
// 모든 방향별 패턴 정보 수집
PatternInfo patternInfo = CollectAllPatterns(simulatedBoard, x, y);
// 4-3 패턴 확인 (이 위치에 놓았을 때 열린 4가 1개, 열린 3이 1개 이상 생성되면 4-3 패턴)
bool isFourThree = IsFourThreeAdvanced(patternInfo);
if (isFourThree)
{
// 4-3 패턴은 금수가 아님
continue;
}
// 쌍삼(3-3) 또는 사사(4-4) 확인
bool isThreeThree = IsThreeThreeAdvanced(patternInfo);
bool isFourFour = IsFourFourAdvanced(patternInfo);
// 금수 여부 판정
if (isThreeThree || isFourFour)
{
forbiddenMoves.Add(new Vector2Int(x, y));
}
}
}
return forbiddenMoves;
}
/// <summary>
/// 한 위치에서 모든 방향의 패턴 정보를 수집
/// </summary>
private PatternInfo CollectAllPatterns(Enums.PlayerType[,] board, int x, int y)
{
int width = board.GetLength(0);
int height = board.GetLength(1);
PatternInfo patternInfo = new PatternInfo();
// 각 방향별로 패턴 수집
for (int dir = 0; dir < 4; dir++)
{
// 해당 방향에서 연속된 돌의 배열 얻기
List<Stone> line = GetLineOfStones(board, x, y, dir, width, height, 8);
// 열린 3 패턴 찾기
List<OpenThreePattern> threePatterns = FindOpenThreePatterns(line, x, y, dir);
patternInfo.OpenThreePatterns.AddRange(threePatterns);
// 열린 4 패턴 찾기
List<OpenFourPattern> fourPatterns = FindOpenFourPatterns(line, x, y, dir);
patternInfo.OpenFourPatterns.AddRange(fourPatterns);
// 방향별 돌 배열 저장 (디버깅용)
if (debugMode)
{
patternInfo.LinesByDirection[dir] = line;
}
}
return patternInfo;
}
/// <summary>
/// 고도화된 4-3 패턴 확인 로직
/// </summary>
private bool IsFourThreeAdvanced(PatternInfo patternInfo)
{
// 열린 4와 열린 3 패턴 확인
List<OpenFourPattern> fourPatterns = patternInfo.OpenFourPatterns;
List<OpenThreePattern> threePatterns = patternInfo.OpenThreePatterns;
if (fourPatterns.Count == 0 || threePatterns.Count == 0)
{
// 열린 4 또는 열린 3이 없으면 4-3 패턴이 아님
return false;
}
// 방향별로 패턴 그룹화
var fourPatternsByDir = fourPatterns.GroupBy(p => p.Direction).ToList();
var threePatternsByDir = threePatterns.GroupBy(p => p.Direction).ToList();
// 열린 4가 있는 각 방향에 대해
foreach (var fourGroup in fourPatternsByDir)
{
int fourDir = fourGroup.Key;
// 열린 3이 있는 각 방향에 대해
foreach (var threeGroup in threePatternsByDir)
{
int threeDir = threeGroup.Key;
// 서로 다른 방향이면 (열린 4와 열린 3이 다른 방향에 있으면)
if (fourDir != threeDir)
{
// 4와 3 패턴이 서로 중첩되지 않는지 확인
bool patternsOverlap = false;
foreach (var fourPattern in fourGroup)
{
foreach (var threePattern in threeGroup)
{
// 중심 돌 외에 다른 공유 돌이 있는지 확인
if (PatternsShareStones(fourPattern, threePattern))
{
patternsOverlap = true;
break;
}
}
if (patternsOverlap) break;
}
// 중첩되지 않는 4-3 패턴 발견됨
if (!patternsOverlap)
{
return true;
}
}
}
}
return false;
}
/// <summary>
/// 두 패턴이 중심 돌 외에 다른 돌을 공유하는지 확인
/// </summary>
private bool PatternsShareStones(OpenFourPattern fourPattern, OpenThreePattern threePattern)
{
// 중심 돌 외에 공유하는 돌이 있는지 확인
foreach (Vector2Int pos4 in fourPattern.StonePositions)
{
foreach (Vector2Int pos3 in threePattern.StonePositions)
{
// 두 패턴이 같은 좌표의 돌을 공유하고, 그것이 중심 돌이 아니면
if (pos4.x == pos3.x && pos4.y == pos3.y &&
!(pos4.x == fourPattern.CenterX && pos4.y == fourPattern.CenterY))
{
return true;
}
}
}
return false;
}
/// <summary>
/// 고도화된 삼삼 확인 로직
/// </summary>
private bool IsThreeThreeAdvanced(PatternInfo patternInfo)
{
List<OpenThreePattern> threePatterns = patternInfo.OpenThreePatterns;
// 열린 3 패턴이 2개 미만이면 삼삼이 아님
if (threePatterns.Count < 2)
return false;
// 방향별로 패턴 그룹화
var patternsByDir = threePatterns.GroupBy(p => p.Direction).ToList();
// 서로 다른 방향의 패턴 쌍을 검사
for (int i = 0; i < patternsByDir.Count; i++)
{
for (int j = i + 1; j < patternsByDir.Count; j++)
{
// 첫 번째 방향의 모든 패턴
var patternsDir1 = patternsByDir[i].ToList();
// 두 번째 방향의 모든 패턴
var patternsDir2 = patternsByDir[j].ToList();
// 두 방향의 패턴들이 서로 중첩되지 않는지 확인
bool foundNonOverlapping = false;
foreach (var pattern1 in patternsDir1)
{
if (foundNonOverlapping) break;
foreach (var pattern2 in patternsDir2)
{
// 중심 돌 외에 다른 공유 돌이 없으면 비중첩 삼삼
if (!PatternsOverlap(pattern1, pattern2))
{
foundNonOverlapping = true;
break;
}
}
}
// 비중첩 삼삼 발견
if (foundNonOverlapping)
{
return true;
}
}
}
return false;
}
/// <summary>
/// 두 열린 3 패턴이 중첩되는지 확인
/// </summary>
private bool PatternsOverlap(OpenThreePattern pattern1, OpenThreePattern pattern2)
{
// 중심 돌 외에 공유하는 돌이 있는지 확인
foreach (Vector2Int pos1 in pattern1.StonePositions)
{
foreach (Vector2Int pos2 in pattern2.StonePositions)
{
// 두 패턴이 같은 좌표의 돌을 공유하고, 그것이 중심 돌이 아니면 중첩
if (pos1.x == pos2.x && pos1.y == pos2.y &&
!(pos1.x == pattern1.CenterX && pos1.y == pattern1.CenterY))
{
return true;
}
}
}
return false;
}
/// <summary>
/// 고도화된 사사 확인 로직
/// </summary>
private bool IsFourFourAdvanced(PatternInfo patternInfo)
{
List<OpenFourPattern> fourPatterns = patternInfo.OpenFourPatterns;
// 열린 4 패턴이 2개 미만이면 사사가 아님
if (fourPatterns.Count < 2)
return false;
// 방향별로 패턴 그룹화
var patternsByDir = fourPatterns.GroupBy(p => p.Direction).ToList();
// 서로 다른 방향의 패턴이 2개 이상이면 사사
if (patternsByDir.Count >= 2)
return true;
// 같은 방향에서도 중첩되지 않는 패턴이 있는지 확인
foreach (var group in patternsByDir)
{
var patterns = group.ToList();
for (int i = 0; i < patterns.Count - 1; i++)
{
for (int j = i + 1; j < patterns.Count; j++)
{
// 중심 돌 외에 다른 공유 돌이 없으면 비중첩 사사
if (!FourPatternsOverlap(patterns[i], patterns[j]))
{
return true;
}
}
}
}
return false;
}
/// <summary>
/// 두 열린 4 패턴이 중첩되는지 확인
/// </summary>
private bool FourPatternsOverlap(OpenFourPattern pattern1, OpenFourPattern pattern2)
{
// 중심 돌 외에 공유하는 돌이 있는지 확인
foreach (Vector2Int pos1 in pattern1.StonePositions)
{
foreach (Vector2Int pos2 in pattern2.StonePositions)
{
// 두 패턴이 같은 좌표의 돌을 공유하고, 그것이 중심 돌이 아니면 중첩
if (pos1.x == pos2.x && pos1.y == pos2.y &&
!(pos1.x == pattern1.CenterX && pos1.y == pattern1.CenterY))
{
return true;
}
}
}
return false;
}
/// <summary>
/// 한 방향의 돌 배열 얻기 (지정된 범위만큼 확장)
/// </summary>
private List<Stone> GetLineOfStones(Enums.PlayerType[,] board, int x, int y, int dirIndex, int width, int height, int extensionRange = 5)
{
List<Stone> line = new List<Stone>();
// 중앙에 놓인 현재 돌 추가
line.Add(new Stone { Type = board[x, y], X = x, Y = y, RelativePosition = 0 });
// 양방향으로 지정된 칸수만큼 확장
for (int extendDir = 0; extendDir < 2; extendDir++)
{
int actualDirIndex = extendDir == 0 ? dirIndex : dirIndex + 4; // 반대 방향으로도 확장
int dx = directions[actualDirIndex, 0];
int dy = directions[actualDirIndex, 1];
// 지정된 칸수만큼 확장
for (int i = 1; i <= extensionRange; i++)
{
int nx = x + (dx * i);
int ny = y + (dy * i);
if (!IsInBounds(nx, ny))
break;
Stone stone = new Stone
{
Type = board[nx, ny],
X = nx,
Y = ny,
RelativePosition = extendDir == 0 ? i : -i
};
if (extendDir == 0)
line.Add(stone); // 정방향은 뒤에 추가
else
line.Insert(0, stone); // 역방향은 앞에 추가
}
}
return line;
}
/// <summary>
/// 주어진 라인에서 열린 3 패턴 찾기 (백돌로 막혀있는 경우 고려)
/// </summary>
private List<OpenThreePattern> FindOpenThreePatterns(List<Stone> line, int centerX, int centerY, int dirIndex)
{
List<OpenThreePattern> result = new List<OpenThreePattern>();
int lineLength = line.Count;
// 각 열린 3 패턴에 대해 검사
foreach (int[] pattern in threePatterns)
{
int patternLength = pattern.Length;
// 라인을 슬라이딩 윈도우로 검사
for (int i = 0; i <= lineLength - patternLength; i++)
{
bool patternMatches = true;
List<Vector2Int> stonePositions = new List<Vector2Int>();
List<int> stoneRelativePositions = new List<int>();
// 패턴과 라인이 일치하는지 확인
for (int j = 0; j < patternLength; j++)
{
Stone stone = line[i + j];
// 패턴의 1은 흑돌(PlayerA)과 일치해야 함
if (pattern[j] == 1)
{
if (stone.Type != Enums.PlayerType.PlayerA)
{
patternMatches = false;
break;
}
stonePositions.Add(new Vector2Int(stone.X, stone.Y));
stoneRelativePositions.Add(stone.RelativePosition);
}
// 패턴의 0은 빈 칸(None)과 일치해야 함
else if (pattern[j] == 0 && stone.Type != Enums.PlayerType.None)
{
patternMatches = false;
break;
}
}
// 패턴이 일치하고, 중심 돌이 패턴에 포함되는 경우에만 열린 3으로 인정
if (patternMatches && stonePositions.Any(pos => pos.x == centerX && pos.y == centerY))
{
// 패턴 양쪽의 확장성 검사 (백돌로 막혀있는지 확인)
bool isReallyOpen = IsPatternReallyOpen(line, i, i + patternLength - 1);
// 진짜 열린 3인 경우에만 추가
if (isReallyOpen)
{
result.Add(new OpenThreePattern
{
Direction = dirIndex,
StonePositions = stonePositions,
RelativePositions = stoneRelativePositions,
CenterX = centerX,
CenterY = centerY
});
}
}
}
}
return result;
}
/// <summary>
/// 주어진 라인에서 열린 4 패턴 찾기 (백돌로 막혀있는 경우 고려)
/// </summary>
private List<OpenFourPattern> FindOpenFourPatterns(List<Stone> line, int centerX, int centerY, int dirIndex)
{
List<OpenFourPattern> result = new List<OpenFourPattern>();
int lineLength = line.Count;
// 각 열린 4 패턴에 대해 검사
foreach (int[] pattern in fourPatterns)
{
int patternLength = pattern.Length;
// 라인을 슬라이딩 윈도우로 검사
for (int i = 0; i <= lineLength - patternLength; i++)
{
bool patternMatches = true;
List<Vector2Int> stonePositions = new List<Vector2Int>();
// 패턴과 라인이 일치하는지 확인
for (int j = 0; j < patternLength; j++)
{
Stone stone = line[i + j];
// 패턴의 1은 흑돌(PlayerA)과 일치해야 함
if (pattern[j] == 1)
{
if (stone.Type != Enums.PlayerType.PlayerA)
{
patternMatches = false;
break;
}
stonePositions.Add(new Vector2Int(stone.X, stone.Y));
}
// 패턴의 0은 빈 칸(None)과 일치해야 함
else if (pattern[j] == 0 && stone.Type != Enums.PlayerType.None)
{
patternMatches = false;
break;
}
}
// 패턴이 일치하고, 중심 돌이 패턴에 포함되는 경우에만 열린 4로 인정
if (patternMatches && stonePositions.Any(pos => pos.x == centerX && pos.y == centerY))
{
// 패턴 양쪽의 확장성 검사 (백돌로 막혀있는지 확인)
bool isReallyOpen = IsPatternReallyOpen(line, i, i + patternLength - 1);
// 진짜 열린 4인 경우에만 추가
if (isReallyOpen)
{
result.Add(new OpenFourPattern
{
Direction = dirIndex,
StonePositions = stonePositions,
CenterX = centerX,
CenterY = centerY
});
}
}
}
}
return result;
}
/// <summary>
/// 패턴이 정말로 열려있는지 확인 (백돌로 막혀있지 않은지)
/// </summary>
private bool IsPatternReallyOpen(List<Stone> line, int startIdx, int endIdx)
{
int lineLength = line.Count;
bool leftSideOpen = false;
bool rightSideOpen = false;
// 좌측 확장성 검사
int leftCheckIdx = startIdx - 1;
int leftExtendableSpaces = 0;
while (leftCheckIdx >= 0)
{
if (line[leftCheckIdx].Type == Enums.PlayerType.None)
{
leftExtendableSpaces++;
leftCheckIdx--;
}
else if (line[leftCheckIdx].Type == Enums.PlayerType.PlayerB)
{
// 백돌로 막혀있음
break;
}
else
{
// 흑돌이 있음 (이미 다른 패턴의 일부일 수 있음)
break;
}
}
// 우측 확장성 검사
int rightCheckIdx = endIdx + 1;
int rightExtendableSpaces = 0;
while (rightCheckIdx < lineLength)
{
if (line[rightCheckIdx].Type == Enums.PlayerType.None)
{
rightExtendableSpaces++;
rightCheckIdx++;
}
else if (line[rightCheckIdx].Type == Enums.PlayerType.PlayerB)
{
// 백돌로 막혀있음
break;
}
else
{
// 흑돌이 있음 (이미 다른 패턴의 일부일 수 있음)
break;
}
}
// 양쪽이 모두 백돌로 막혀있다면 진짜 열린 3이 아님
if (leftCheckIdx >= 0 && rightCheckIdx < lineLength &&
line[leftCheckIdx].Type == Enums.PlayerType.PlayerB &&
line[rightCheckIdx].Type == Enums.PlayerType.PlayerB)
{
return false;
}
// 적어도 한쪽에 빈 공간이 있으면 열린 패턴으로 간주
leftSideOpen = leftCheckIdx < 0 || line[leftCheckIdx].Type != Enums.PlayerType.PlayerB;
rightSideOpen = rightCheckIdx >= lineLength || line[rightCheckIdx].Type != Enums.PlayerType.PlayerB;
// 한쪽이라도 열려있어야 열린 패턴으로 인정
return leftSideOpen || rightSideOpen;
}
/// <summary>
/// 장목(6목 이상) 금수 검사
/// </summary>
private bool IsOverline(Enums.PlayerType[,] board, int x, int y)
{
int width = board.GetLength(0);
int height = board.GetLength(1);
// 4방향(가로, 세로, 대각선1, 대각선2)에 대해 6목 이상 검사
for (int dir = 0; dir < 4; dir++)
{
int count = 1; // 현재 위치 포함
// 정방향 탐색
int dx = directions[dir, 0];
int dy = directions[dir, 1];
int nx = x + dx;
int ny = y + dy;
while (IsInBounds(nx, ny) && board[nx, ny] == Enums.PlayerType.PlayerA)
{
count++;
nx += dx;
ny += dy;
}
// 역방향 탐색
dx = directions[dir + 4, 0];
dy = directions[dir + 4, 1];
nx = x + dx;
ny = y + dy;
while (IsInBounds(nx, ny) && board[nx, ny] == Enums.PlayerType.PlayerA)
{
count++;
nx += dx;
ny += dy;
}
// 6목 이상이면 장목(금수)
if (count >= 6)
return true;
}
return false;
}
/// <summary>
/// 돌 정보를 저장하는 구조체
/// </summary>
private struct Stone
{
public Enums.PlayerType Type;
public int X;
public int Y;
public int RelativePosition; // 중심 돌로부터의 상대적 위치
}
/// <summary>
/// 열린 3 패턴 정보를 저장하는 클래스
/// </summary>
private class OpenThreePattern
{
public int Direction;
public List<Vector2Int> StonePositions;
public List<int> RelativePositions; // 중심 돌로부터의 상대적 위치
public int CenterX;
public int CenterY;
}
/// <summary>
/// 열린 4 패턴 정보를 저장하는 클래스
/// </summary>
private class OpenFourPattern
{
public int Direction;
public List<Vector2Int> StonePositions;
public int CenterX;
public int CenterY;
}
/// <summary>
/// 한 위치의 모든 패턴 정보를 저장하는 클래스
/// </summary>
private class PatternInfo
{
public List<OpenThreePattern> OpenThreePatterns = new List<OpenThreePattern>();
public List<OpenFourPattern> OpenFourPatterns = new List<OpenFourPattern>();
public Dictionary<int, List<Stone>> LinesByDirection = new Dictionary<int, List<Stone>>();
}
}

3
Assets/Script/Renju/RenjuRuleChecker.cs.meta Normal file
View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 083e8b9070ed407b8744d4cacd0d53dc
timeCreated: 1742256498