/// <summary>
/// 공격 가능한 타일들을 모두 삭제한다.
/// </summary>
private void ClearAttackables()
{
if (m_AttackableTiles == null)
{
return;
}
if (m_AttackableTiles.Count == 0)
{
return;
}
Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();
foreach (var item in m_AttackableTiles)
{
//if ( item.m_State.m_State != eTileType.Attackable )
//{
// continue;
//}
item.m_State = null;
item.m_State = new TileStateUnitPlaced(item.m_Position);
SquareTile unitTile = SquareTileFactory.CreateUnitPlaced(item.m_Position);
m_Tilemap.SetTile(unitTile.m_Position, unitTile);
costs.Add(item.m_Position, 0f);
}
m_Grid.UpdateGrid(costs);
}
/// <summary>
/// 해당 위치에 타일을 삭제한다.
/// </summary>
/// <param name="_position"></param>
public void DeleteTile(Vector3Int _position)
{
SquareTile tile = m_Tilemap.GetTile <SquareTile>(_position);
if (tile == null)
{
return;
}
// 이동 가능한 타일 / 유닛이 위치한 타일 / 이동 경로 타일 일 때는 삭제할 필요가 없다.
if (tile.m_State.m_State == eTileType.Movable)
{
return;
}
// 그 외의 타일일 경우에는 일반 타일로 교체한다.
tile.m_State = null;
tile.m_State = new TileStateNormal(tile.m_Position);
SquareTile normalTile = SquareTileFactory.CreateNormal(tile.m_Position);
m_Tilemap.SetTile(normalTile.m_Position, normalTile);
m_TilemapPathFind.m_Grid.UpdateTile(_position, 0f);
}
/// <summary>
/// 유닛을 실제로 이동 시키고 각종 초기화를 수행한다.
/// </summary>
/// <param name="_path"></param>
/// <returns></returns>
IEnumerator MoveCoroutine(HashSet <Vector3Int> _path, Vector3Int _targetPosition)
{
SquareTile item = Map.instance.m_TilemapHighlight.m_Tilemap.GetTile <SquareTile>(m_Position);
item.m_State = null;
item.m_State = new TileStateNormal(m_Position);
SquareTile normalTile = SquareTileFactory.CreateNormal(m_Position);
Map.instance.m_TilemapHighlight.m_Tilemap.SetTile(normalTile.m_Position, normalTile);
foreach (Vector3Int point in _path)
{
Vector3 pos = m_SetCenterPosition.GetWorldPosition(point);
transform.DOMove(pos, 1f);
yield return(new WaitForSeconds(1f));
if (point == _targetPosition)
{
break;
}
}
// 초기화
SetToIdle();
SetPosition(_targetPosition, true);
InitTiles();
}
/// <summary>
/// 현재 마우스 위치에 선택된 타일을 반환한다.
/// </summary>
private SquareTile SelectedTile()
{
Vector3 worldPosition = m_Camera.ScreenToWorldPoint(Input.mousePosition);
Vector3Int cellPosition = m_Tilemap.WorldToCell(worldPosition);
// 예외 처리
if (cellPosition.x >= m_Bounds.xMax || cellPosition.x < m_Bounds.xMin)
{
return(null);
}
if (cellPosition.y >= m_Bounds.yMax || cellPosition.y < m_Bounds.yMin)
{
return(null);
}
SquareTile tile = m_Tilemap.GetTile <SquareTile>(cellPosition);
tile.m_Position = cellPosition;
Debug.Log("selected tile = " + tile.m_Position + " : type = " + tile.m_State.m_State);
UnitKnight knight = UnitManager.GetReadyToMovePlayer();
if (knight != null)
{
tile.m_State.SetUnitPlacedTile(knight.m_Position);
}
tile.m_State.OnClicked();
return(tile);
}
/// <summary>
/// 이동 가능한 영역의 타일들을 모두 삭제한다.
/// </summary>
public void ClearMovableTiles()
{
if (m_MovableTiles == null)
{
return;
}
if (m_MovableTiles.Count == 0)
{
return;
}
Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();
foreach (var item in m_MovableTiles)
{
if (item.m_State.m_State != eTileType.Movable)
{
continue;
}
item.m_State = null;
item.m_State = new TileStateNormal(item.m_Position);
SquareTile normalTile = SquareTileFactory.CreateNormal(item.m_Position);
m_Tilemap.SetTile(normalTile.m_Position, normalTile);
costs.Add(item.m_Position, 0f);
}
m_Grid.UpdateGrid(costs);
}
void AddTile(UIElement large, UIElement small)
{
WideTile wide = WideTile.CreateTileWideImage(RenderTreeToImage(large));
SquareTile square = SquareTile.CreateTileSquareImage(RenderTreeToImage(small));
LiveTileManager.UpdateTile(wide, square, true);
}
/// <summary>
/// 타일 에셋을 불러들인다.
/// </summary>
private static void LoadTiles()
{
m_NormalTile = Resources.Load <SquareTile>("Palettes/Tiles/BlankTile 1");
m_SelectedTile = Resources.Load <SquareTile>("Palettes/Tiles/SelectedTile 1");
m_MovableTile = Resources.Load <SquareTile>("Palettes/Tiles/MovableTile 1");
m_AttackableTile = Resources.Load <SquareTile>("Palettes/Tiles/AttackableTile 1");
m_UnitPlacedTile = Resources.Load <SquareTile>("Palettes/Tiles/BlankTile 1");
}
public void Setup(TileLayouter _owner, SquareTile _parent, int _zoomLevel, int _index, int _levelCount)
{
parent = _parent;
name = _zoomLevel.ToString() + "-" + _index;
Setup(_owner, _zoomLevel, _levelCount);
}
private void InitTiles()
{
SquareTile tile = ScriptableObject.CreateInstance <SquareTile>();
tile.m_Position = m_Position;
tile.m_State = new TileStateNormal(tile.m_Position);
m_CurrentTile = SquareTileFactory.CreateNormal(tile.m_Position);
Map.instance.m_TilemapHighlight.m_Tilemap.SetTile(m_Position, m_CurrentTile);
Map.instance.m_TilemapController.ResetAllTiles();
Map.instance.m_TilemapController.SetAllUnitPlacedTiles();
}
public void MCCoinSimulation_UniformRandom_Run_Test()
{
var settings = MCSimulationSettings.Create(numberTrials: 100000);
var randomEngineService = new Random2DEngineService();
var coin = Coin.CreateWithDiameter(1.0);
var squareTile = SquareTile.Create(2.0);
var simulation = new MCCoinSimulation(settings, randomEngineService);
simulation.Finished += results => { Assert.AreEqual(0.75, Math.Round(results.Probability, 2)); };
simulation.Run(coin: coin, squareTile: squareTile, method: SamplingMethod.RandomUniform);
}
void Select()
{
if (Input.GetButtonDown("Forward"))
{
if (!bUnitMenu)
{
if (!bIsChooseMove && !bIsChooseAttack)
{
SquareTile current = squareCoord[currentActiveSquare[0], currentActiveSquare[1]];
if (current.currentUnit != null)
{
bIsSummoner = current.currentUnit.bIsSummoner;
unitMenu.Activate(bIsSummoner);
bUnitMenu = true;
}
}
else
{
SquareTile current = squareCoord[currentActiveSquare[0], currentActiveSquare[1]];
if (listFloodFillResult.Contains(current))
{
if (bIsChooseAttack)
{
//TODO attack
print("attack this");
}
else if (bIsChooseMove)
{
//TODO move
print("move here");
}
}
}
}
}
if (Input.GetButtonDown("Back"))
{
Back();
}
if (Input.GetButtonDown("Cancel"))
{
if (bUnitMenu || bIsChooseAttack || bIsChooseMove)
{
Back();
}
else
{
}
}
}
public static SquareTile CreateGrid(Vector3Int _position)
{
SquareTile tile = ScriptableObject.CreateInstance <SquareTile>();
tile.sprite = TurnBasedGameKit.DemoUnityTilemap.ResourcesLoader.m_GridSprite;
tile.m_Position = _position;
tile.m_Cost = 0;
tile.m_Distance = 0;
tile.m_State = new TileStateOutline(_position);
tile.m_State.m_Tile = tile;
tile.m_Unit = UnitManager.GetUnitAt(_position);
return(tile);
}
/// <summary>
/// 유닛이 위치한 타일을 제외하고 모든 타일들을 모두 지운다.
/// </summary>
public void ResetAllTiles()
{
Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();
for (int x = m_Bounds.xMin; x < m_Bounds.xMax; x++)
{
for (int y = m_Bounds.yMin; y < m_Bounds.yMax; y++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
SquareTile tile = m_Tilemap.GetTile <SquareTile>(pos);
// 유닛이 위치한 타일은 초기화 할 필요 없다.
//if ( tile.m_State.m_State == eTileType.UnitPlaced )
//{
// //tile.m_Cost = 0;
// //tile.m_Distance = 0;
// //m_Tilemap.SetTile( tile.m_Position, tile );
// continue;
//}
// 타일 위에 유닛이 없으면 일반 타일로 초기화시킨다.
//else
{
tile.m_State = null;
tile.m_State = new TileStateNormal(tile.m_Position);
SquareTile normalTile = SquareTileFactory.CreateNormal(tile.m_Position);
m_Tilemap.SetTile(normalTile.m_Position, normalTile);
costs.Add(tile.m_Position, 0f);
}
}
}
// 테스트 코드
//for ( int x = m_Bounds.xMin; x < m_Bounds.xMax; x++ )
//{
// for ( int y = m_Bounds.yMin; y < m_Bounds.yMax; y++ )
// {
// Vector3Int pos = new Vector3Int( x, y, 0 );
// SquareTile tile = m_Tilemap.GetTile<SquareTile>( pos );
// if ( tile.m_Distance != 0 )
// {
// Debug.Log( pos );
// }
// }
//}
m_TilemapPathFind.m_Grid.UpdateGrid(costs);
}
/// <summary>
/// 해당 위치를 기준으로 이동 가능한 타일들을 표시한다.
/// </summary>
/// <param name="_start"></param>
public void DrawMovableRange(Unit _unit, SquareTile _start)
{
m_MovableTiles = SearchToMove(_start, _unit.m_Stat.m_MoveRange);
if (m_MovableTiles.Count == 0)
{
return;
}
Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();
HashSet <Vector3Int> obstacles = Map.instance.m_TilemapObstacle.GetObstacleTiles();
foreach (var tile in m_MovableTiles)
{
bool isObstacle = false;
// 장애물이 있을 경우, 장애물 타일로 변경
foreach (var point in obstacles)
{
if (point == tile.m_Position)
{
tile.m_State = null;
tile.m_State = new TileStateObstacle(tile.m_Position);
SquareTile obstacle = SquareTileFactory.CreateObstacle(tile.m_Position);
m_Tilemap.SetTile(obstacle.m_Position, obstacle);
costs.Add(obstacle.m_Position, 0f);
isObstacle = true;
break;
}
}
// 장애물이 아닐 경우,
if (isObstacle == false)
{
tile.m_State = null;
tile.m_State = new TileStateMovable(tile.m_Position);
SquareTile moveTile = SquareTileFactory.CreateMovable(tile.m_Position);
m_Tilemap.SetTile(moveTile.m_Position, moveTile);
costs.Add(tile.m_Position, 1f);
}
}
m_Grid.UpdateGrid(costs);
}
/// <summary>
/// 해당 위치를 기준으로 공격 가능한 타일들을 표시한다.
/// </summary>
/// <param name="_unit"></param>
/// <param name="_start"></param>
public void DrawAttackableRange(Unit _unit, SquareTile _start)
{
m_AttackableTiles = SearchToAttack(_start, _unit.m_Stat.m_AttackRange);
if (m_AttackableTiles.Count == 0)
{
return;
}
Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();
HashSet <Vector3Int> obstacles = Map.instance.m_TilemapObstacle.GetObstacleTiles();
foreach (var tile in m_AttackableTiles)
{
bool isObstacle = false;
// 장애물이 있을 경우, 장애물 타일로 변경
foreach (var point in obstacles)
{
if (point == tile.m_Position)
{
tile.m_State = null;
tile.m_State = new TileStateObstacle(tile.m_Position);
SquareTile obstacle = SquareTileFactory.CreateObstacle(tile.m_Position);
m_Tilemap.SetTile(tile.m_Position, obstacle);
costs.Add(tile.m_Position, 0f);
isObstacle = true;
break;
}
}
// 장애물이 아니고 타일 위에 적 캐릭터가 있으면 공격 가능한 타일로 설정한다.
if (isObstacle == false && tile.m_Unit.m_Type == eCampType.Enemies)
{
tile.m_State = null;
tile.m_State = new TileStateAttackable(tile.m_Position);
SquareTile attackTile = SquareTileFactory.CreateAttackable(tile.m_Position);
m_Tilemap.SetTile(attackTile.m_Position, attackTile);
costs.Add(tile.m_Position, 1f);
}
}
m_Grid.UpdateGrid(costs);
}
public void ResetTileDistance()
{
for (int x = m_Bounds.xMin; x < m_Bounds.xMax; x++)
{
for (int y = m_Bounds.yMin; y < m_Bounds.yMax; y++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
SquareTile tile = m_Tilemap.GetTile <SquareTile>(pos);
tile.m_Distance = 0;
m_Tilemap.SetTile(pos, tile);
}
}
}
/// <summary>
/// 마우스 버튼 클릭한 위치에 선택 타일 표시
/// </summary>
private void ProcessMouseUp()
{
if (m_SelectedTile != null)
{
m_PreviousTile = m_SelectedTile;
}
// 이전에 선택했던 타일은 삭제
if (m_PreviousTile != null)
{
m_TilemapController.DeleteTile(m_PreviousTile.m_Position);
}
// 현재 선택한 타일을 가져온다.
m_SelectedTile = SelectedTile();
}
/// <summary>
/// 이동할 범위 내에 있는 타일 리스트를 반환한다.
/// </summary>
/// <param name="start">유닛이 위치한 타일</param>
/// <returns></returns>
private HashSet <SquareTile> SearchToMove(SquareTile _start, int _range)
{
HashSet <SquareTile> movableTiles = new HashSet <SquareTile>();
Queue <SquareTile> checkNowQueue = new Queue <SquareTile>();
checkNowQueue.Enqueue(_start);
while (checkNowQueue.Count > 0)
{
SquareTile tile = checkNowQueue.Dequeue();
if (tile == null)
{
continue;
}
// 상, 하, 좌, 우로 검색해야 하기 때문에 4번 반복
for (int i = 0; i < 4; i++)
{
SquareTile nextTile = m_TilemapController.GetTileAt(tile.m_Position + m_Direction[i]);
if (nextTile == null)
{
continue;
}
// 유닛이 위치한 타일은 movableTiles에 추가하지 않는다.
//if ( nextTile.m_State.m_State == eTileType.UnitPlaced )
//{
// continue;
//}
nextTile.m_Distance = tile.m_Distance + 1;
// 이동 범위 보다 적은 타일만 이동 가능한 타일로 추가
if (nextTile.m_Distance < _range)
{
checkNowQueue.Enqueue(nextTile);
movableTiles.Add(nextTile);
}
}
}
movableTiles.Remove(_start);
return(movableTiles);
}
/// <summary>
/// 타일맵을 격자 형태의 타일들로 설정한다.
/// </summary>
private void CreateGridTiles()
{
for (int x = m_Bounds.xMin; x < m_Bounds.xMax; x++)
{
for (int y = m_Bounds.yMin; y < m_Bounds.yMax; y++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
SquareTile tile = ScriptableObject.CreateInstance <SquareTile>();
tile.m_Position = pos;
tile.m_State = new TileStateOutline(tile.m_Position);
SquareTile gridTile = SquareTileFactory.CreateGrid(tile.m_Position);
m_Tilemap.SetTile(gridTile.m_Position, gridTile);
}
}
}
public static SquareTile CreateObstacle(Vector3Int _position)
{
SquareTile tile = ScriptableObject.CreateInstance <SquareTile>();
tile.sprite = TurnBasedGameKit.DemoUnityTilemap.ResourcesLoader.m_NormalSprite;
Color color = Color.white;
tile.color = color;
tile.m_Position = _position;
tile.m_Cost = 0;
tile.m_Distance = 0;
tile.m_State = new TileStateObstacle(_position);
tile.m_State.m_Tile = tile;
tile.m_State.m_State = eTileType.Obstacle;
tile.m_Unit = UnitManager.GetUnitAt(_position);
return(tile);
}
public void LoadSquareTiles(LevelDescriptor levelConfiguration)
{
uint width = levelConfiguration.PlotWidth;
uint height = levelConfiguration.PlotLength;
List <ObjectiveStep> mandatorySteps = levelConfiguration.MandatorySteps;
BoundingBox2D tileBBox = GameObjectHelper.getBoundingBoxInWorld(TemplateTile.gameObject);
float sqWidth = GameObjectHelper.getWidthFromBBox(tileBBox);
float sqHeight = GameObjectHelper.getWidthFromBBox(tileBBox);
float sqDistance = sqWidth / 10; // distance between tiles
for (int plotY = 0; plotY < height; plotY++) //iterates through lines (y)
{
for (int plotX = 0; plotX < width; plotX++) //iterates through columns (x)
{
// Checks if this is a mandatory step, and obtains info
ObjectiveStep step = levelConfiguration.MandatorySteps.Where(s => s.CoordinateInPlot.x == plotX && s.CoordinateInPlot.y == plotY).FirstOrDefault();
// Creates the tile
SquareTile tile = (plotX + plotY) == 0 ? TemplateTile : TemplateTile.CloneThisTile();
//tile.transform.parent = TemplateTile.gameObject.transform.parent;
//tile.transform.position = TemplateTile.transform.position;
// Sets the tile colour
tile.SetColour(step == null ? SquareTile.STExpectedState.NOT_TO_STEP :
(step.SpecialAction ? SquareTile.STExpectedState.TO_EXECUTE_SPECIAL_ACTION : SquareTile.STExpectedState.TO_STEP));
// Sets the coordinates text display
tile.SetCoordinateText(plotX, plotY);
// Creates a new position
Vector3 newTilePos = tile.transform.position;
newTilePos.x += plotX * (sqWidth + sqDistance);
newTilePos.y += plotY * (sqHeight + sqDistance);
// Sets the new position
tile.transform.position = newTilePos;
squareTiles.Add(tile);
}
}
}
/// <summary>
/// Tilemap에 SquareTile들로 설정한다.
/// </summary>
private void CreateTilesToNormal()
{
// Tilemap 크기에 맞추어 SquareTile들을 생성한다.
for (int x = m_Bounds.xMin; x < m_Bounds.xMax; x++)
{
for (int y = m_Bounds.yMin; y < m_Bounds.yMax; y++)
{
Vector3Int current = new Vector3Int(x, y, 0);
SquareTile normal = ScriptableObject.CreateInstance <SquareTile>();
normal.m_Position = new Vector3Int(x, y, 0);
normal.m_Cost = 1f;
normal.m_State = new TileStateNormal(normal.m_Position);
SquareTile tile = SquareTileFactory.CreateNormal(normal.m_Position);
m_Tilemap.SetTile(current, tile);
}
}
}
/// <summary>
/// 지정한 위치의 타일을 유닛이 위치한 타일로 설정한다.
/// </summary>
/// <param name="_position"></param>
public void SetTileAsUnitPlaced(Vector3Int _position)
{
SquareTile tile = ScriptableObject.CreateInstance <SquareTile>();
tile.m_Position = _position;
tile.m_Cost = 0f;
tile.m_State = null;
tile.m_State = new TileStateUnitPlaced(tile.m_Position);
SquareTile unitTile = SquareTileFactory.CreateUnitPlaced(tile.m_Position);
unitTile.m_Unit = UnitManager.GetUnitAt(_position);
if (unitTile.m_Unit == null)
{
Debug.LogError("unitTile.m_Unit == null");
return;
}
m_Tilemap.SetTile(unitTile.m_Position, unitTile);
}
public void ResetAllExceptMoveTiles()
{
Dictionary <Vector3Int, float> costs = new Dictionary <Vector3Int, float>();
for (int x = m_Bounds.xMin; x < m_Bounds.xMax; x++)
{
for (int y = m_Bounds.yMin; y < m_Bounds.yMax; y++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
SquareTile tile = m_Tilemap.GetTile <SquareTile>(pos);
//if ( tile.m_State.m_State == eTileType.UnitPlaced )
//{
// continue;
//}
/*else */ if (tile.m_State.m_State == eTileType.Movable)
{
continue;
}
//else if ( tile.m_State.m_State == eTileType.Path )
//{
// continue;
//}
//else if ( tile.m_State.m_State == eTileType.Attackable )
//{
// continue;
//}
else
{
tile.m_State = null;
tile.m_State = new TileStateNormal(tile.m_Position);
SquareTile normalTile = SquareTileFactory.CreateNormal(tile.m_Position);
m_Tilemap.SetTile(normalTile.m_Position, normalTile);
costs.Add(tile.m_Position, 0f);
}
}
}
m_TilemapPathFind.m_Grid.UpdateGrid(costs);
}
IEnumerator DrawFourSquare(int _layerCount)
{
Debug.Log(name);
var nexZoo = zoomLevel + 1;
var nexLayCou = _layerCount - 1;
Vector3 nexLeveScal = myRect.localScale / 2;
float halfLength = myRect.sizeDelta.x / 4;
// four square centers
Vector2 center01 = (Vector2.up + Vector2.left) * halfLength;
Vector2 center02 = (Vector2.up + Vector2.right) * halfLength;
Vector2 center03 = (Vector2.left + Vector2.down) * halfLength;
Vector2 center04 = (Vector2.down + Vector2.right) * halfLength;
//Instantiate
til01 = owner.Instantiater(transform);
yield return(null);
til02 = owner.Instantiater(transform);
yield return(null);
til03 = owner.Instantiater(transform);
yield return(null);
til04 = owner.Instantiater(transform);
yield return(null);
til01.Setup(owner, this, nexZoo, 1, nexLayCou);
til02.Setup(owner, this, nexZoo, 2, nexLayCou);
til03.Setup(owner, this, nexZoo, 3, nexLayCou);
til04.Setup(owner, this, nexZoo, 4, nexLayCou);
til01.myRect.localScale = nexLeveScal;
til02.myRect.localScale = nexLeveScal;
til03.myRect.localScale = nexLeveScal;
til04.myRect.localScale = nexLeveScal;
til01.myRect.localPosition = center01;
til02.myRect.localPosition = center02;
til03.myRect.localPosition = center03;
til04.myRect.localPosition = center04;
}
public override void OnClicked()
{
base.OnClicked();
// 선택된 타일로 설정
SquareTile tile = SquareTileFactory.CreateSelected(m_Position);
Map.instance.m_TilemapHighlight.m_Tilemap.SetTile(m_Position, tile);
// 이동 준비 상태의 플레이어가 있으면 대기 상태로 되돌린다
UnitKnight knight = UnitManager.GetReadyToMovePlayer();
if (knight != null)
{
knight.SetToIdle();
}
Map.instance.m_TilemapController.ResetAllTiles();
Map.instance.m_TilemapController.SetAllUnitPlacedTiles();
}
void GenerateMap()
{
GameObject TileGroup = new GameObject();
TileGroup.name = "TileGroup";
map = new List <List <SquareTile> >();
for (int i = 0; i < mapSize; i++)
{
List <SquareTile> Row = new List <SquareTile>();
for (int j = 0; j < mapSize; j++)
{
SquareTile tile = ((GameObject)Instantiate(TilePrefab, new Vector3(i - Mathf.Floor(mapSize / 2), 0, -j + Mathf.Floor(mapSize / 2)), Quaternion.Euler(new Vector3()))).GetComponent <SquareTile>();
tile.gridPosition = new Vector2(i, j);
tile.transform.parent = TileGroup.transform; //Adiciona o Tile ao GameObject groupTile
Row.Add(tile);
}
map.Add(Row);
}
}
/// <summary>
/// 유닛의 위치를 설정한다.
/// </summary>
/// <param name="_position"></param>
public void SetPosition(Vector3Int _position, bool _addOffset = false)
{
m_Position = _position;
m_SetZOrder.SetSortingOrder(m_Position.y);
Vector3 worldPosition = Vector3.zero;
if (_addOffset == true)
{
worldPosition = m_SetCenterPosition.GetWorldPosition(_position);
}
else
{
worldPosition = new Vector3(_position.x, _position.y, _position.z);
}
transform.position = new Vector3(worldPosition.x, worldPosition.y, worldPosition.z);
m_CurrentTile = Map.instance.m_TilemapHighlight.m_Tilemap.GetTile <SquareTile>(m_Position);
}
/// <summary>
/// 해당 위치를 기준으로 공격 가능한 캐릭터가 있으면 true를 반환한다.
/// </summary>
/// <param name="_unit"></param>
/// <param name="_start"></param>
/// <returns></returns>
public bool IsAttackable(Unit _unit, SquareTile _start)
{
HashSet <SquareTile> attackables = SearchToAttack(_start, _unit.m_Stat.m_AttackRange);
if (attackables.Count == 0)
{
return(false);
}
else
{
// 공격 가능한 타일에 적 캐릭터가 존재하면 true를 반환한다.
foreach (SquareTile item in attackables)
{
//if ( item.m_State.m_State == eTileType.UnitPlaced )
{
return(true);
}
}
return(false);
}
}
static void Main(string[] args)
{
var settings = MCSimulationSettings.Create(numberTrials: 1000000, reportEveryIteration: 10000);
var randomEngineService = new Random2DEngineService();
var simulation = new MCCoinSimulation(settings, randomEngineService);
simulation.ResultsUpdated += results =>
{
var prop = (double)results.NumberOfHits / (double)results.Iteration;
Console.WriteLine($"Iteration: {results.Iteration} " +
$"Hits: {results.NumberOfHits} " +
$"Probability: {prop}");
};
simulation.Finished += results => { Console.WriteLine($"MC simulation finished.\n{results}"); };
simulation.Run(Coin.CreateWithDiameter(1.0),
SquareTile.Create(10.0),
SamplingMethod.RandomUniform);
Console.ReadKey();
}
