void Move(Point p)
{
MapNodePiece target = Map.Instance.getNodeAtPoint(p).getPiece();
if (target.value == 2)
{
return;
}
piece.transform.parent = null;
Map.Instance.SwitchNodePieceAndValue(piece.index, p);
var tmp = target.transform.position;
transform.DOMove(target.transform.position, 0.2f).OnComplete(() =>
{
piece.transform.parent = transform;
piece.transform.localPosition = Vector3.zero;
if (CheckBeside() != null)
{
attackNode = Map.Instance.getNodeAtPoint(Player.Instance.index).getPiece();
attackNode.transform.localPosition -= Vector3.forward * 1.1f;
attackNode.SetColor(Color.red);
}
});
target.transform.position = piece.transform.position;
piece.transform.position = tmp;
}
void Update()
{
if (Player.Instance.index.Equals(index))
{
playerInHere = true;
if (!boss.playerInNow.Contains(this))
{
boss.playerInNow.Add(this);
}
}
else
{
playerInHere = false;
if (boss.playerInNow.Contains(this))
{
boss.playerInNow.Remove(this);
}
}
if (index.x == 0 && index.y == 0)
{
if (Physics2D.Raycast(transform.position + Vector3.forward * 0.01f, Vector3.forward))
{
RaycastHit2D hit = Physics2D.Raycast(transform.position + Vector3.forward * 0.01f, Vector3.forward);
if (hit.transform.GetComponent <MapNodePiece>() != null)
{
MapNodePiece piece = hit.transform.GetComponent <MapNodePiece>();
index.x = piece.index.x;
index.y = piece.index.y;
}
}
}
}
void UpdateIndex()
{
RaycastHit2D hit = Physics2D.Raycast(transform.position + Vector3.forward * 0.01f, Vector3.forward);
MapNodePiece piece = hit.transform.GetComponent <MapNodePiece>();
index.x = piece.index.x;
index.y = piece.index.y;
}
public override void EnemyNeedToDO()
{
if (!open)
{
return;
}
minesTimeCounter += 1;
wallTimeCounter += 1;
if (needToAttack.Count != 0)
{
foreach (AttackTrigger attack in needToAttack)
{
Map.Instance.getNodeAtPoint(attack.index).getPiece().SetColor(Color.white);
}
switch (needToAttack[0].attackMode)
{
case AttackTrigger.AttackMode.CutAttack:
{
CutAttack();
break;
}
case AttackTrigger.AttackMode.LaserAttack:
{
LaserAttack();
break;
}
case AttackTrigger.AttackMode.MinesAttack:
{
MinesAttack();
break;
}
case AttackTrigger.AttackMode.MidDistanceAttack:
{
MidDistanceAttack();
break;
}
case AttackTrigger.AttackMode.CreatWall:
{
CreatWall();
break;
}
}
}
else
{
ShowAttackRange();
StateManager.Instance.state = StateManager.State.myTurn;
}
WallReset();
MinesReset();
currentWeakPoint = ChangeWeakPoint();
}
void CloseAttackPiece()
{
if (attackNode != null)
{
attackNode.SetColor(Color.white);
attackNode.transform.localPosition += Vector3.forward * 1.1f;
attackNode = null;
}
}
public void SwitchNodePieceAndValue(Point a, Point b)
{
MapNodePiece pieceA = getNodeAtPoint(a).getPiece();
MapNode nodeA = getNodeAtPoint(a);
MapNodePiece pieceB = getNodeAtPoint(b).getPiece();
MapNode nodeB = getNodeAtPoint(b);
nodeA.SetPiece(pieceB);
nodeB.SetPiece(pieceA);
}
public void SetPiece(MapNodePiece p)
{
piece = p;
value = (piece == null) ? 0 : piece.value;
if (piece == null)
{
return;
}
piece.SetIndex(index);
}
void Start()
{
piece = GetComponentInChildren <MapNodePiece>();
sprite = GetComponent <SpriteRenderer>();
moveList = new List <Point>();
moveListList = new List <List <Point> >();
hasMoveList = new List <Point>();
oriColor = sprite.color;
oriPoint = piece.index;
currentHP = maxHP;
}
void Move(Point p)
{
MapNodePiece target = Map.Instance.getNodeAtPoint(p).getPiece();
if (target.value == 2)
{
return;
}
if (Mathf.Abs(p.x - piece.index.x) == 0)
{
if (p.y - piece.index.y > 0)
{
transform.rotation = transform.rotation = Quaternion.Euler(Vector3.forward * 180);
}
else
{
transform.rotation = Quaternion.Euler(Vector3.zero);
}
}
else
{
if (p.x - piece.index.x > 0)
{
transform.rotation = Quaternion.Euler(Vector3.forward * -90);
}
else
{
transform.rotation = Quaternion.Euler(Vector3.forward * 90);
}
}
piece.transform.parent = null;
Map.Instance.SwitchNodePieceAndValue(piece.index, p);
var tmp = target.transform.position;
transform.DOMove(target.transform.position, 0.2f).OnComplete(() =>
{
piece.transform.parent = transform;
piece.transform.localPosition = Vector3.zero;
if (CheckBeside() != null)
{
attackNode = Map.Instance.getNodeAtPoint(Player.Instance.index).getPiece();
attackNode.transform.localPosition -= Vector3.forward * 1.1f;
attackNode.SetColor(Color.red);
}
});
target.transform.position = piece.transform.position;
piece.transform.position = tmp;
}
void StateMoveNeedToDo()
{
if (canMoveList.Count == 0)
{
UpdateIndex();
canMoveList.Add(index);
FindCanMovePoints(Mathf.Clamp(ProcessedData.Instance.move, 0, 5), index);
canMoveList.Remove(index);
if (canMoveList.Count == 0)
{
ProcessedData.Instance.move = 0;
}
ChangeGridColor(canMoveList, Color.green);
uiState.ChangeState("移動選択");
}
else
{
if (Input.GetMouseButton(0) && !clickOnce)
{
clickOnce = true;
var hit = Physics2D.Raycast(new Vector2(Camera.main.ScreenToWorldPoint(Input.mousePosition).x, Camera.main.ScreenToWorldPoint(Input.mousePosition).y), Vector2.zero, 0f);
MapNodePiece piece = null;
if (hit.transform != null)
{
piece = hit.transform.GetComponent <MapNodePiece>();
}
else
{
return;
}
if (piece == null)
{
return;
}
if (!Map.Instance.isContainPointInPointList(canMoveList, piece.index))
{
return;
}
moveList.Clear();
FindTheWay(Mathf.Clamp(ProcessedData.Instance.move, 0, 5), index, piece.index);
FindTheLowestPath();
Move(moveList, 0);
ResetGridColor(canMoveList);
moveListList.Clear();
canMoveList.Clear();
}
else if (!Input.GetMouseButton(0) && clickOnce)
{
clickOnce = false;
}
}
}
void MovePath(List <Point> pathList, int index)
{
MapNodePiece target = Map.Instance.getNodeAtPoint(pathList[index]).getPiece();
if (target.value == 2)
{
pauseTimes += index;
pauseTimes += 1;
if (pauseTimes >= moveTimes)
{
pauseTimes = 0;
return;
}
else
{
FindTheWay(detectDis, piece.index, Player.Instance.index);
FindTheLowestPath();
if (moveList.Count != 0)
{
MovePath(moveList, 0);
}
}
}
if (index >= moveTimes || pathList.IndexOf(pathList[index]) == pathList.Count - 1)
{
if (CheckBeside() != null)
{
attackNode = Map.Instance.getNodeAtPoint(Player.Instance.index).getPiece();
attackNode.transform.localPosition -= Vector3.forward;
attackNode.SetColor(Color.red);
}
return;
}
piece.transform.parent = null;
Map.Instance.SwitchNodePieceAndValue(piece.index, pathList[index]);
var tmp = target.transform.position;
transform.DOMove(target.transform.position, 0.2f).OnComplete(() =>
{
piece.transform.parent = transform;
piece.transform.localPosition = Vector3.zero;
MovePath(pathList, index + 1);
});
target.transform.position = piece.transform.position;
piece.transform.position = tmp;
}
void InstantiateBoard()
{
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
MapNode node = getNodeAtPoint(new Point(x, y));
int val = node.value;
if (val != 0)
{
continue;
}
GameObject p = Instantiate(road, transform);
MapNodePiece piece = p.GetComponent <MapNodePiece>();
Transform rect = p.GetComponent <Transform>();
rect.position = new Vector3(transform.position.x + (cellSize * x) + cellSize / 2, transform.position.y - (cellSize * y) - cellSize / 2, 0.1f);
node.SetPiece(piece);
node.getPiece().FirstTime();
}
}
}
public void ShowBossRoom()
{
mist.SetActive(false);
boss.open = true;
foreach (MapNodePiece piece in transform.GetComponentsInChildren <MapNodePiece>())
{
piece.sprite.color = piece.lastColor;
}
for (int x = bossRoomStartIndex.x; x < bossRoomEndIndex.x; x++)
{
for (int y = bossRoomStartIndex.y; y < bossRoomEndIndex.y; y++)
{
MapNodePiece piece = Map.Instance.getNodeAtPoint(new Point(x, y)).getPiece();
if (piece.value == 0)
{
piece.sprite.color = Color.white;
}
else
{
piece.sprite.color = piece.lastColor;
}
}
}
}
public override void EnemyNeedToDO()
{
if (dead)
{
return;
}
Debug.Log("EnemyAction");
CloseAttackPiece();
if (sprite.color.a == 1 && !hasBeenDetected)
{
hasBeenDetected = true;
oriColor = new Color(oriColor.r, oriColor.g, oriColor.b, 1);
}
hasAround = false;
if (!DetectDistance())
{
sprite.color = oriColor;
return;
}
Point dir = CheckBeside();
if (dir != null)
{
AttackPlayer();
attackNode = Map.Instance.getNodeAtPoint(Player.Instance.index).getPiece();
attackNode.transform.localPosition -= Vector3.forward * 1.1f;
attackNode.SetColor(Color.red);
hasMove = 0;
if (dir.Equals(Point.up))
{
transform.rotation = Quaternion.Euler(Vector3.forward * 180);
}
else if (dir.Equals(Point.down))
{
transform.rotation = Quaternion.Euler(Vector3.zero);
}
else if (dir.Equals(Point.right))
{
transform.rotation = Quaternion.Euler(Vector3.forward * -90);
}
else if (dir.Equals(Point.left))
{
transform.rotation = Quaternion.Euler(Vector3.forward * 90);
}
return;
}
DetectPlayer(detectDis, piece.index);
if (hasAround)
{
moveList.Clear();
FindTheWay(detectDis, piece.index, Player.Instance.index);
FindTheLowestPath();
if (moveList.Count != 0)
{
Move(moveList[0]);
}
moveListList.Clear();
sprite.color = Color.red;
hasMove += 1;
if (hasMove < moveTimes)
{
StartCoroutine(WaitToDo(0.2f, () => EnemyNeedToDO()));
}
else
{
hasMove = 0;
}
}
else
{
sprite.color = oriColor;
}
}
public void DetectMap(int moveAmount, Point p)
{
if (moveAmount == 0)
{
return;
}
Point[] directions =
{
Point.up,
Point.right,
Point.down,
Point.left
};
foreach (Point dir in directions)
{
Point next = Point.add(p, dir);
if (next.x >= Map.Instance.width || next.y >= Map.Instance.height || next.x < 0 || next.y < 0)
{
continue;
}
if (Map.Instance.getNodeAtPoint(next).value == 0)
{
MapNodePiece piece = Map.Instance.getNodeAtPoint(next).getPiece();
Color tmp = piece.sprite.color;
piece.sprite.color = new Color(tmp.r, tmp.g, tmp.b, 1);
DetectMap(moveAmount - 1, next);
continue;
}
else if (Map.Instance.getNodeAtPoint(next).value == 1)
{
MapNodePiece piece = Map.Instance.getNodeAtPoint(next).getPiece();
Color tmp = piece.sprite.color;
piece.sprite.color = new Color(tmp.r, tmp.g, tmp.b, 1);
continue;
}
else if (Map.Instance.getNodeAtPoint(next).value == 2)
{
MapNodePiece piece = Map.Instance.getNodeAtPoint(next).getPiece();
Color tmp = piece.sprite.color;
piece.sprite.color = new Color(tmp.r, tmp.g, tmp.b, 1);
NormalEnemy enemy = piece.GetComponentInParent <NormalEnemy>();
if (enemy != null)
{
SpriteRenderer sprite = enemy.GetComponent <SpriteRenderer>();
Color tmp2 = sprite.color;
sprite.color = new Color(tmp2.r, tmp2.g, tmp2.b, 1);
}
else
{
TreasureChestEnemy treasureChestEnemy = piece.GetComponentInParent <TreasureChestEnemy>();
if (treasureChestEnemy != null)
{
SpriteRenderer sprite = treasureChestEnemy.GetComponent <SpriteRenderer>();
Color tmp2 = sprite.color;
sprite.color = new Color(tmp2.r, tmp2.g, tmp2.b, 1);
}
}
continue;
}
}
}
public override void EnemyNeedToDO()
{
if (dead)
{
return;
}
CloseAttackPiece();
if (sprite.color.a == 1 && !hasBeenDetected)
{
hasBeenDetected = true;
oriColor = new Color(oriColor.r, oriColor.g, oriColor.b, 1);
}
hasAround = false;
if (!DetectDistance())
{
return;
}
Point dir = CheckBeside();
if (dir != null)
{
AttackPlayer();
attackNode = Map.Instance.getNodeAtPoint(Player.Instance.index).getPiece();
attackNode.transform.localPosition -= Vector3.forward * 1.1f;
attackNode.SetColor(Color.red);
return;
}
DetectPlayer(detectDis, piece.index);
if (hasAround)
{
moveList.Clear();
FindTheWay(detectDis, piece.index, Player.Instance.index);
FindTheLowestPath();
if (moveList.Count != 0)
{
Move(moveList[0]);
}
moveListList.Clear();
sprite.sprite = changeSprite;
hasMove += 1;
if (hasMove < moveTimes)
{
StartCoroutine(WaitToDo(0.2f, () => EnemyNeedToDO()));
}
else
{
hasMove = 0;
}
}
else
{
sprite.sprite = originSprite;
}
}
void StateAttackNeedToDo()
{
if (!attackReady)
{
uiState.ChangeState("攻擊選択");
UpdateIndex();
Point[] directions =
{
Point.up,
Point.right,
Point.down,
Point.left
};
foreach (Point dir in directions)
{
Point next = Point.add(index, dir);
if (next.x >= Map.Instance.width || next.y >= Map.Instance.height || next.x < 0 || next.y < 0)
{
continue;
}
if (/*Map.Instance.getNodeAtPoint(next).value == 0 ||*/ Map.Instance.getNodeAtPoint(next).value == 2)
{
canAttackList.Add(next);
}
}
ChangeGridColor(canAttackList, Color.green);
attackReady = true;
}
else
{
if (canAttackList.Count == 0)
{
hasAttacked = true;
}
if (Input.GetMouseButton(0) && !clickOnce)
{
clickOnce = true;
var hit = Physics2D.Raycast(new Vector2(Camera.main.ScreenToWorldPoint(Input.mousePosition).x, Camera.main.ScreenToWorldPoint(Input.mousePosition).y), Vector2.zero, 0f);
MapNodePiece piece = null;
if (hit.transform != null)
{
piece = hit.transform.GetComponent <MapNodePiece>();
}
if (piece == null)
{
return;
}
if (!Map.Instance.isContainPointInPointList(canAttackList, piece.index))
{
return;
}
var boss = piece.GetComponentInParent <Boss>();
if (boss != null && boss.currentWeakPoint == piece)
{
var damageText = ObjectPool.TakeFromPool("Damage");
damageText.position = boss.transform.position;
var ui = damageText.GetComponent <UINumberPopUp>();
ui.amount = ProcessedData.Instance.atk * 2;
ui.ShowDamage();
boss.currentHP -= ProcessedData.Instance.atk * 2;
boss.Dead();
}
else
{
Enemy enemy = piece.GetComponentInParent <Enemy>();
var damageText = ObjectPool.TakeFromPool("Damage");
damageText.position = enemy.transform.position;
var ui = damageText.GetComponent <UINumberPopUp>();
ui.amount = ProcessedData.Instance.atk;
ui.ShowDamage();
enemy.currentHP -= ProcessedData.Instance.atk;
enemy.Dead();
}
hasAttacked = true;
}
else if (!Input.GetMouseButton(0) && clickOnce)
{
clickOnce = false;
}
}
}
