private bool MoveToOpponent(List <HexCoord> moveTarget)
{
if (m_PlayerState.Equals(PlayerState.Active))
{
List <HexTilePath> opponentPaths = new List <HexTilePath>();
List <Player> temp = m_PlayerManager.GetUserPlayers(null, false);
List <HexCoord> opponentLeastHPTiles = new List <HexCoord>();
//sort all target by distance and hp
temp.OrderBy(x => HexCoord.HexDistance(x.m_Hex, m_Hex)).ThenBy(x => x.m_Hp);
for (int i = 0; i < temp.Count; i++)
{
//get target in attack range after move
opponentLeastHPTiles = GetAttackRangeWithTarget(temp[i].m_Hex, moveTarget);
if (opponentLeastHPTiles != null && opponentLeastHPTiles.Count > 0)
{
break;
}
}
for (int i = 0; i < opponentLeastHPTiles.Count; i++)
{
opponentPaths.Add(m_StageMapManager.FindPath(m_Hex, opponentLeastHPTiles[i]));
}
if (opponentPaths.Count > 0)
{
//get highest defense rate tile and least step path
opponentPaths = opponentPaths.OrderBy(x => - x.lastTile.m_DefenseRate).ThenBy(x => x.costOfPath).ToList();
m_StageMapManager.HighlightTileAt(m_Hex, (int)m_MovementPerActionPoint, false);
HexTile destTile = opponentPaths[0].lastTile;
GameManager.m_Instance.MoveCurrentPlayer(destTile);
GameManager.m_Instance.isSetCamera = true;
return(true);
}
}
return(false);
}
private void EnemyAction()
{
if (m_IsMoving)
{
return;
}
//priority queue
List <HexCoord> attackHexesDirect = HexCoord.HexRing(m_Hex, 1);
List <HexCoord> attackHexesIndirect = HexCoord.HexRing(m_Hex, 2);
List <HexCoord> moveRange = new List <HexCoord>();
if (m_PlayerState.Equals(PlayerState.Action))
{
if (m_EnemyAIType == EnemyAIType.Attacker)
{
moveRange = m_StageMapManager.FindHighlight(m_Hex, m_MovementPerActionPoint, false);
moveRange = m_PlayerManager.GetEmptyHex(moveRange);
}
else if (m_EnemyAIType == EnemyAIType.Defanser)
{
moveRange = m_StageMapManager.FindHighlight(m_Hex, m_SearchRange, false);
moveRange = m_PlayerManager.GetEmptyHex(moveRange);
}
}
List <HexCoord> attackHexesInRange = new List <HexCoord>();
List <HexCoord> opponetsCanBeAttackDirect = new List <HexCoord>();
List <HexCoord> opponetsCanBeAttackIndirect = new List <HexCoord>();
List <HexCoord> opponetsNotCanBeCountDirect = new List <HexCoord>();
List <HexCoord> opponetsNotCanBeCountIndirect = new List <HexCoord>();
int directAtk = 0;
int indirectAtk = 0;
GetWeaponAttack(ref directAtk, ref indirectAtk);
List <Player> opponets = new List <Player>();
List <Player> opponetsNotCanBeCount = new List <Player>();
List <Player> moveOpponets = new List <Player>();
List <Player> moveOpponetsNotCanBeCount = new List <Player>();
//Get player who can (not) counter in range
if (directAtk > 0)
{
GetOpponet(attackHexesDirect, attackHexesInRange, opponets, opponetsNotCanBeCount, true);
GetMoveOpponet(opponetsNotCanBeCountDirect, opponetsCanBeAttackDirect, moveOpponetsNotCanBeCount, true);
}
if (indirectAtk > 0)
{
GetOpponet(attackHexesIndirect, attackHexesInRange, opponets, opponetsNotCanBeCount, false);
GetMoveOpponet(opponetsNotCanBeCountIndirect, opponetsCanBeAttackIndirect, moveOpponetsNotCanBeCount, false);
}
//Attack player who cannot counter
if (AttackOpponent(opponetsNotCanBeCount))
{
return;
}
//Move to player who cannot counter in move range
if (MoveToOpponent(opponetsNotCanBeCountDirect.Union(opponetsNotCanBeCountIndirect).Intersect(moveRange).ToList()))
{
return;
}
//Attack player in range
if (AttackOpponent(opponets))
{
return;
}
//Move to player who can counter in move range
if (MoveToOpponent(opponetsCanBeAttackDirect.Union(opponetsCanBeAttackIndirect).Intersect(moveRange).ToList()))
{
return;
}
if (m_PlayerState.Equals(PlayerState.Active) && m_EnemyAIType == EnemyAIType.Attacker)
{
//Move to nearist target
List <HexCoord> opponentTiles = new List <HexCoord>();
List <HexTilePath> opponentPaths = new List <HexTilePath>();
int minDistance = 9999;
List <Player> temp = m_PlayerManager.GetUserPlayers(null, false);
for (int i = 0; i < temp.Count; i++)
{
Player userPlayer = temp[i];
for (int j = 0; j < moveRange.Count; j++)
{
int distance = HexCoord.HexDistance(moveRange[j], userPlayer.m_Hex);
if (distance < minDistance)
{
minDistance = distance;
opponentTiles.Clear();
opponentTiles.Add(moveRange[j]);
}
else if (distance == minDistance)
{
opponentTiles.Add(moveRange[j]);
}
}
}
opponentTiles = opponentTiles.OrderBy(x => HexCoord.HexDistance(m_Hex, x)).ToList();
for (int i = 0; i < opponentTiles.Count; i++)
{
opponentPaths.Add(m_StageMapManager.FindPath(m_Hex, opponentTiles[i]));
}
HexTile destTile = null;
float cost = 0;
List <HexTile> path = new List <HexTile>();
for (int i = 0; i < opponentPaths[0].listOfTiles.Count; i++)
{
HexTile tile = opponentPaths[0].listOfTiles[i];
cost += tile.m_MovementCost;
if (cost <= m_MovementPerActionPoint)
{
destTile = tile;
}
else
{
break;
}
}
m_StageMapManager.HighlightTileAt(moveRange);
GameManager.m_Instance.MoveCurrentPlayer(destTile);
return;
}
//Nothing can do.
TurnEnd();
}
public void AttackWithCurrentPlayer(Player player, HexTile destTile, bool checkScenarion = true)
{
if (!destTile.m_IsHighLight && !destTile.m_Impassible)
{
Debug.Log("destination invalid");
return;
}
Player attacker = player;
Player target = m_PlayerManager.GetPlayer(destTile.m_Hex);
if (checkScenarion && m_ScenarionManager.SetBeforeScenarion(attacker, target, destTile.m_Hex))
{
ChangeState(GameState.Scenarion);
return;
}
string backGround = "";
string getItem = "";
bool isHeal = attacker.m_IsEnemy && target.m_IsEnemy;
int getExp = 0;
bool isDirectAtk = HexCoord.HexDistance(attacker.m_Hex, target.m_Hex) == 1;
bool isCounter = target.GetIsCanAttack(isDirectAtk);
int attackerDamage = 0;
int targetDamage = 0;
int level;
int raceID = attacker.m_IsEnemy ? target.m_Race : attacker.m_Race;
string playerClass = m_ElementManager.GetRace(raceID).name;
HexTile targetTile = m_StageMapManager.GetMapTile(attacker.m_Hex);
PlayerRecord playerData = new PlayerRecord();
isCounter &= GetBattleResult(attacker, target, destTile, isDirectAtk, isHeal, out attackerDamage, ref getExp);
if (isCounter)
{
GetBattleResult(target, attacker, targetTile, isDirectAtk, isHeal, out targetDamage, ref getExp);
}
if (!isHeal)
{
int enemyIndex = attacker.m_IsEnemy ? attacker.playerIndex : target.playerIndex;
HexCoord hex = attacker.m_IsEnemy ? attacker.m_Hex : target.m_Hex;
SetBattleScenarionChecker(enemyIndex, hex);
}
attacker.TurnEnd();
m_StageMapManager.RemoveHighlightTiles();
BattlePlayerData attackerData = GetBattlePlayerData(attacker, targetTile, targetDamage);
BattlePlayerData targetData = GetBattlePlayerData(target, destTile, attackerDamage);
//level up
PlayerRecord lvUpProp = null;
Player checkLevelUp = m_IsPlayerTurn ? attacker : target;
lvUpProp = checkLevelUp.LevelUp(m_PlayerLevelMax, m_PlayerHPMax, m_PlayerStateMax);
if (lvUpProp != null)
{
level = checkLevelUp.m_Level;
playerData = checkLevelUp.GetPlayerProp();
checkLevelUp.LevelUp(lvUpProp);
}
Player enemy = attacker.m_IsEnemy ? attacker : target;
if (!isHeal && !enemy.IsAlive)
{
if (UnityEngine.Random.Range(0f, 1f) < 0.5)
{
m_PlayerDataManager.m_PlayerGold += target.m_Gold;
getItem = "<color=yellow>" + target.m_Gold + "</color>Gold";
}
else
{
if (m_PlayerDataManager.m_PlayerWeapons.ContainsKey(target.m_EquipWeapon))
{
m_PlayerDataManager.m_PlayerWeapons[target.m_EquipWeapon]++;
}
else
{
m_PlayerDataManager.m_PlayerWeapons.Add(target.m_EquipWeapon, 1);
}
getItem = m_ElementManager.GetWeapon(target.m_EquipWeapon).name;
}
}
battleData = new BattleSendData(attackerData, targetData, backGround, isHeal || !attacker.m_IsEnemy, isHeal, isDirectAtk, isCounter, getExp, getItem, playerClass, lvUpProp, playerData);
//TODO set battle data to demo
////send to battle scene
//isWaitingBattle = true;
//battleData = new BattleSendData(attackerName, targetName, backGround, attackerTileName, targetTileName, isPlayerAttack, isHeal, isCounter, isDirectAtk, attackerDefensRate, targetDefensRate, attackerMaxHP, attackerHP, damageByAttacker, targetMaxHP, targetHP, damageByTarget, getItem, playerExp, getExp, level, playerClass, playerData, lvUpProp);
//Debug.Log(Newtonsoft.Json.JsonConvert.SerializeObject(battleData));
////SceneManager.LoadScene("Battle");
}