640 lines
23 KiB
C#
640 lines
23 KiB
C#
using System.Collections.Generic;
|
|
using Unity.Netcode;
|
|
using UnityEngine;
|
|
|
|
namespace Northbound
|
|
{
|
|
/// <summary>
|
|
/// Helper class for efficient line-of-sight calculations using sector-based raycasting
|
|
/// </summary>
|
|
public class LineOfSightCalculator
|
|
{
|
|
private struct SectorData
|
|
{
|
|
public float angle; // Angle in degrees (0-360)
|
|
public float blockedDistance; // Distance where vision is blocked (float.MaxValue if clear)
|
|
public bool hasObstacle; // True if this sector has an obstacle
|
|
public float obstacleHeight; // Height of blocking obstacle
|
|
public Vector3 obstaclePosition; // World position of obstacle hit point
|
|
}
|
|
|
|
private FogOfWarSystem _fogSystem;
|
|
private SectorData[] _sectors;
|
|
private int _sectorCount;
|
|
|
|
public LineOfSightCalculator(FogOfWarSystem fogSystem)
|
|
{
|
|
_fogSystem = fogSystem;
|
|
RecalculateSectors();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recalculate sector count based on angular step
|
|
/// </summary>
|
|
public void RecalculateSectors()
|
|
{
|
|
_sectorCount = Mathf.CeilToInt(360f / _fogSystem.raycastAngularStep);
|
|
_sectors = new SectorData[_sectorCount];
|
|
|
|
for (int i = 0; i < _sectorCount; i++)
|
|
{
|
|
_sectors[i].angle = i * _fogSystem.raycastAngularStep;
|
|
_sectors[i].blockedDistance = float.MaxValue;
|
|
_sectors[i].hasObstacle = false;
|
|
_sectors[i].obstacleHeight = 0f;
|
|
_sectors[i].obstaclePosition = Vector3.zero;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Perform raycasting to determine blocked sectors with height awareness
|
|
/// </summary>
|
|
public void CalculateVisibleSectors(Vector3 viewerPosition, float visionRange)
|
|
{
|
|
// Reset sectors
|
|
for (int i = 0; i < _sectorCount; i++)
|
|
{
|
|
_sectors[i].blockedDistance = float.MaxValue;
|
|
_sectors[i].hasObstacle = false;
|
|
_sectors[i].obstacleHeight = 0f;
|
|
_sectors[i].obstaclePosition = Vector3.zero;
|
|
}
|
|
|
|
// Raycast origin at viewer eye height
|
|
Vector3 rayOrigin = viewerPosition + Vector3.up * _fogSystem.viewerEyeHeight;
|
|
|
|
for (int i = 0; i < _sectorCount; i++)
|
|
{
|
|
float angleRad = _sectors[i].angle * Mathf.Deg2Rad;
|
|
Vector3 direction = new Vector3(Mathf.Cos(angleRad), 0, Mathf.Sin(angleRad));
|
|
|
|
if (Physics.Raycast(rayOrigin, direction, out RaycastHit hit, visionRange, _fogSystem.visionBlockingLayers))
|
|
{
|
|
_sectors[i].blockedDistance = hit.distance;
|
|
_sectors[i].hasObstacle = true;
|
|
_sectors[i].obstaclePosition = hit.point;
|
|
|
|
// Determine obstacle height
|
|
if (_fogSystem.enableHeightBlocking)
|
|
{
|
|
_sectors[i].obstacleHeight = GetObstacleHeight(hit.collider);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the height of an obstacle for vision blocking calculations
|
|
/// </summary>
|
|
private float GetObstacleHeight(Collider obstacle)
|
|
{
|
|
// Check if it's a building
|
|
Building building = obstacle.GetComponent<Building>();
|
|
if (building != null && building.buildingData != null)
|
|
{
|
|
return building.buildingData.height;
|
|
}
|
|
|
|
// For non-buildings (rocks, trees, terrain), use collider bounds
|
|
return obstacle.bounds.size.y;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if a grid cell is visible from viewer position (with height awareness)
|
|
/// </summary>
|
|
public bool IsCellVisible(Vector3 viewerPosition, Vector2Int cellGridPos, float visionRange)
|
|
{
|
|
Vector3 cellWorldPos = _fogSystem.GridToWorld(cellGridPos.x, cellGridPos.y);
|
|
|
|
Vector3 viewerEye = viewerPosition + Vector3.up * _fogSystem.viewerEyeHeight;
|
|
Vector3 toCell = cellWorldPos - viewerPosition;
|
|
float horizontalDistance = new Vector2(toCell.x, toCell.z).magnitude;
|
|
|
|
// Outside vision range
|
|
if (horizontalDistance > visionRange)
|
|
return false;
|
|
|
|
// Calculate angle to cell
|
|
float angle = Mathf.Atan2(toCell.z, toCell.x) * Mathf.Rad2Deg;
|
|
if (angle < 0) angle += 360f;
|
|
|
|
// Find corresponding sector
|
|
int sectorIndex = Mathf.FloorToInt(angle / _fogSystem.raycastAngularStep) % _sectorCount;
|
|
|
|
// Check if blocked by obstacle in this sector
|
|
if (_sectors[sectorIndex].hasObstacle)
|
|
{
|
|
// Dynamic tolerance to handle large mesh colliders
|
|
// Large rocks can be hit several units before their center
|
|
// Use cell size + generous buffer for very large obstacles
|
|
float distanceTolerance = _fogSystem.cellSize * 5.0f + 3.0f;
|
|
|
|
// Height-based blocking check
|
|
if (_fogSystem.enableHeightBlocking && _sectors[sectorIndex].obstacleHeight >= _fogSystem.minBlockingHeight)
|
|
{
|
|
float obstacleDistance = _sectors[sectorIndex].blockedDistance;
|
|
|
|
// If cell is beyond obstacle (with tolerance), check if obstacle blocks the sight line
|
|
if (horizontalDistance > obstacleDistance + distanceTolerance)
|
|
{
|
|
// Calculate sight line angle to cell
|
|
float verticalAngleToCell = Mathf.Atan2(cellWorldPos.y - viewerEye.y, horizontalDistance);
|
|
|
|
// Calculate obstacle top height
|
|
float obstacleTopHeight = _sectors[sectorIndex].obstaclePosition.y + _sectors[sectorIndex].obstacleHeight;
|
|
|
|
// Calculate angle to obstacle top
|
|
float verticalAngleToObstacleTop = Mathf.Atan2(obstacleTopHeight - viewerEye.y, obstacleDistance);
|
|
|
|
// If sight line passes below obstacle top, it's blocked
|
|
if (verticalAngleToCell <= verticalAngleToObstacleTop)
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Simple distance-based blocking (no height consideration)
|
|
// Use tolerance to allow objects at the obstacle position to be visible
|
|
if (horizontalDistance > _sectors[sectorIndex].blockedDistance + distanceTolerance)
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Detailed raycasting for edge cases
|
|
if (_fogSystem.useDetailedRaycasting)
|
|
{
|
|
float distanceTolerance = _fogSystem.cellSize * 3.0f + 2.0f;
|
|
int prevSector = (sectorIndex - 1 + _sectorCount) % _sectorCount;
|
|
int nextSector = (sectorIndex + 1) % _sectorCount;
|
|
|
|
if (_sectors[prevSector].hasObstacle && horizontalDistance > _sectors[prevSector].blockedDistance + distanceTolerance)
|
|
return false;
|
|
if (_sectors[nextSector].hasObstacle && horizontalDistance > _sectors[nextSector].blockedDistance + distanceTolerance)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 전장의 안개 시스템 - 플레이어별 시야 관리
|
|
/// </summary>
|
|
public class FogOfWarSystem : NetworkBehaviour
|
|
{
|
|
public static FogOfWarSystem Instance { get; private set; }
|
|
|
|
[Header("Grid Settings")]
|
|
public int gridWidth = 100;
|
|
public int gridHeight = 100;
|
|
public float cellSize = 1f;
|
|
public Vector3 worldOrigin = Vector3.zero;
|
|
|
|
[Header("Visibility Settings")]
|
|
public float updateInterval = 0.2f;
|
|
|
|
[Header("Line of Sight Settings")]
|
|
[Tooltip("Enable line-of-sight blocking by obstacles")]
|
|
public bool enableLineOfSight = true;
|
|
|
|
[Tooltip("Layers that block vision (buildings, obstacles, terrain)")]
|
|
public LayerMask visionBlockingLayers = ~0;
|
|
|
|
[Tooltip("Angular resolution for raycasting (degrees). Lower = more accurate, higher = better performance")]
|
|
[Range(1f, 15f)]
|
|
public float raycastAngularStep = 6f;
|
|
|
|
[Tooltip("Use detailed raycasting (more accurate but slower)")]
|
|
public bool useDetailedRaycasting = false;
|
|
|
|
[Header("Height-Based Visibility")]
|
|
[Tooltip("Enable height-based vision blocking (tall obstacles block vision)")]
|
|
public bool enableHeightBlocking = true;
|
|
|
|
[Tooltip("Viewer eye height for line-of-sight calculations")]
|
|
public float viewerEyeHeight = 1.5f;
|
|
|
|
[Tooltip("Minimum obstacle height to block vision")]
|
|
public float minBlockingHeight = 2.0f;
|
|
|
|
// 서버: 각 플레이어별 가시성 맵
|
|
private Dictionary<ulong, FogOfWarData> _serverFogData = new Dictionary<ulong, FogOfWarData>();
|
|
|
|
// 클라이언트: 로컬 플레이어의 가시성 맵
|
|
private FogOfWarData _localFogData;
|
|
|
|
private List<IVisionProvider> _visionProviders = new List<IVisionProvider>();
|
|
private float _updateTimer;
|
|
private LineOfSightCalculator _losCalculator;
|
|
|
|
private void Awake()
|
|
{
|
|
if (Instance != null && Instance != this)
|
|
{
|
|
Destroy(gameObject);
|
|
return;
|
|
}
|
|
Instance = this;
|
|
_losCalculator = new LineOfSightCalculator(this);
|
|
}
|
|
|
|
public override void OnNetworkSpawn()
|
|
{
|
|
base.OnNetworkSpawn();
|
|
|
|
if (IsServer)
|
|
{
|
|
// Server: Register client connected callback to initialize fog data
|
|
NetworkManager.Singleton.OnClientConnectedCallback += OnClientConnected;
|
|
}
|
|
|
|
if (IsClient && !IsServer)
|
|
{
|
|
// 클라이언트는 로컬 데이터 초기화
|
|
_localFogData = new FogOfWarData(gridWidth, gridHeight);
|
|
Debug.Log($"<color=cyan>[FogOfWar] 클라이언트 {NetworkManager.LocalClientId} 초기화</color>");
|
|
}
|
|
}
|
|
|
|
private void OnClientConnected(ulong clientId)
|
|
{
|
|
if (!IsServer) return;
|
|
|
|
// Ensure fog data exists for this client
|
|
if (!_serverFogData.ContainsKey(clientId))
|
|
{
|
|
_serverFogData[clientId] = new FogOfWarData(gridWidth, gridHeight);
|
|
Debug.Log($"<color=cyan>[FogOfWar] 클라이언트 {clientId} 안개 데이터 초기화</color>");
|
|
}
|
|
}
|
|
|
|
public override void OnNetworkDespawn()
|
|
{
|
|
base.OnNetworkDespawn();
|
|
|
|
if (IsServer && NetworkManager.Singleton != null)
|
|
{
|
|
NetworkManager.Singleton.OnClientConnectedCallback -= OnClientConnected;
|
|
}
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (!IsServer) return;
|
|
|
|
_updateTimer += Time.deltaTime;
|
|
if (_updateTimer >= updateInterval)
|
|
{
|
|
_updateTimer = 0f;
|
|
UpdateAllVision();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 시야 제공자 등록 (플레이어, 건물 등)
|
|
/// </summary>
|
|
public void RegisterVisionProvider(IVisionProvider provider)
|
|
{
|
|
if (!_visionProviders.Contains(provider))
|
|
{
|
|
_visionProviders.Add(provider);
|
|
// Debug.Log($"<color=cyan>[FogOfWar] Vision Provider 등록: {provider.GetTransform().name} (Owner: {provider.GetOwnerId()})</color>");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 시야 제공자 등록 해제
|
|
/// </summary>
|
|
public void UnregisterVisionProvider(IVisionProvider provider)
|
|
{
|
|
_visionProviders.Remove(provider);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 플레이어별 FogOfWar 데이터 가져오기
|
|
/// </summary>
|
|
public FogOfWarData GetPlayerFogData(ulong clientId)
|
|
{
|
|
// 클라이언트는 자신의 로컬 데이터 반환
|
|
if (IsClient && !IsServer)
|
|
{
|
|
return _localFogData;
|
|
}
|
|
|
|
// 서버는 해당 클라이언트의 데이터 반환
|
|
if (!_serverFogData.ContainsKey(clientId))
|
|
{
|
|
_serverFogData[clientId] = new FogOfWarData(gridWidth, gridHeight);
|
|
}
|
|
return _serverFogData[clientId];
|
|
}
|
|
|
|
/// <summary>
|
|
/// 모든 시야 업데이트 (서버만)
|
|
/// </summary>
|
|
private void UpdateAllVision()
|
|
{
|
|
// 각 플레이어의 현재 시야 초기화
|
|
foreach (var fogData in _serverFogData.Values)
|
|
{
|
|
fogData.ClearCurrentVision();
|
|
}
|
|
|
|
// 모든 시야 제공자의 시야 범위 계산
|
|
foreach (var provider in _visionProviders)
|
|
{
|
|
if (provider == null || !provider.IsActive()) continue;
|
|
|
|
ulong ownerId = provider.GetOwnerId();
|
|
if (!_serverFogData.ContainsKey(ownerId))
|
|
{
|
|
_serverFogData[ownerId] = new FogOfWarData(gridWidth, gridHeight);
|
|
}
|
|
|
|
Vector3 position = provider.GetTransform().position;
|
|
float visionRange = provider.GetVisionRange();
|
|
|
|
RevealArea(ownerId, position, visionRange);
|
|
}
|
|
|
|
// 각 클라이언트에게 시야 데이터 전송
|
|
foreach (var kvp in _serverFogData)
|
|
{
|
|
ulong clientId = kvp.Key;
|
|
FogOfWarData fogData = kvp.Value;
|
|
|
|
// 압축된 데이터로 전송
|
|
byte[] visibleData = fogData.GetVisibleData();
|
|
byte[] exploredData = fogData.GetExploredData();
|
|
|
|
SendFogDataToClientRpc(visibleData, exploredData,
|
|
new ClientRpcParams
|
|
{
|
|
Send = new ClientRpcSendParams
|
|
{
|
|
TargetClientIds = new ulong[] { clientId }
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 클라이언트에게 안개 데이터 전송
|
|
/// </summary>
|
|
[ClientRpc]
|
|
private void SendFogDataToClientRpc(byte[] visibleData, byte[] exploredData, ClientRpcParams clientRpcParams = default)
|
|
{
|
|
if (_localFogData == null)
|
|
{
|
|
_localFogData = new FogOfWarData(gridWidth, gridHeight);
|
|
}
|
|
|
|
_localFogData.SetVisibleData(visibleData);
|
|
_localFogData.SetExploredData(exploredData);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 특정 영역을 밝힘 (서버만) - Line-of-Sight 지원
|
|
/// </summary>
|
|
private void RevealArea(ulong clientId, Vector3 worldPosition, float radius)
|
|
{
|
|
FogOfWarData fogData = _serverFogData[clientId];
|
|
Vector2Int gridPos = WorldToGrid(worldPosition);
|
|
|
|
int cellRadius = Mathf.CeilToInt(radius / cellSize);
|
|
|
|
// Line-of-sight raycasting if enabled
|
|
if (enableLineOfSight)
|
|
{
|
|
_losCalculator.CalculateVisibleSectors(worldPosition, radius);
|
|
}
|
|
|
|
for (int x = -cellRadius; x <= cellRadius; x++)
|
|
{
|
|
for (int y = -cellRadius; y <= cellRadius; y++)
|
|
{
|
|
// Basic circular range check
|
|
if (x * x + y * y > cellRadius * cellRadius)
|
|
continue;
|
|
|
|
int gridX = gridPos.x + x;
|
|
int gridY = gridPos.y + y;
|
|
|
|
if (gridX < 0 || gridX >= gridWidth || gridY < 0 || gridY >= gridHeight)
|
|
continue;
|
|
|
|
// Line-of-sight check
|
|
if (enableLineOfSight)
|
|
{
|
|
Vector2Int cellPos = new Vector2Int(gridX, gridY);
|
|
if (!_losCalculator.IsCellVisible(worldPosition, cellPos, radius))
|
|
continue;
|
|
}
|
|
|
|
// 현재 시야에 표시 + 방문한 적 있음으로 기록
|
|
fogData.SetVisible(gridX, gridY, true);
|
|
fogData.SetExplored(gridX, gridY, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 월드 좌표를 그리드 좌표로 변환
|
|
/// </summary>
|
|
public Vector2Int WorldToGrid(Vector3 worldPos)
|
|
{
|
|
Vector3 localPos = worldPos - worldOrigin;
|
|
int x = Mathf.FloorToInt(localPos.x / cellSize);
|
|
int z = Mathf.FloorToInt(localPos.z / cellSize);
|
|
return new Vector2Int(x, z);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 그리드 좌표를 월드 좌표로 변환
|
|
/// </summary>
|
|
public Vector3 GridToWorld(int x, int y)
|
|
{
|
|
return worldOrigin + new Vector3(x * cellSize, 0, y * cellSize);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 특정 위치가 플레이어에게 보이는지 확인
|
|
/// </summary>
|
|
public FogOfWarState GetVisibilityState(ulong clientId, Vector3 worldPosition)
|
|
{
|
|
FogOfWarData fogData = GetPlayerFogData(clientId);
|
|
if (fogData == null)
|
|
return FogOfWarState.Unexplored;
|
|
|
|
Vector2Int gridPos = WorldToGrid(worldPosition);
|
|
return fogData.GetState(gridPos.x, gridPos.y);
|
|
}
|
|
|
|
private void OnDrawGizmos()
|
|
{
|
|
// 그리드 시각화
|
|
Gizmos.color = Color.yellow;
|
|
Vector3 size = new Vector3(gridWidth * cellSize, 0.1f, gridHeight * cellSize);
|
|
Gizmos.DrawWireCube(worldOrigin + size / 2f, size);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 플레이어별 안개 데이터
|
|
/// </summary>
|
|
public class FogOfWarData
|
|
{
|
|
private bool[,] _explored; // 한번이라도 방문한 적이 있는가
|
|
private bool[,] _currentlyVisible; // 현재 보이는가
|
|
private int _width;
|
|
private int _height;
|
|
|
|
public FogOfWarData(int width, int height)
|
|
{
|
|
_width = width;
|
|
_height = height;
|
|
_explored = new bool[width, height];
|
|
_currentlyVisible = new bool[width, height];
|
|
}
|
|
|
|
public void SetExplored(int x, int y, bool value)
|
|
{
|
|
if (IsValidCoord(x, y))
|
|
_explored[x, y] = value;
|
|
}
|
|
|
|
public void SetVisible(int x, int y, bool value)
|
|
{
|
|
if (IsValidCoord(x, y))
|
|
_currentlyVisible[x, y] = value;
|
|
}
|
|
|
|
public void ClearCurrentVision()
|
|
{
|
|
System.Array.Clear(_currentlyVisible, 0, _currentlyVisible.Length);
|
|
}
|
|
|
|
public FogOfWarState GetState(int x, int y)
|
|
{
|
|
if (!IsValidCoord(x, y))
|
|
return FogOfWarState.Unexplored;
|
|
|
|
if (_currentlyVisible[x, y])
|
|
return FogOfWarState.Visible;
|
|
|
|
if (_explored[x, y])
|
|
return FogOfWarState.Explored;
|
|
|
|
return FogOfWarState.Unexplored;
|
|
}
|
|
|
|
private bool IsValidCoord(int x, int y)
|
|
{
|
|
return x >= 0 && x < _explored.GetLength(0) &&
|
|
y >= 0 && y < _explored.GetLength(1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Visible 데이터를 바이트 배열로 압축
|
|
/// </summary>
|
|
public byte[] GetVisibleData()
|
|
{
|
|
int totalCells = _width * _height;
|
|
int byteCount = (totalCells + 7) / 8; // 8비트 = 1바이트
|
|
byte[] data = new byte[byteCount];
|
|
|
|
for (int i = 0; i < totalCells; i++)
|
|
{
|
|
int x = i % _width;
|
|
int y = i / _width;
|
|
|
|
if (_currentlyVisible[x, y])
|
|
{
|
|
int byteIndex = i / 8;
|
|
int bitIndex = i % 8;
|
|
data[byteIndex] |= (byte)(1 << bitIndex);
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Explored 데이터를 바이트 배열로 압축
|
|
/// </summary>
|
|
public byte[] GetExploredData()
|
|
{
|
|
int totalCells = _width * _height;
|
|
int byteCount = (totalCells + 7) / 8;
|
|
byte[] data = new byte[byteCount];
|
|
|
|
for (int i = 0; i < totalCells; i++)
|
|
{
|
|
int x = i % _width;
|
|
int y = i / _width;
|
|
|
|
if (_explored[x, y])
|
|
{
|
|
int byteIndex = i / 8;
|
|
int bitIndex = i % 8;
|
|
data[byteIndex] |= (byte)(1 << bitIndex);
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 바이트 배열에서 Visible 데이터 복원
|
|
/// </summary>
|
|
public void SetVisibleData(byte[] data)
|
|
{
|
|
System.Array.Clear(_currentlyVisible, 0, _currentlyVisible.Length);
|
|
|
|
int totalCells = _width * _height;
|
|
for (int i = 0; i < totalCells && i / 8 < data.Length; i++)
|
|
{
|
|
int byteIndex = i / 8;
|
|
int bitIndex = i % 8;
|
|
|
|
bool isVisible = (data[byteIndex] & (1 << bitIndex)) != 0;
|
|
|
|
int x = i % _width;
|
|
int y = i / _width;
|
|
_currentlyVisible[x, y] = isVisible;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 바이트 배열에서 Explored 데이터 복원
|
|
/// </summary>
|
|
public void SetExploredData(byte[] data)
|
|
{
|
|
int totalCells = _width * _height;
|
|
for (int i = 0; i < totalCells && i / 8 < data.Length; i++)
|
|
{
|
|
int byteIndex = i / 8;
|
|
int bitIndex = i % 8;
|
|
|
|
bool isExplored = (data[byteIndex] & (1 << bitIndex)) != 0;
|
|
|
|
int x = i % _width;
|
|
int y = i / _width;
|
|
|
|
// Explored는 누적 (한번 탐색하면 계속 유지)
|
|
if (isExplored)
|
|
_explored[x, y] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 안개 상태
|
|
/// </summary>
|
|
public enum FogOfWarState
|
|
{
|
|
Unexplored, // 방문한 적 없음 (완전히 어두움)
|
|
Explored, // 방문했지만 현재 시야 밖 (지형/건물만 보임)
|
|
Visible // 현재 시야 안 (모두 보임)
|
|
}
|
|
} |