public static sPosition GetPositionByDirection(sPosition position, eMoveDirection direction)
{
int moveX = position.x;
int moveY = position.y;
switch (direction)
{
case eMoveDirection.LEFT:
moveX--;
break;
case eMoveDirection.RIGHT:
moveX++;
break;
case eMoveDirection.UP:
moveY--;
break;
case eMoveDirection.DOWN:
moveY++;
break;
}
sPosition newPosition;
newPosition.x = moveX;
newPosition.y = moveY;
return(newPosition);
}
//Message
override public void ReceiveObjectMessage(MessageParam msgParam)
{
switch (msgParam.message)
{
case "Attack":
Debug.Log("recevie Attack!");
_damagePoint = msgParam.attackPoint;
SetAttacker(msgParam.sender);
sPosition curPosition;
curPosition.x = _tileX;
curPosition.y = _tileY;
sPosition attackedPosition;
attackedPosition.x = msgParam.sender.GetTileX();
attackedPosition.y = msgParam.sender.GetTileY();
eMoveDirection direction = GetDirection(curPosition, attackedPosition);
//SetNextDirection(direction);
//MoveStart(attackedPosition.x, attackedPosition.y);
_state.NextState(eStateType.DAMAGE);
break;
case "IsDead":
Debug.Log("I'm dead!");
Character msgSender = (Character)msgParam.sender;
IncreaseEXP(msgSender.GetEXP());
break;
}
}
public override void Update()
{
if (_character.EmptyPathFindingTileCell() == false)
{
TileCell tileCell = _character.PopPathFindingTileCell();
sPosition curPosition;
curPosition.x = _character.GetTileX();
curPosition.y = _character.GetTileY();
sPosition nextPosition;
nextPosition.x = tileCell.GetTileX();
nextPosition.y = tileCell.GetTileY();
eMoveDirection direction = GetDirection(curPosition, nextPosition);
_character.SetNextDirection(direction);
if ((_character.MoveStart(tileCell.GetTileX(), tileCell.GetTileY()) == false))
{
//_nextState = eStateType.ATTACK;
_nextState = eStateType.DISCOVER;
}
}
else
{
_nextState = eStateType.IDLE;
}
}
override public void Update()
{
eMoveDirection moveDirection = eMoveDirection.NONE;
if (Input.GetKeyDown(KeyCode.LeftArrow))
{
moveDirection = eMoveDirection.LEFT;
}
else if (Input.GetKeyDown(KeyCode.RightArrow))
{
moveDirection = eMoveDirection.RIGHT;
}
else if (Input.GetKeyDown(KeyCode.UpArrow))
{
moveDirection = eMoveDirection.UP;
}
else if (Input.GetKeyDown(KeyCode.DownArrow))
{
moveDirection = eMoveDirection.DOWN;
}
if (eMoveDirection.NONE != moveDirection)
{
_character.SetNextDirection(moveDirection);
_nextState = eStateType.MOVE;
}
}
public MotionControlCommand(byte vehicleNumber, eMoveDirection moveDirection, eSpeed speed, eLogicalDirection logicalDirection = eLogicalDirection.LogicalGo, byte movementTime = 0x00) :
base(eAgvCommandWord.MotionControl, vehicleNumber)
{
DNHead = vehicleNumber;
MoveDirection = moveDirection;
Speed = speed;
LogicalDirection = logicalDirection;
MovementTime = movementTime;
Check = (byte)(CommandWord + MoveDirection + (byte)Speed + (byte)LogicalDirection + MovementTime + Data5 + Data6 + Data7 + Data8 + Data9 + Data10 + Data11 + Data12 + Data13 + Data14 + Data15 + Data16);
}
sPosition GetDirectionTilePosition(eMoveDirection direction, sPosition position)
{
switch (direction)
{
case eMoveDirection.LEFT: position.x--; break;
case eMoveDirection.RIGHT: position.x++; break;
case eMoveDirection.UP: position.y--; break;
case eMoveDirection.DOWN: position.y++; break;
}
return(position);
}
public MainWindow()
{
InitializeComponent();
this.SourceInitialized += Window_SourceInitialized;
this.Loaded += Window_Loaded;
this.StateChanged += Window_StateChanged;
this.Closing += Window_Closing;
ShowInTaskbar = false;
MoveDirection = eMoveDirection.Up;
textBlockShoot1.PreviewMouseDown += TextBlockShoot_PreviewMouseDown;
textBlockShoot2.PreviewMouseDown += TextBlockShoot_PreviewMouseDown;
textBlockShoot3.PreviewMouseDown += TextBlockShoot3_PreviewMouseDown;
textBlock.Text = GetEnglish();
}
private void advanceInMatrix(eMoveDirection i_Direction, ref int io_CurrentRow, ref int io_CurrentCol, out bool o_ReachedEnd)
{
o_ReachedEnd = false;
int currentRow = io_CurrentRow;
int currentCol = io_CurrentCol;
switch (i_Direction)
{
case eMoveDirection.Up:
o_ReachedEnd = --currentRow < 0;
break;
case eMoveDirection.UpRight:
o_ReachedEnd = --currentRow < 0 || ++currentCol >= BoardSize;
break;
case eMoveDirection.Right:
o_ReachedEnd = ++currentCol >= BoardSize;
break;
case eMoveDirection.DownRight:
o_ReachedEnd = ++currentRow >= BoardSize || ++currentCol >= BoardSize;
break;
case eMoveDirection.Down:
o_ReachedEnd = ++currentRow >= BoardSize;
break;
case eMoveDirection.DownLeft:
o_ReachedEnd = ++currentRow >= BoardSize || --currentCol < 0;
break;
case eMoveDirection.Left:
o_ReachedEnd = --currentCol < 0;
break;
case eMoveDirection.UpLeft:
o_ReachedEnd = --currentCol < 0 || --currentRow < 0;
break;
}
if (!o_ReachedEnd)
{
io_CurrentRow = currentRow;
io_CurrentCol = currentCol;
}
}
void UpdateMove()
{
if (_character.IsMovePossible())
{
_eMoveState = eMoveState.END;
}
switch (_eMoveState)
{
case eMoveState.START:
if (0 != _pathfindingStack.Count)
{
_nextTileCell = _pathfindingStack.Pop();
sPosition curPosition;
curPosition.x = _character.GetTileX();
curPosition.y = _character.GetTileY();
sPosition toPosition;
toPosition.x = _nextTileCell.GetTileX();
toPosition.y = _nextTileCell.GetTileY();
_direction = _character.GetDirection(curPosition, toPosition);
_character.SetAnimation(_direction.ToString().ToLower());
}
else
{
//상태 변경
MoveFinish();
return;
}
_eMoveState = eMoveState.MOVE;
break;
case eMoveState.MOVE:
MoveInterpolation(); //보간
break;
case eMoveState.END:
_character.MoveTileCell(_nextTileCell);
_characterVector = _character.GetPosition();
_eMoveState = eMoveState.START;
break;
default:
break;
}
}
sPosition GetPositionByDirection(sPosition curPosition, eMoveDirection direction)
{
sPosition tilePosition = curPosition;
switch (direction)
{
case eMoveDirection.LEFT:
tilePosition.x--;
break;
case eMoveDirection.RIGHT:
tilePosition.x++;
break;
case eMoveDirection.UP:
tilePosition.y--;
break;
case eMoveDirection.DOWN:
tilePosition.y++;
break;
}
if (tilePosition.x < 0)
{
tilePosition.x = 0;
}
if (tilePosition.x > GameManager.Instance.GetMap().GetWidth() - 1)
{
curPosition.x = GameManager.Instance.GetMap().GetWidth() - 1;
}
if (tilePosition.y < 0)
{
tilePosition.y = 0;
}
if (tilePosition.y > GameManager.Instance.GetMap().GetHeight() - 1)
{
curPosition.y = GameManager.Instance.GetMap().GetHeight() - 1;
}
return(tilePosition);
}
private void TextBlockShoot_PreviewMouseDown(object sender, MouseButtonEventArgs e)
{
var animation = new DoubleAnimation();
if (MoveDirection == eMoveDirection.Up)
{
MoveDirection = eMoveDirection.Down;
animation.From = imageGrid.Height;
animation.To = MaxImgHeight;
}
else
{
MoveDirection = eMoveDirection.Up;
animation.From = imageGrid.Height;
animation.To = MinImgHeight;
}
animation.Duration = TimeSpan.FromSeconds(OneTimeSpan);
imageGrid.BeginAnimation(HeightProperty, animation);
}
public override void Update()
{
if (false == _character.IsEmptyPathfindingTileCell())
{
if (_moveDuration < _moveSpeed)
{
_moveDuration += Time.deltaTime;
return;
}
_moveDuration = 0.0f;
TileCell tileCell = _character.PopPathfindingTileCell();
sPosition curPosition;
curPosition.x = _character.GetTileX();
curPosition.y = _character.GetTileY();
sPosition toPosition;
toPosition.x = tileCell.GetTileX();
toPosition.y = tileCell.GetTileY();
eMoveDirection direction = GetDirection(toPosition, curPosition);
_character.SetNextDirection(direction);
if (false == _character.MoveStart(tileCell.GetTileX(), tileCell.GetTileY()))
{
if (_character.IsAttackable())
{
_nextState = eStateType.ATTACK;
}
else
{
_nextState = eStateType.IDLE;
}
}
}
else
{
_nextState = eStateType.IDLE;
}
}
public override void Update()
{
base.Update();
if (_character.GetMoveSpeed() <= _movingDuration)
{
_movingDuration = 0.0f;
if (0 != _pathTileCellStack.Count)
{
TileCell tileCell = _pathTileCellStack.Pop();
sPosition curPosition;
curPosition.x = _character.GetTileX();
curPosition.y = _character.GetTileY();
sPosition nextPosition;
nextPosition.x = tileCell.GetTileX();
nextPosition.y = tileCell.GetTileY();
eMoveDirection direction = GlobalUtility.GetDirection(curPosition, nextPosition);
_character.SetNextDirection(direction);
if (GameManager.Instance.GetMap().CanMoveTile(nextPosition.x, nextPosition.y))
{
_character.MoveStart(nextPosition.x, nextPosition.y);
}
else
{
_nextState = eStateType.IDLE;
}
}
else
{
_nextState = eStateType.IDLE;
}
}
else
{
_movingDuration += Time.deltaTime;
}
}
public sPosition GetPositionByDirection(sPosition curPosition, int direction)
{
sPosition position = curPosition;
eMoveDirection moveDirection = (eMoveDirection)direction;
switch (moveDirection)
{
case eMoveDirection.LEFT:
position.x--;
if (position.x < 0)
{
position.x++;
}
break;
case eMoveDirection.RIGHT:
position.x++;
if (position.x == GameManager.Instance.GetMap().GetWidth())
{
position.x--;
}
break;
case eMoveDirection.UP:
position.y--;
if (position.y < 0)
{
position.y++;
}
break;
case eMoveDirection.DOWN:
position.y++;
if (position.y == GameManager.Instance.GetMap().GetHeight())
{
position.y--;
}
break;
}
return(position);
}
//--------------------------------------------------------------------------------------//
// Make list of currect movment and Sequence lists for change team pieces //
//--------------------------------------------------------------------------------------//
private void makeAListOfCurrectMoves()
{
GetCurrentPlayer().IsHaveValidMove = false;
List <Piece> allThePiecesFormCurrentPlayer = GetCurrentPlayer().Pieces;
foreach (Piece currentPieceOnPlayerList in allThePiecesFormCurrentPlayer)
{
Coordinates currentPieceCoordinate = currentPieceOnPlayerList.CoordinatesOnBoard;
for (eMoveDirection currentDirection = eMoveDirection.TopRightDirection; (byte)currentDirection < k_NumOfDirections; currentDirection++)
{
List <Piece> currentListOfsequencePieces = new List <Piece>();
Coordinates currentCoordinate = currentPieceCoordinate;
currentCoordinate = getCellCoordinateToProcced(currentCoordinate, currentDirection);
while (isAValidMove(currentCoordinate))
{
Piece currentRivalPiece = s_GamePanel[currentCoordinate];
currentListOfsequencePieces.Add(currentRivalPiece);
currentCoordinate = getCellCoordinateToProcced(currentCoordinate, currentDirection);
if (checkIfArriveToEmptyCellOnBoard(currentCoordinate))
{
saveTheSequenceListToChangeTeamPiecesMember(ref currentListOfsequencePieces, currentCoordinate);
GetCurrentPlayer().IsHaveValidMove = true;
currentListOfsequencePieces.Clear();
}
else if (isCurrentCoordinateContainAllyPiece(currentCoordinate))
{
currentListOfsequencePieces.Clear();
break;
}
}
currentListOfsequencePieces.Clear();
}
}
}
private void performTokensReplacementForDirection(
eSignMarks i_Symbol,
eMoveDirection i_MoveDirection,
int i_Row,
int i_Col,
eSignMarks[,] i_PreviousBoardStatus,
out eSignMarks[,] o_NewBoardStatus,
out int o_NumberOfTokenReplaced)
{
o_NewBoardStatus = null;
o_NumberOfTokenReplaced = 0;
eSignMarks[,] boardStateWithUpdatedDirection = new eSignMarks[BoardSize, BoardSize];
Array.Copy(i_PreviousBoardStatus, boardStateWithUpdatedDirection, i_PreviousBoardStatus.Length);
boardStateWithUpdatedDirection[i_Row, i_Col] = i_Symbol;
int possibleNumberOfTokensReplaced = 0;
bool AriiveTOBorder;
eSignMarks previousTokenValue = eSignMarks.Blank;
int row = i_Row;
int col = i_Col;
do
{
advanceInMatrix(i_MoveDirection, ref row, ref col, out AriiveTOBorder);
if (!AriiveTOBorder)
{
previousTokenValue = boardStateWithUpdatedDirection[row, col];
boardStateWithUpdatedDirection[row, col] = i_Symbol;
}
++possibleNumberOfTokensReplaced;
}while (previousTokenValue != i_Symbol && previousTokenValue != eSignMarks.Blank && !AriiveTOBorder);
if (!AriiveTOBorder && previousTokenValue != eSignMarks.Blank && possibleNumberOfTokensReplaced > 1)
{
o_NumberOfTokenReplaced = possibleNumberOfTokensReplaced;
o_NewBoardStatus = boardStateWithUpdatedDirection;
}
}
bool IsConnectedCellOnDirection(int tileX, int tileY, eMoveDirection direction)
{
//진행방향으로만 붙어있는 타일 체크
sPosition position;
position.x = tileX;
position.y = tileY;
sPosition nextPosition = GlobalUtility.GetPositionByDirection(position, (eMoveDirection)direction);
if (0 <= nextPosition.x && nextPosition.x < _width && 0 <= nextPosition.y && nextPosition.y < _height)
{
if (false == GetTileCell(nextPosition.x, nextPosition.y).IsPathfindable())
{
return(true);
}
}
else
{
return(true); //맵 밖
}
return(false);
}
sPosition GetPositionByDirection(sPosition curPosition, eMoveDirection direction)
{
sPosition newPosition = curPosition;
switch (direction)
{
case eMoveDirection.LEFT:
newPosition.x--;
break;
case eMoveDirection.RIGHT:
newPosition.x++;
break;
case eMoveDirection.UP:
newPosition.y--;
break;
case eMoveDirection.DOWN:
newPosition.y++;
break;
}
return(newPosition);
}
void CreateRandomMaze()
{
float tileSize = 32.0f;
TextAsset scriptAsset = Resources.Load <TextAsset>("Data/Map1Data_layer01");
string[] records = scriptAsset.text.Split('\n');
{
string[] token = records[0].Split(',');
_width = int.Parse(token[1]);
_height = int.Parse(token[2]);
}
_tileCellList = new TileCell[_height, _width];
// 1층
for (int y = 0; y < _height; y++)
{
int line = y + 2;
string[] token = records[line].Split(',');
for (int x = 0; x < _width; x++)
{
int spriteIndex = int.Parse(token[x]);
GameObject tileGameObject = GameObject.Instantiate(TileObjectPrefbas);
tileGameObject.transform.SetParent(transform);
tileGameObject.transform.localScale = Vector3.one;
tileGameObject.transform.localPosition = Vector3.zero;
TileObject tileObject = tileGameObject.GetComponent <TileObject>();
tileObject.Init(_sprityArray[spriteIndex]);
tileObject.SetTilePosition(x, y);
_tileCellList[y, x] = new TileCell();
GetTileCell(x, y).Init(x, y);
GetTileCell(x, y).SetPosition(x * tileSize / 100.0f, y * tileSize / 100.0f);
GetTileCell(x, y).AddObject(eTileLayer.GROUND, tileObject);
}
}
// 2층
// 준비 작업
for (int y = 0; y < _height; y++)
{
if (0 == (y % 2))
{
for (int x = 0; x < _width; x++)
{
if (0 == (x % 2))
{
int spriteIndex = 139;
GameObject tileGameObject = GameObject.Instantiate(TileObjectPrefbas);
tileGameObject.transform.SetParent(transform);
tileGameObject.transform.localScale = Vector3.one;
tileGameObject.transform.localPosition = Vector3.zero;
TileObject tileObject = tileGameObject.GetComponent <TileObject>();
tileObject.Init(_sprityArray[spriteIndex]);
tileObject.SetCanMove(false);
tileObject.SetTilePosition(x, y);
GetTileCell(x, y).AddObject(eTileLayer.GROUND, tileObject);
}
}
}
}
// 가지치기 알고리즘으로 미로 생성
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < _width; x++)
{
if (false == GetTileCell(x, y).CanMove())
{
// 연결되지 않은 블럭일 경우
if (false == IsConnectedCell(x, y))
{
// 랜덤한 한 방향으로 블럭이 연결될 때 까지 이어준다
eMoveDirection direction = (eMoveDirection)Random.Range(1, (int)eMoveDirection.DOWN + 1);
int searchTileX = x;
int searchTileY = y;
while (false == IsConnectedCell(searchTileX, searchTileY))
{
switch (direction)
{
case eMoveDirection.LEFT: searchTileX--; break;
case eMoveDirection.RIGHT: searchTileX++; break;
case eMoveDirection.UP: searchTileY--; break;
case eMoveDirection.DOWN: searchTileY++; break;
}
if (0 <= searchTileX && searchTileX < _width && 0 <= searchTileY && searchTileY < _height)
{
// 새로운 블럭을 심는다.
int spriteIndex = 139;
GameObject tileGameObject = GameObject.Instantiate(TileObjectPrefbas);
tileGameObject.transform.SetParent(transform);
tileGameObject.transform.localScale = Vector3.one;
tileGameObject.transform.localPosition = Vector3.zero;
TileObject tileObject = tileGameObject.GetComponent <TileObject>();
tileObject.Init(_sprityArray[spriteIndex]);
tileObject.SetCanMove(false);
tileObject.SetTilePosition(searchTileX, searchTileY);
GetTileCell(searchTileX, searchTileY).AddObject(eTileLayer.GROUND, tileObject);
}
}
}
}
}
}
/*
* scriptAsset = Resources.Load<TextAsset>("Data/Map1Data_layer02");
* records = scriptAsset.text.Split('\n');
* for (int y = 0; y < _height; y++)
* {
* int line = y + 2;
* string[] token = records[line].Split(',');
* for (int x = 0; x < _width; x++)
* {
* int spriteIndex = int.Parse(token[x]);
*
* if (0 <= spriteIndex)
* {
* GameObject tileGameObject = GameObject.Instantiate(TileObjectPrefbas);
* tileGameObject.transform.SetParent(transform);
* tileGameObject.transform.localScale = Vector3.one;
* tileGameObject.transform.localPosition = Vector3.zero;
*
* TileObject tileObject = tileGameObject.GetComponent<TileObject>();
* tileObject.Init(_sprityArray[spriteIndex]);
* tileObject.SetCanMove(false);
* tileObject.SetTilePosition(x, y);
*
* GetTileCell(x, y).AddObject(eTileLayer.GROUND, tileObject);
* }
* }
* }
*/
}
void CreateRandomMaze()
{
float tileSize = 32.0f;
//1층
{
TextAsset scriptAsset = Resources.Load <TextAsset>("Data/MapData_layer1");
string[] records = scriptAsset.text.Split('\n');
{
string[] token = records[0].Split(',');
_width = int.Parse(token[1]);
_height = int.Parse(token[2]);
}
_tileCellList = new TileCell[_height, _width];
for (int y = 0; y < _height; y++)
{
int line = y + 2;
string[] token = records[line].Split(',');
for (int x = 0; x < _width; x++)
{
int spriteIndex = int.Parse(token[x]);
GameObject tileGameObject = GameObject.Instantiate(TileObjectPrefabs);
tileGameObject.transform.SetParent(transform);
tileGameObject.transform.localScale = Vector3.one;
tileGameObject.transform.localPosition = Vector3.zero;
TileObject tileObject = tileGameObject.GetComponent <TileObject>();
tileObject.Init(_spriteArray[spriteIndex]);
tileObject.SetTilePosition(x, y);
_tileCellList[y, x] = new TileCell();
GetTileCell(x, y).Init();
//GetTileCell(x, y).SetPosition(x * tileSize / 100.0f, -(y * tileSize / 100.0f));
GetTileCell(x, y).SetPosition(x * tileSize / 32.0f, -(y * tileSize / 32.0f));
GetTileCell(x, y).SetTilePosition(x, y);
GetTileCell(x, y).AddObject(eTileLayer.GROUND, tileObject);
}
}
}
//2층(랜덤)
{
//1. 일정간격으로 기둥을 박는다.
int interval = 4;
for (int y = 0; y < _height; y++)
{
if (0 == y % interval)
{
for (int x = 0; x < _width; x++)
{
if (0 == x % interval)
{
int spriteIndex = 252;
GameObject tileGameObject = GameObject.Instantiate(TileObjectPrefabs);
tileGameObject.transform.SetParent(transform);
tileGameObject.transform.localScale = Vector3.one;
tileGameObject.transform.localPosition = Vector3.zero;
TileObject tileObject = tileGameObject.GetComponent <TileObject>();
tileObject.Init(_spriteArray[spriteIndex]);
tileObject.SetTilePosition(x, y);
tileObject.SetCanMove(false);
GetTileCell(x, y).AddObject(eTileLayer.GROUND, tileObject);
}
}
}
}
//2. 가지치기로 미로 생성
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < _width; x++)
{
if (false == GetTileCell(x, y).CanMove()) //기둥
{
//연결되지 않은 기둥일 경우
if (false == IsConnectedCell(x, y))
{
//랜덤한 한 방향으로 기둥이 연결될떄까지 이어준다
eMoveDirection direction = (eMoveDirection)Random.Range((int)eMoveDirection.LEFT, (int)eMoveDirection.DOWN + 1);
sPosition searchPosition;
searchPosition.x = x;
searchPosition.y = y;
//while (false == IsConnectedCell(searchPosition.x, searchPosition.y))
while (false == IsConnectedCellOnDirection(searchPosition.x, searchPosition.y, direction))
{
sPosition nextPosition = GlobalUtility.GetPositionByDirection(searchPosition, (eMoveDirection)direction);
if (0 <= nextPosition.x && nextPosition.x < _width && 0 <= nextPosition.y && nextPosition.y < _height)
{
//새로운 기둥을 심는다.
int spriteIndex = 252;
GameObject tileGameObject = GameObject.Instantiate(TileObjectPrefabs);
tileGameObject.transform.SetParent(transform);
tileGameObject.transform.localScale = Vector3.one;
tileGameObject.transform.localPosition = Vector3.zero;
TileObject tileObject = tileGameObject.GetComponent <TileObject>();
tileObject.Init(_spriteArray[spriteIndex]);
tileObject.SetTilePosition(nextPosition.x, nextPosition.y);
tileObject.SetCanMove(false);
GetTileCell(nextPosition.x, nextPosition.y).AddObject(eTileLayer.GROUND, tileObject);
}
direction = (eMoveDirection)Random.Range((int)eMoveDirection.LEFT, (int)eMoveDirection.DOWN + 1);
searchPosition = nextPosition;
}
}
}
}
}
}
}
void CreateRandomMaze()
{
float scale = 1.0f; // 화면에 보이는 크기 배수
float tileSize = 32.0f * scale;
_tileScale = new Vector3(scale, scale);
//1층
TextAsset scriptAsset = Resources.Load <TextAsset>("Data/Map1Data_layer1");
string[] records = scriptAsset.text.Split('\n');
{
string[] token = records[0].Split(',');
_width = int.Parse(token[1]);
_height = int.Parse(token[2]);
}
_tileCellList = new TileCell[_height, _width];
for (int y = 0; y < _height; y++)
{
int line = y + 2;
string[] token = records[line].Split(',');
for (int x = 0; x < _width; x++)
{
int spriteIndex = int.Parse(token[x]);
GameObject tileGameObject = GameObject.Instantiate(TileObjectPrefabs);
tileGameObject.transform.SetParent(transform);
tileGameObject.transform.localScale = _tileScale;
tileGameObject.transform.localPosition = Vector3.zero;
TileObject tileObject = tileGameObject.GetComponent <TileObject>();
tileObject.Init(_spriteArray[spriteIndex], x, y);
_tileCellList[y, x] = new TileCell();
GetTileCell(x, y).Init();
//setPosition 합치기
GetTileCell(x, y).SetPosition(x * tileSize / 100.0f, -y * tileSize / 100.0f);
GetTileCell(x, y).SetTilePosition(x, y);
GetTileCell(x, y).AddObject(eTileLayer.GROUND, tileObject);
}
}
//2층
{
int interval = 2;
//기둥!
for (int y = 0; y < _height; y++)
{
if (y % interval == 0)
{
for (int x = 0; x < _width; x++)
{
if (x % interval == 0)
{
int spriteIndex = 127;
GameObject tileGameObject = GameObject.Instantiate(TileObjectPrefabs);
tileGameObject.transform.SetParent(transform);
tileGameObject.transform.localScale = _tileScale;
tileGameObject.transform.localPosition = Vector3.zero;
TileObject tileObject = tileGameObject.GetComponent <TileObject>();
tileObject.Init(_spriteArray[spriteIndex], x, y);
tileObject.SetCanMove(false);
GetTileCell(x, y).AddObject(eTileLayer.GROUND, tileObject);
}
}
}
}
//가지치기
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < _width; x++)
{
if (false == GetTileCell(x, y).CanMove())
{
sPosition tilePosition;
tilePosition.x = x;
tilePosition.y = y;
// 연결 안된 블록이면
if (false == IsConnectedCell(tilePosition))
{
//랜덤한 방향으로 연결될때까지 이어준다
eMoveDirection direction = (eMoveDirection)Random.Range(1, (int)eMoveDirection.DOWN + 1);
sPosition curPosition;
curPosition.x = x;
curPosition.y = y;
while (false == IsConnectedCell(curPosition))
{
int i = 0;
while (i < interval - 1)
{
curPosition = GetDirectionTilePosition((eMoveDirection)direction, curPosition);
if (0 <= curPosition.x && curPosition.x < _width && 0 <= curPosition.y && curPosition.y < _height)
{
int spriteIndex = 127;
GameObject tileGameObject = GameObject.Instantiate(TileObjectPrefabs);
tileGameObject.transform.SetParent(transform);
tileGameObject.transform.localScale = _tileScale;
tileGameObject.transform.localPosition = Vector3.zero;
TileObject tileObject = tileGameObject.GetComponent <TileObject>();
tileObject.Init(_spriteArray[spriteIndex], curPosition.x, curPosition.y);
tileObject.SetCanMove(false);
GetTileCell(curPosition.x, curPosition.y).AddObject(eTileLayer.GROUND, tileObject);
}
i++;
}
}
}
}
}
}
//스프라이트 부드럽게
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < _width; x++)
{
sPosition tilePosition;
tilePosition.x = x;
tilePosition.y = y;
if (true == IsConnectedCell(tilePosition))
{
}
}
}
}
}
private Coordinates getCellCoordinateToProcced(Coordinates i_CurrentCoordinate, eMoveDirection i_CurrentDirection)
{
Coordinates nextCoordinateInDirection = new Coordinates();
switch (i_CurrentDirection)
{
case eMoveDirection.TopRightDirection:
{
moveCoordinateTopRightDirection(ref nextCoordinateInDirection, i_CurrentCoordinate);
}
break;
case eMoveDirection.TopDirection:
{
moveCoordinateTopDirection(ref nextCoordinateInDirection, i_CurrentCoordinate);
}
break;
case eMoveDirection.TopLeftDirection:
{
moveCoordinateTopLeftDirection(ref nextCoordinateInDirection, i_CurrentCoordinate);
}
break;
case eMoveDirection.LeftDirection:
{
moveCoordinateLeftDirection(ref nextCoordinateInDirection, i_CurrentCoordinate);
}
break;
case eMoveDirection.LeftDownDirection:
{
moveCoordinateLeftDownDirection(ref nextCoordinateInDirection, i_CurrentCoordinate);
}
break;
case eMoveDirection.DownDirection:
{
moveCoordinateDownDirection(ref nextCoordinateInDirection, i_CurrentCoordinate);
}
break;
case eMoveDirection.RightDownDirection:
{
moveCoordinateRightDownDirection(ref nextCoordinateInDirection, i_CurrentCoordinate);
}
break;
case eMoveDirection.RightDirection:
{
moveCoordinateRightDirection(ref nextCoordinateInDirection, i_CurrentCoordinate);
}
break;
}
return(nextCoordinateInDirection);
}
public void FindPath(eFindMode mode, eFindMethod method)
{
bool isViewRange = (eFindMode.VIEW_MOVERANGE == mode || eFindMode.VIEW_ATTACKRANGE == mode);
while (0 != _pathfindingQueue.Count)
{
sPathCommand command = _pathfindingQueue[0];
_pathfindingQueue.RemoveAt(0);
if (false == command.tileCell.IsVisit())
{
command.tileCell.Visit();
//FIND TARGET
if (eFindMode.FIND_PATH == mode)
{
if ((_targetTileCell.GetTileX() == command.tileCell.GetTileX()) &&
(_targetTileCell.GetTileY() == command.tileCell.GetTileY()))
{
_reverseTileCell = _targetTileCell;
return;
}
}
for (eMoveDirection direction = 0; direction <= eMoveDirection.DOWN; direction++)
{
sPosition curPosition;
curPosition.x = command.tileCell.GetTileX();
curPosition.y = command.tileCell.GetTileY();
sPosition nextPosition = GlobalUtility.GetPositionByDirection(curPosition, direction);
TileMap map = GameManager.Instance.GetMap();
TileCell nextTileCell = map.GetTileCell(nextPosition.x, nextPosition.y);
if (CheckPrecondition(mode, nextTileCell, _targetTileCell))
{
float distanceFromStart = command.tileCell.GetDistanceFromStart()
+ command.tileCell.GetDistanceWeight();
float heuristic = CalcHeuristic(method, distanceFromStart,
command.tileCell, nextTileCell, _targetTileCell);
if (isViewRange && (_range < distanceFromStart))
{
return;
}
if (null == nextTileCell.GetPrevTileCell())
{
nextTileCell.SetDistanceFromStart(distanceFromStart);
nextTileCell.SetPrevTileCell(command.tileCell);
sPathCommand newCommand;
newCommand.tileCell = nextTileCell;
newCommand.heuristic = heuristic;
PushCommand(newCommand);
//검색범위를 그려준다.
if (isViewRange)
{
DrawSearchTile(nextTileCell);
}
}
}
}
}
}
}
public void SetNextDirection(eMoveDirection direction)
{
_nextDirection = direction;
}
public void CreateRandomMaps()
{
float _tileSize = 32.0f;
TextAsset scriptAsset = Resources.Load <TextAsset>("Data/NewMapData1_layer1");
string[] records = scriptAsset.text.Split('\n');
{
string[] token = records[0].Split(',');
_width = int.Parse(token[1]);
_height = int.Parse(token[2]);
}
_tileCellList = new TileCell[_height, _width];
for (int y = 0; y < _height; y++)
{
int line = y + 2;
string[] token = records[line].Split(',');
for (int x = 0; x < _width; x++)
{
int spriteIndex = int.Parse(token[x]);
GameObject tileGameObj = GameObject.Instantiate(TileObjPrefabs);
tileGameObj.transform.SetParent(transform);
tileGameObj.transform.localScale = Vector3.one;
tileGameObj.transform.position = Vector3.zero;
TileObject tileObject = tileGameObj.GetComponent <TileObject>();
tileObject.Init(_spriteArray[spriteIndex]);
tileObject.SetTilePosition(x, y);
_tileCellList[y, x] = new TileCell();
GetTileCell(x, y).Init();
GetTileCell(x, y).SetPosition(x * _tileSize / 100.0f, -(y * _tileSize / 100.0f));
GetTileCell(x, y).SetTile(x, y);
GetTileCell(x, y).AddObject(eTileLayer.GROUND, tileObject);
}
}
{
int interval = 3;
for (int y = 0; y < _height; y++)
{
if (y % interval == 0)
{
for (int x = 0; x < _width; x++)
{
if (x % interval == 0)
{
int spriteIndex = 7;
GameObject tileGameObj = Instantiate(TileObjPrefabs);
tileGameObj.transform.SetParent(transform);
tileGameObj.transform.localScale = Vector3.one;
tileGameObj.transform.localPosition = Vector3.zero;
GameObject lightObj = Instantiate(LightObjPrefabs);
AddLighting(lightObj, tileGameObj);
TileObject tileObj = tileGameObj.GetComponent <TileObject>();
tileObj.Init(_spriteArray[spriteIndex]);
tileObj.SetCanMove(false);
GetTileCell(x, y).AddObject(eTileLayer.GROUND, tileObj);
}
}
}
}
}
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < _width; x++)
{
if (GetTileCell(x, y).CanMove() == false)
{
if (IsConnectedCell(x, y) == false)
{
eMoveDirection direction = (eMoveDirection)Random.Range(1, (int)eMoveDirection.DOWN);
int searchTileX = x;
int searchTileY = y;
while (IsConnectedCell(searchTileX, searchTileY) == false)
{
switch (direction)
{
case eMoveDirection.LEFT:
searchTileX--;
break;
case eMoveDirection.RIGHT:
searchTileX++;
break;
case eMoveDirection.UP:
searchTileY--;
break;
case eMoveDirection.DOWN:
searchTileY++;
break;
}
if (0 <= searchTileX && searchTileX < _width && 0 <= searchTileY && searchTileY <= _height)
{
int spriteIndex = 7;
GameObject tileGameObj = Instantiate(TileObjPrefabs);
tileGameObj.transform.SetParent(transform);
tileGameObj.transform.localScale = Vector3.one;
tileGameObj.transform.localPosition = Vector3.zero;
TileObject tileObj = tileGameObj.GetComponent <TileObject>();
tileObj.Init(_spriteArray[spriteIndex]);
tileObj.SetCanMove(false);
GetTileCell(searchTileX, searchTileY).AddObject(eTileLayer.GROUND, tileObj);
}
}
}
}
}
}
}
