// Start is called before the first frame update
void Start()
{
if (instance != null && instance != this)
{
Destroy(transform.gameObject);
}
else
{
instance = this;
DontDestroyOnLoad(transform.gameObject);
DontDestroyOnLoad(moveTarget.gameObject);
}
currentlySelectedUnit = null;
moveTarget.parent = null;
rb = GetComponent <Rigidbody2D>();
col = GetComponent <BoxCollider2D>();
isMovingUnit = false;
isChoosingAttackTarget = false;
selectedButtonIndex = -1;
weaponBListIndex = -1;
timeSinceLastButtonChange = 0.2f;
attackTargetIndex = -1;
attackableTargets = new List <GameObject>();
if (validSpaceMap != null)
{
WipeValidSpaceMap();
}
SceneManager.activeSceneChanged += SceneChanged;
}
// Update is called once per frame
void Update()
{
if (instance != null && instance != this)
{
DestroySelf();
return;
}
if (!canUpdate)
{
return;
}
if (levelUpCanvas.active || levelUpInfoCanvas.active || weaponUpgradeCanvas.active)
{
return;
}
if (mapBoss != null)
{
didHaveABoss = true;
}
// Handle dead units
for (int i = playerUnitList.Count - 1; i >= 0; i--)
{
var unit = playerUnitList[i];
var unitStats = unit.GetComponent <CharacterStats>();
if (unitStats.currentHp <= 0)
{
fallenPlayerUnitList.Add(unit);
playerUnitList.Remove(unit);
}
}
// Victory and Defeat Conditions
// If the map had a boss, and the boss is nonexistent (has been killed), you win!
if (didHaveABoss && !mapBoss.active)
{
victoryCanvas.active = true;
canUpdate = false;
return;
}
// if the player units are all gone, you lose...
if (playerUnitList.Count == 0)
{
defeatCanvas.active = true;
return;
}
// If the enemy units are all gone, you win!
if (enemyUnitList.Count == 0)
{
playerTurnCanvas.active = false;
enemyTurnCanvas.active = false;
defeatCanvas.active = false;
victoryCanvas.active = true;
canUpdate = false;
return;
}
else
{
bool enemiesAllDead = true;
for (int i = 0; i < enemyUnitList.Count; i++)
{
if (enemyUnitList[i] != null && enemyUnitList[i].active)
{
enemiesAllDead = false;
break;
}
}
if (enemiesAllDead)
{
victoryCanvas.active = true;
playerTurnCanvas.active = false;
enemyTurnCanvas.active = false;
defeatCanvas.active = false;
canUpdate = false;
}
else
{
victoryCanvas.active = false;
}
}
if (enemyTurnCanvas.active)
{
return;
}
/**
* if (defeatCanvas.active || victoryCanvas.active || enemyTurnCanvas.active || playerTurnCanvas.active)
* {
* return;
* }
**/
if (isPlayerTurn)
{
if (indexOfMovingEnemy == -1)
{
playerTurnCanvas.active = true;
indexOfMovingEnemy -= 1;
return;
}
try
{
for (int i = enemyUnitList.Count - 1; i >= 0; i--)
{
var unit = enemyUnitList[i];
var unitStats = unit.GetComponent <CharacterStats>();
if (unitStats.currentHp <= 0)
{
fallenEnemyUnitList.Add(unit);
enemyUnitList.Remove(unit);
}
}
}
catch (Exception e)
{
}
// Check if it is still the player's turn.
isPlayerTurn = false;
for (int i = 0; i < playerUnitList.Count; i++)
{
if (playerUnitList[i] == null)
{
continue;
}
var unitStats = playerUnitList[i].GetComponent <CharacterStats>();
if (!playerUnitList[i].active)
{
continue;
}
if (unitStats.hasMoved == 0)
{
isPlayerTurn = true;
break;
}
}
// If the player's turn has just ended, do some prep work: reset player unit has moved values, and tell self that it's enemy turn
if (!isPlayerTurn)
{
for (int i = 0; i < playerUnitList.Count; i++)
{
var unitStats = playerUnitList[i].GetComponent <CharacterStats>();
unitStats.hasMoved = 0;
}
indexOfMovingEnemy = 0;
// enemyUnitList = enemyUnitList.Where(x => x != null).ToList();
foreach (GameObject unit in enemyUnitList)
{
var unitStats = unit.GetComponent <CharacterStats>();
if (unitStats.currentHp <= 0)
{
fallenEnemyUnitList.Add(unit);
enemyUnitList.Remove(unit);
}
}
enemyTurnCanvas.active = true;
}
}
else
{
// If index of moving enemy is outside of enemy list length, enemy turn has ended. Perform clean-up and pass back to player.
if (indexOfMovingEnemy >= enemyUnitList.Count)
{
for (int i = 0; i < enemyUnitList.Count; i++)
{
if (enemyUnitList[i] != null)
{
var unitStats = enemyUnitList[i].GetComponent <CharacterStats>();
unitStats.hasMoved = 0;
}
}
try
{
for (int i = enemyUnitList.Count - 1; i >= 0; i--)
{
var unit = enemyUnitList[i];
var unitStats = unit.GetComponent <CharacterStats>();
if (unitStats.currentHp <= 0)
{
fallenEnemyUnitList.Add(unit);
enemyUnitList.Remove(unit);
}
}
}
catch (Exception e)
{
}
indexOfMovingEnemy = -1;
isPlayerTurn = true;
return;
}
GameObject currEnemy = enemyUnitList[indexOfMovingEnemy];
if (currEnemy == null || !currEnemy.active)
{
indexOfMovingEnemy += 1;
return;
}
var currEnemyStats = currEnemy.GetComponent <CharacterStats>();
// If it's not the player's turn, take the enemy's turn.
// This part of the method handles the current index enemy before moving to the next
if (!isMovingEnemy)
{
var currEnemyX = currEnemy.transform.position.x;
var currEnemyY = currEnemy.transform.position.y;
List <GameObject> attackablePlayerUnits = new List <GameObject>();
FindAttackableTargets(currEnemyStats.weaponRange, currEnemyStats.Mov, currEnemyX, currEnemyY, attackablePlayerUnits);
if (attackablePlayerUnits.Count <= 0)
{
currEnemyStats.hasMoved = 1;
indexOfMovingEnemy += 1;
}
else
{
attackTarget = null;
int highestDamage = -1;
for (int i = 0; i < attackablePlayerUnits.Count; i++)
{
int currDamage = ForecastDamage(currEnemy, attackablePlayerUnits[i]);
if (currDamage > highestDamage)
{
highestDamage = currDamage;
attackTarget = attackablePlayerUnits[i];
}
}
if (attackTarget != null)
{
List <Vector3> possibleEndPoints = new List <Vector3>();
Vector3 basePosition = attackTarget.transform.position;
Vector3 currEnemyPos = currEnemy.transform.position;
if (currEnemyStats.weaponRange == 2)
{
possibleEndPoints.Add(new Vector3(basePosition.x + 1, basePosition.y + 1, 0f));
possibleEndPoints.Add(new Vector3(basePosition.x + 1, basePosition.y - 1, 0f));
possibleEndPoints.Add(new Vector3(basePosition.x - 1, basePosition.y + 1, 0f));
possibleEndPoints.Add(new Vector3(basePosition.x - 1, basePosition.y - 1, 0f));
}
possibleEndPoints.Add(new Vector3(basePosition.x + 1, basePosition.y, 0f));
possibleEndPoints.Add(new Vector3(basePosition.x - 1, basePosition.y, 0f));
possibleEndPoints.Add(new Vector3(basePosition.x, basePosition.y + 1, 0f));
possibleEndPoints.Add(new Vector3(basePosition.x, basePosition.y - 1, 0f));
for (int i = possibleEndPoints.Count - 1; i >= 0; i--)
{
Vector3 end = possibleEndPoints[i];
var dist = Mathf.Abs(end.x - currEnemyPos.x) + Mathf.Abs(end.y - currEnemyPos.y);
int currMove = currEnemyStats.Mov;
if (currMove == 0)
{
currMove = 1;
}
if (dist > (currMove + 0.2f))
{
possibleEndPoints.RemoveAt(i);
}
else if (Physics2D.OverlapCircle(end, 0.1f, mapEdge))
{
possibleEndPoints.RemoveAt(i);
}
}
// possibleEndPoints = possibleEndPoints.Where(x => (((Mathf.Abs(x.x - currEnemyPos.x)) + (Mathf.Abs(x.y - currEnemyPos.y))) <= (currEnemyStats.Mov + currEnemyStats.weaponRange))).ToList();
// possibleEndPoints = possibleEndPoints.Where(x => !Physics2D.OverlapCircle(x, 0.1f, mapEdge)).ToList();
foreach (GameObject unit in playerUnitList)
{
if (unit != null)
{
for (int i = possibleEndPoints.Count - 1; i >= 0; i--)
{
Vector3 end = possibleEndPoints[i];
if (end == unit.transform.position)
{
possibleEndPoints.RemoveAt(i);
}
}
}
}
foreach (GameObject unit in enemyUnitList)
{
if (unit != null && unit != currEnemy)
{
for (int i = possibleEndPoints.Count - 1; i >= 0; i--)
{
Vector3 end = possibleEndPoints[i];
if (end == unit.transform.position)
{
possibleEndPoints.RemoveAt(i);
}
}
}
}
if (possibleEndPoints.Contains(currEnemyPos))
{
targetMovePosition = currEnemyPos;
isMovingEnemy = true;
}
switch (possibleEndPoints.Count)
{
case 0:
currEnemyStats.hasMoved = 1;
indexOfMovingEnemy += 1;
dist = 0;
break;
case 1:
targetMovePosition = possibleEndPoints[0];
currEnemyPos = Vector3.MoveTowards(currEnemy.transform.position, targetMovePosition, 10 * Time.deltaTime);
isMovingEnemy = true;
dist += (int)Math.Abs(basePosition.x - targetMovePosition.x);
dist += (int)Math.Abs(basePosition.y - targetMovePosition.y);
break;
default:
targetMovePosition = possibleEndPoints[0];
currEnemyPos = Vector3.MoveTowards(currEnemy.transform.position, targetMovePosition, 10 * Time.deltaTime);
isMovingEnemy = true;
dist += (int)Math.Abs(basePosition.x - targetMovePosition.x);
dist += (int)Math.Abs(basePosition.y - targetMovePosition.y);
break;
}
}
}
}
else
{
currEnemy.transform.position = Vector3.MoveTowards(currEnemy.transform.position, targetMovePosition, 10 * Time.deltaTime);
if (Vector3.Distance(currEnemy.transform.position, targetMovePosition) <= 0.02f)
{
CharacterStats currPlayerStats = attackTarget.GetComponent <CharacterStats>();
var currEnemyLevel = currEnemyStats.level;
var currPlayerLevel = currPlayerStats.level;
Attack(currEnemy, attackTarget, dist);
dist = 0;
try
{
currEnemyStats.hasMoved = 1;
if (currPlayerStats.currentHp > 0)
{
if (currEnemyStats.currentHp <= 0)
{
currPlayerStats.exp += 100;
levelUpCanvas.active = true;
}
else if (currPlayerLevel <= currEnemyLevel)
{
if (currPlayerStats.exp >= 70)
{
levelUpCanvas.active = true;
}
currPlayerStats.exp += 30;
}
else if (currPlayerLevel - currEnemyLevel <= 2)
{
if (currPlayerStats.exp >= 85)
{
levelUpCanvas.active = true;
}
currPlayerStats.exp += 15;
}
else
{
if (currPlayerStats.exp >= 95)
{
levelUpCanvas.active = true;
}
currPlayerStats.exp += 5;
}
}
}
catch (Exception e)
{
}
if (levelUpCanvas.active)
{
Player_Cursor_Controls cursorScript = cursor.GetComponent <Player_Cursor_Controls>();
cursorScript.currentlySelectedUnit = attackTarget;
cursor.transform.position = cursorScript.currentlySelectedUnit.transform.position;
cursorScript.moveTarget.position = cursor.transform.position;
}
isMovingEnemy = false;
indexOfMovingEnemy += 1;
}
}
}
}
