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

Merge pull request #10 from Degulleo/DO-4-AI-Controller

Browse Source 
AI 코드 추가
This commit is contained in:
Sehyeon 2025-03-17 20:23:43 +09:00 committed by GitHub
commit 72d0fea12e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
8 changed files with 2110 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Assets/KSH.meta Normal file
View File

@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: d652b2a2f29c0c541983b529f66a5169
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

1641
Assets/KSH/AITestScene.unity Normal file
View File

File diff suppressed because it is too large Load Diff

7
Assets/KSH/AITestScene.unity.meta Normal file
View File

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: e200b684d5479a643aa06e6361c430c9
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Script/AI.meta Normal file
View File

@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 2b0c3d8290ac86441b7db8c07a6d21a6
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

340
Assets/Script/AI/MiniMaxAIController.cs Normal file
View File

@ -0,0 +1,340 @@
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
public static class MiniMaxAIController
{
// To-Do List
// 탐색 시간 개선: 캐싱(_stoneInfoCache), 좋은 수부터 탐색(Move Ordering)
// AI 난이도 개선
private const int SEARCH_DEPTH = 3; // 탐색 깊이 제한 (3 = 빠른 응답, 4 = 좀 더 강한 AI 그러나 느린)
private const int WIN_COUNT = 5;
private static int[][] _directions = new int[][]
{
new int[] {1, 0}, // 수직
new int[] {0, 1}, // 수평
new int[] {1, 1}, // 대각선 ↘ ↖
new int[] {1, -1} // 대각선 ↙ ↗
};
private static int _playerLevel = 1; // 급수 설정
private static float _mistakeMove;
private static Enums.PlayerType _AIPlayerType = Enums.PlayerType.PlayerB;
// 중복 계산을 방지하기 위한 캐싱 데이터. 위치(row, col) 와 방향(dirX, dirY) 중복 계산 방지
private static Dictionary<(int, int, int, int), (int count, int openEnds)> _stoneInfoCache
= new Dictionary<(int, int, int, int), (int count, int openEnds)>();
// 급수 설정 -> 실수 넣을 때 계산
public static void SetLevel(int level)
{
_playerLevel = level;
_mistakeMove = GetMistakeProbability(_playerLevel);
}
// 실수 확률 계산 함수
private static float GetMistakeProbability(int level)
{
// 레벨이 1일 때 실수 확률 0%, 레벨이 18일 때 실수 확률 50%
return (level - 1) / 17f * 0.5f;
}
// return 값이 null 일 경우 == 보드에 칸 꽉 참
public static (int row, int col)? GetBestMove(Enums.PlayerType[,] board)
{
// 캐시 초기화
ClearCache();
float bestScore = float.MinValue;
(int row, int col)? bestMove = null;
(int row, int col)? secondBestMove = null;
List<(int row, int col, float score)> validMoves = GetValidMoves(board);
// 보드에 놓을 수 있는 자리가 있는지 확인
if (validMoves.Count == 0)
{
return null;
}
// 5연승 가능한 자리를 먼저 찾아서 우선적으로 설정
List<(int row, int col)> fiveInARowMoves = GetFiveInARowCandidateMoves(board);
if (fiveInARowMoves.Count > 0)
{
bestMove = fiveInARowMoves[0];
return bestMove;
}
foreach (var (row, col, _) in validMoves)
{
board[row, col] = _AIPlayerType;
float score = DoMinimax(board, SEARCH_DEPTH, false, -1000, 1000, row, col);
board[row, col] = Enums.PlayerType.None;
if (score > bestScore)
{
bestScore = score;
if (bestMove != null)
{
secondBestMove = bestMove;
}
bestMove = (row, col);
}
}
// 랜덤 실수
if (secondBestMove != null && UnityEngine.Random.value < _mistakeMove) // UnityEngine.Random.value == 0~1 사이 반환
{
Debug.Log("AI Mistake");
return secondBestMove;
}
return bestMove;
}
private static float DoMinimax(Enums.PlayerType[,] board, int depth, bool isMaximizing, float alpha, float beta,
int recentRow, int recentCol)
{
if (CheckGameWin(Enums.PlayerType.PlayerA, board, recentRow, recentCol)) return -100 + depth;
if (CheckGameWin(Enums.PlayerType.PlayerB, board, recentRow, recentCol)) return 100 - depth;
if (depth == 0) return EvaluateBoard(board);
float bestScore = isMaximizing ? float.MinValue : float.MaxValue;
List<(int row, int col, float score)> validMoves = GetValidMoves(board); // 현재 놓을 수 있는 자리 리스트
foreach (var (row, col, _) in validMoves)
{
board[row, col] = isMaximizing ? Enums.PlayerType.PlayerB : Enums.PlayerType.PlayerA;
ClearCachePartial(row, col); // 부분 초기화
// ClearCache();
float minimaxScore = DoMinimax(board, depth - 1, !isMaximizing, alpha, beta, row, col);
board[row, col] = Enums.PlayerType.None;
ClearCachePartial(row, col);
// ClearCache();
if (isMaximizing)
{
bestScore = Math.Max(bestScore, minimaxScore);
alpha = Math.Max(alpha, bestScore);
}
else
{
bestScore = Math.Min(bestScore, minimaxScore);
beta = Math.Min(beta, bestScore);
}
if (beta <= alpha) break;
}
return bestScore;
}
// 이동 가능 + 주변에 돌 있는 위치 탐색
private static List<(int row, int col, float score)> GetValidMoves(Enums.PlayerType[,] board)
{
List<(int, int, float)> validMoves = new List<(int, int, float)>();
int size = board.GetLength(0);
for (int row = 0; row < size; row++)
{
for (int col = 0; col < size; col++)
{
if (board[row, col] == Enums.PlayerType.None && HasNearbyStones(board, row, col))
{
float score = EvaluateBoard(board);
validMoves.Add((row, col, score));
}
}
}
validMoves.Sort((a, b) => b.Item3.CompareTo(a.Item3));
return validMoves;
}
private static bool HasNearbyStones(Enums.PlayerType[,] board, int row, int col, int distance = 3)
{
// 9칸 기준으로 현재 위치를 중앙으로 상정한 후 나머지 8방향
int[] dr = { -1, -1, -1, 0, 0, 1, 1, 1 };
int[] dc = { -1, 0, 1, -1, 1, -1, 0, 1 };
int size = board.GetLength(0);
for(int i = 0; i < dr.Length; i++)
{
int nr = row + dr[i], nc = col + dc[i];
if (nr >= 0 && nr < size && nc >= 0 && nc < size && board[nr, nc] != Enums.PlayerType.None)
{
return true;
}
}
return false;
}
// 특정 방향으로 같은 돌 개수와 열린 끝 개수를 계산하는 함수
private static (int count, int openEnds) CountStones(
Enums.PlayerType[,] board, int row, int col, int[] direction, Enums.PlayerType player)
{
int dirX = direction[0], dirY = direction[1];
var key = (row, col, dirX, dirY);
// 캐시에 존재하면 바로 반환 (탐색 시간 감소)
if (_stoneInfoCache.TryGetValue(key, out var cachedResult))
{
return cachedResult;
}
int size = board.GetLength(0);
int count = 0;
int openEnds = 0;
// 정방향 탐색
int r = row + direction[0], c = col + direction[1];
while (r >= 0 && r < size && c >= 0 && c < size && board[r, c] == player)
{
count++;
r += direction[0]; // row값 옮기기
c += direction[1]; // col값 옮기기
}
if (r >= 0 && r < size && c >= 0 && c < size && board[r, c] == Enums.PlayerType.None)
{
openEnds++;
}
// 역방향 탐색
r = row - direction[0];
c = col - direction[1];
while (r >= 0 && r < size && c >= 0 && c < size && board[r, c] == player)
{
count++;
r -= direction[0];
c -= direction[1];
}
if (r >= 0 && r < size && c >= 0 && c < size && board[r, c] == Enums.PlayerType.None)
{
openEnds++;
}
var resultValue = (count, openEnds);
_stoneInfoCache[key] = resultValue; // 결과 저장
return resultValue;
}
// 캐시 초기화, 새로운 돌이 놓일 시 실행
private static void ClearCache()
{
_stoneInfoCache.Clear();
}
// 캐시 부분 초기화 (현재 변경된 위치 N에서 반경 5칸만 초기화)
private static void ClearCachePartial(int centerRow, int centerCol, int radius = 5)
{
// 캐시가 비어있으면 아무 작업도 하지 않음
if (_stoneInfoCache.Count == 0) return;
// 제거할 키 목록
List<(int, int, int, int)> keysToRemove = new List<(int, int, int, int)>();
// 모든 캐시 항목을 검사
foreach (var key in _stoneInfoCache.Keys)
{
var (row, col, _, _) = key;
// 거리 계산
int distance = Math.Max(Math.Abs(row - centerRow), Math.Abs(col - centerCol));
// 지정된 반경 내에 있는 캐시 항목을 삭제 목록에 추가
if (distance <= radius)
{
keysToRemove.Add(key);
}
}
// 반경 내의 키 제거
foreach (var key in keysToRemove)
{
_stoneInfoCache.Remove(key);
}
}
// 최근에 둔 돌 위치 기반으로 게임 승리를 판별하는 함수
public static bool CheckGameWin(Enums.PlayerType player, Enums.PlayerType[,] board, int row, int col)
{
foreach (var dir in _directions)
{
var (count, _) = CountStones(board, row, col, dir, player);
// 자기 자신 포함하여 5개 이상일 시 true 반환
if (count + 1 >= WIN_COUNT)
return true;
}
return false;
}
// 5목이 될 수 있는 위치 찾기
private static List<(int row, int col)> GetFiveInARowCandidateMoves(Enums.PlayerType[,] board)
{
List<(int row, int col)> fiveInARowMoves = new List<(int, int)>();
int size = board.GetLength(0);
for (int row = 0; row < size; row++)
{
for (int col = 0; col < size; col++)
{
if (board[row, col] != Enums.PlayerType.None) continue;
foreach (var dir in _directions)
{
var (count, openEnds) = CountStones(board, row, col, dir, _AIPlayerType);
if (count == 4 && openEnds > 0)
{
fiveInARowMoves.Add((row, col));
break; // 하나 나오면 바로 break (시간 단축)
}
}
}
}
return fiveInARowMoves;
}
// 현재 보드 평가 함수
private static float EvaluateBoard(Enums.PlayerType[,] board)
{
float score = 0;
int size = board.GetLength(0);
for (int row = 0; row < size; row++)
{
for (int col = 0; col < size; col++)
{
if (board[row, col] == Enums.PlayerType.None) continue;
Enums.PlayerType player = board[row, col];
int playerScore = (player == _AIPlayerType) ? 1 : -1; // AI는 양수, 플레이어는 음수
foreach (var dir in _directions)
{
var (count, openEnds) = CountStones(board, row, col, dir, player);
// 점수 계산
if (count == 4)
score += playerScore * (openEnds == 2 ? 10000 : 1000);
else if (count == 3)
score += playerScore * (openEnds == 2 ? 1000 : 100);
else if (count == 2)
score += playerScore * (openEnds == 2 ? 100 : 10);
}
}
}
return score;
}
}

11
Assets/Script/AI/MiniMaxAIController.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 0cabba9cae3792747bd277ecdc12196d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

84
Assets/Script/AI/TestGameManager.cs Normal file
View File

@ -0,0 +1,84 @@
using System;
using System.Collections;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.Serialization;
using UnityEngine.UI;
public class TestGameManager : MonoBehaviour
{
[SerializeField] private TMP_InputField rowText;
[SerializeField] private TMP_InputField colText;
[SerializeField] private TMP_Text boardText;
private Enums.PlayerType[,] _board;
private void Start()
{
_board = new Enums.PlayerType[15, 15];
MiniMaxAIController.SetLevel(1); // 급수 설정 테스트
ResultBoard();
}
public void OnClickGoButton()
{
int row = int.Parse(rowText.text);
int col = int.Parse(colText.text);
if (_board[row, col] != Enums.PlayerType.None)
{
Debug.Log("중복 위치");
return;
}
_board[row, col] = Enums.PlayerType.PlayerA;
Debug.Log($"Player's row: {row} col: {col}");
// var isEnded = MiniMaxAIController.CheckGameWin(Enums.PlayerType.PlayerA, _board, row, col);
// Debug.Log("PlayerA is Win: " + isEnded);
// 인공지능 호출
var result = MiniMaxAIController.GetBestMove(_board);
if (result.HasValue)
{
Debug.Log($"AI's row: {result.Value.row} col: {result.Value.col}");
_board[result.Value.row, result.Value.col] = Enums.PlayerType.PlayerB;
// isEnded = MiniMaxAIController.CheckGameWin(Enums.PlayerType.PlayerB, _board, result.Value.row, result.Value.col);
// Debug.Log("PlayerB is Win: " + isEnded);
}
ResultBoard();
}
private void ResultBoard()
{
boardText.text = "";
// player 타입에 따라 입력받는 건 무조건 A로 해서 A, AI는 B로 나타내고 None은 _
for (int i = 0; i < 15; i++)
{
for (int j = 0; j < 15; j++)
{
if (_board[i, j] == Enums.PlayerType.PlayerA)
{
boardText.text += 'A';
}
else if (_board[i, j] == Enums.PlayerType.PlayerB)
{
boardText.text += 'B';
}
else if (_board[i, j] == Enums.PlayerType.None)
{
boardText.text += '_';
}
boardText.text += ' ';
}
boardText.text += '\n';
}
}
}

11
Assets/Script/AI/TestGameManager.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: facc79abb6042e846bb0a2b099b58e9c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: