public void EndTurn()
{
foreach (BattlePawn pawn in m_charactersInBattle)
{
if (pawn.m_timeUntilTurn == 0)
{
pawn.m_timeUntilTurn = m_charactersInBattle.Count;
}
pawn.m_timeUntilTurn--;
}
foreach (BattlePawn pawn in m_charactersInBattle)
{
if (pawn.m_timeUntilTurn == 0)
{
if (pawn.m_myTurn)
{
return;
}
m_currentTurnPawn = pawn;
m_turnTimer = m_turnDelay;
m_battleState = BattleState.BATTLESTATE_INBETWEENTURN;
}
}
}
public override void Inflict(BattlePawn inflicted, BattlePawn creator)
{
r_InflictedPawn = inflicted;
r_Creator = creator;
m_visual = Instantiate(m_visualPrefab, r_InflictedPawn.gameObject.transform, false);
m_visual.transform.SetPositionAndRotation(r_InflictedPawn.transform.position, r_InflictedPawn.transform.rotation);
}
public override bool UseSkill(BattlePawn user, int targetX, int targetY)
{
m_user = user;
m_target = user.m_battleSystem.m_battleSpaces[targetX, targetY].m_pawn;
m_user.m_battleSystem.m_playingSkillAnimation = true;
m_user.m_playingSkillAnimation = true;
if (m_user.m_facingLeft)
{
m_user.GetComponent <SpriteRenderer>().sprite = m_user.m_spriteL;
}
else
{
m_user.GetComponent <SpriteRenderer>().sprite = m_user.m_spriteR;
}
m_animationStarted = false;
m_user.m_SP -= m_spCost;
m_user.m_AP -= m_apCost;
if (m_user.m_x < targetX)
{
m_fireDirection = Direction.DIRECTION_RIGHT;
}
else if (m_user.m_x > targetX)
{
m_fireDirection = Direction.DIRECTION_LEFT;
}
//determin the direction and face the arrow and user that way
switch (m_fireDirection)
{
case Direction.DIRECTION_NONE:
break;
case Direction.DIRECTION_UP:
break;
case Direction.DIRECTION_DOWN:
break;
case Direction.DIRECTION_RIGHT:
m_user.GetComponent <SpriteRenderer>().sprite = r_CharacterSpriteRight;
m_Bolt = Instantiate(r_BoltPrefab, m_user.gameObject.transform.position + new Vector3(0, 0, 0.7f), Quaternion.Euler(0, 90, 0));
break;
case Direction.DIRECTION_LEFT:
m_user.GetComponent <SpriteRenderer>().sprite = r_CharacterSpriteLeft;
m_Bolt = Instantiate(r_BoltPrefab, m_user.gameObject.transform.position + new Vector3(0, 0, 0.7f), Quaternion.identity);
break;
default:
break;
}
m_animationStarted = true;
return(true);
}
public override bool UseItem(BattlePawn user, int targetX, int targetY)
{
m_user = user;
m_user.m_battleSystem.m_playingItemAnimation = true;
m_user.m_playingItemAnimation = true;
m_target = m_user.m_battleSystem.m_battleSpaces[targetX, targetY].m_pawn;
Instantiate(m_particle, m_user.m_battleSystem.m_battleSpaces[targetX, targetY].m_pawn.transform.position + new Vector3(0, 1.5f, 0), m_particle.transform.rotation);
play = true;
return(true);
}
public bool CanUseSkill(BattlePawn user)
{
//the check to see if the skill can be selected to use from the skill menu
if (user.m_AP >= m_apCost && user.m_SP >= m_spCost)
{
return(true);
}
else
{
return(false);
}
}
public override bool ValidTarget(BattlePawn m_user, int targetX, int targetY)
{
if (m_user.isInRange(targetX, targetY, m_rangeMin, m_rangeMax) && m_user.m_battleSystem.m_battleSpaces[targetX, targetY].m_occupied)
{
if (m_user.m_battleSystem.m_battleSpaces[targetX, targetY].m_pawn.gameObject.tag == "Enemy")
{
return(true);
}
}
return(false);
}
public override bool ValidTarget(BattlePawn user, int targetX, int targetY)
{
m_user = user;
if (m_user.isInRange(targetX, targetY, 1) && m_user.m_battleSystem.m_battleSpaces[targetX, targetY].m_occupied)
{
if (m_user.m_battleSystem.m_battleSpaces[targetX, targetY].m_pawn.gameObject.tag == "Player")
{
return(true);
}
}
return(false);
}
public void Death(BattlePawn deadPawn)
{
foreach (BattlePawn pawn in m_charactersInBattle)
{
if (pawn.m_timeUntilTurn > deadPawn.m_timeUntilTurn)
{
pawn.m_timeUntilTurn--;
}
}
m_charactersInBattle.Remove(deadPawn);
m_battleSpaces[deadPawn.m_x, deadPawn.m_y].m_occupied = false;
m_battleSpaces[deadPawn.m_x, deadPawn.m_y].m_pawn = null;
if (deadPawn.tag == "Enemy")
{
m_enemies--;
foreach (BattlePawn character in m_charactersInBattle)
{
if (character.tag == "Player")
{
//Gain EXP based on enemy level
int levelDif = deadPawn.m_level - character.m_level;
int levelDifBoost = deadPawn.m_level + levelDif;
if (levelDifBoost < 0)
{
levelDifBoost = 0;
}
character.m_expGain += levelDifBoost + deadPawn.m_level;
}
}
}
else
{
m_allies--;
}
if (m_allies == 0)
{
m_battleState = BattleState.BATTLESTATE_LOSE;
r_characterActionButtons.SetActive(false);
return;
}
if (m_enemies == 0)
{
m_battleState = BattleState.BATTLESTATE_WIN;
r_characterActionButtons.SetActive(false);
}
}
public void StartBattle()
{
m_battleSystem.m_battleSpaces[m_x, m_y].m_occupied = true;
m_battleSystem.m_battleSpaces[m_x, m_y].m_pawn = this;
gameObject.transform.position = new Vector3(m_battleSystem.m_battleSpaces[m_x, m_y].m_cube.transform.position.x,
0.5f,
m_battleSystem.m_battleSpaces[m_x, m_y].m_cube.transform.position.z);
if (gameObject.tag == "Enemy")
{
foreach (BattlePawn pawn in m_battleSystem.m_charactersInBattle)
{
if (pawn.gameObject.tag == "Player")
{
r_playerPawns.Add(pawn);
}
}
r_targetPlayer = r_playerPawns[0];
}
}
void OnLevelFinishedLoading(Scene scene, LoadSceneMode mode)
{
Debug.Log("Level Loaded");
Debug.Log(scene.name);
Debug.Log(mode);
if (scene.name == "WorldMap")
{
m_mapPawn = Instantiate(m_mapPawnPrefab, m_mapPosition, Quaternion.identity);
m_mapPawn.GetComponent <MapPawn>().m_gameManager = this;
}
if (scene.name == "Battle")
{
int encounterNum = Random.Range(0, r_mapArea.m_encounters.Count);
Encounter currentEncounter = r_mapArea.m_encounters[encounterNum];
BattleSystem currentBattleSystem = FindObjectOfType <BattleSystem>();
foreach (CharacterSheet sheet in m_playerParty)
{
BattlePawn temp = Instantiate(sheet.m_battlePawnPrefab).GetComponent <BattlePawn>();
temp.r_characterSheet = sheet;
currentBattleSystem.m_charactersInBattle.Add(temp);
temp.SetUp();
}
for (int i = 0; i < currentEncounter.m_enemies.Count; i++)
{
BattlePawn temp = Instantiate(currentEncounter.m_enemies[i].m_BattlePawn).GetComponent <BattlePawn>();
temp.r_enemySheet = currentEncounter.m_enemies[i];
temp.m_x = currentEncounter.m_enemyLocations[i].x;
temp.m_y = currentEncounter.m_enemyLocations[i].y;
currentBattleSystem.m_charactersInBattle.Add(temp);
temp.SetUp();
}
currentBattleSystem.StartBattle();
}
}
public override bool UseSkill(BattlePawn user, int targetX, int targetY)
{
m_user = user;
m_target = user.m_battleSystem.m_battleSpaces[targetX, targetY].m_pawn;
m_user.m_battleSystem.m_playingSkillAnimation = true;
m_user.m_playingSkillAnimation = true;
m_animationStarted = false;
m_attackHasHit = false;
m_user.m_SP -= m_spCost;
m_user.m_AP -= m_apCost;
attackTimer = 1.0f;
if (m_user.m_x < targetX)
{
m_throwDirection = Direction.DIRECTION_RIGHT;
}
else if (m_user.m_x > targetX)
{
m_throwDirection = Direction.DIRECTION_LEFT;
}
else if (m_user.m_y < targetY)
{
m_throwDirection = Direction.DIRECTION_UP;
}
else if (m_user.m_y > targetY)
{
m_throwDirection = Direction.DIRECTION_DOWN;
}
oldPos = user.transform.position;
calcLandingSquare();
m_throwTimer = 1;
m_airTimeTimer = UP_TIME + (THROW_TIME_PER_SPACE * m_rangeMax) + UP_TIME / 2;
targetStart = m_target.gameObject.transform.position + new Vector3(0, 1, 0);
m_animationStarted = true;
//EndSkill();
return(true);
}
public void Attack(int targX, int targY, Vector3 targPos)
{
BattlePawn a_target = m_battleSystem.m_battleSpaces[targX, targY].m_pawn;
attackPos = targPos + new Vector3(0, 0, -0.1f);
oldPos = new Vector3(m_battleSystem.m_battleSpaces[m_x, m_y].m_cube.transform.position.x,
0.5f,
m_battleSystem.m_battleSpaces[m_x, m_y].m_cube.transform.position.z);
m_attackHasHit = false;
attackTimer = 1.0f;
m_targetX = targX;
m_targetY = targY;
if (targX > m_x)
{
gameObject.GetComponent <SpriteRenderer>().sprite = m_spriteR;
m_facingLeft = false;
}
else if (targX < m_x)
{
gameObject.GetComponent <SpriteRenderer>().sprite = m_spriteL;
m_facingLeft = true;
}
}
//called by the skill that made it when it is first made. should set up the visual indicator and initialize values abstract public void Inflict(BattlePawn inflicted, BattlePawn creator);
public void TakeDamage(BattlePawn attacker, DamageType damageType, float DamageMod)
{
bool isCrit = false;
int damageTotal = 0;
//calculate crit
if (Random.Range(0, 31 - attacker.m_speed + m_speed) == 0)
{
isCrit = true;
}
switch (damageType)
{
case DamageType.DAMAGETYPE_PHYSICAL:
if (isCrit)
{
// a criticle hit will not use defence
damageTotal = (int)((attacker.m_attack * Random.Range(1.0f, 1.5f)) * (DamageMod));
}
else
{
damageTotal = (int)((attacker.m_attack * Random.Range(1.0f, 1.5f) - (m_defence / 2 * Random.Range(1.0f, 0.5f))) * (DamageMod));
}
if (m_isDefending)
{
damageTotal = (int)(damageTotal / 2);
}
break;
case DamageType.DAMAGETYPE_MAGIC:
if (isCrit)
{
// a criticle hit will not use defence
damageTotal = (int)((attacker.m_magic * Random.Range(1.0f, 1.5f)) * (DamageMod));
}
else
{
damageTotal = (int)((attacker.m_magic * Random.Range(1.0f, 1.5f) - (m_magicDefence / 2 * Random.Range(1.0f, 0.5f))) * (DamageMod));
}
if (m_isDefending)
{
damageTotal = (int)(damageTotal / 2);
}
break;
case DamageType.DAMAGETYPE_SKILL:
if (isCrit)
{
// a criticle hit will not use defence
damageTotal = (int)((attacker.m_magic * Random.Range(1.0f, 1.5f)) * (DamageMod));
}
else
{
damageTotal = (int)((attacker.m_magic * Random.Range(1.0f, 1.5f) - (m_defence / 2 * Random.Range(1.0f, 0.5f))) * (DamageMod));
}
if (m_isDefending)
{
damageTotal = (int)(damageTotal / 2);
}
break;
case DamageType.DAMAGETYPE_MAGICWEAPON:
if (isCrit)
{
// a criticle hit will not use defence
damageTotal = (int)((attacker.m_attack * Random.Range(1.0f, 1.5f)) * (DamageMod));
}
else
{
damageTotal = (int)((attacker.m_attack * Random.Range(1.0f, 1.5f) - (m_magicDefence / 2 * Random.Range(1.0f, 0.5f))) * (DamageMod));
}
if (m_isDefending)
{
damageTotal = (int)(damageTotal / 2);
}
break;
default:
break;
}
if (damageTotal <= 0)
{
damageTotal = 1;
}
m_HP -= damageTotal;
r_hitParticle.emission.SetBurst(0, new ParticleSystem.Burst(0, damageTotal * 2));
r_hitParticle.Play();
r_damageNumbers.SpawnNumber(damageTotal, Color.red);
}
//sort function
static int SortBySpeed(BattlePawn p1, BattlePawn p2)
{
return(p2.m_speed.CompareTo(p1.m_speed));
}
//Function to start the fight after the Game Manager has set up the players and enemies
public void StartBattle()
{
//sets the first flag for the victory screen
m_victoryState = VictoryState.VICTORYSTATE_START;
m_SelectableSpaces = new List <BattleSpace>();
m_battleSpaces = new BattleSpace[8, 4];
int spaceNum = 0;
//set up battle spaces
for (int x = 0; x < 8; x++)
{
for (int y = 0; y < 4; y++)
{
m_battleSpaces[x, y] = new BattleSpace();
m_battleSpaces[x, y].m_cube = r_spaces[spaceNum];
m_battleSpaces[x, y].x = x;
m_battleSpaces[x, y].y = y;
spaceNum++;
}
}
m_battleState = BattleState.BATTLESTATE_START;
m_selectedCommand = Command.COMMAND_NONE;
foreach (BattlePawn pawn in m_charactersInBattle)
{
m_battleSpaces[pawn.m_x, pawn.m_y].m_pawn = pawn;
if (pawn.gameObject.tag == "Player")
{
m_partyMembers.Add(pawn);
m_StatusBoxes[m_partyMembers.Count - 1].r_character = pawn;
}
pawn.StartBattle();
}
TurnOrder();
EventSystem.current.SetSelectedGameObject(null);
r_attackButton.Select();
if (m_charactersInBattle[0].gameObject.tag == "Player")
{
m_battleState = BattleState.BATTLESTATE_PLAYER_TURN;
r_characterActionButtons.SetActive(true);
EventSystem.current.SetSelectedGameObject(null);
r_attackButton.Select();
}
else if (m_charactersInBattle[0].gameObject.tag == "Enemy")
{
m_battleState = BattleState.BATTLESTATE_ENEMY_TURN;
r_characterActionButtons.SetActive(false);
}
m_currentTurnPawn = m_charactersInBattle[0];
m_charactersInBattle[0].TakeTurn();
}
public void SetUp()
{
m_isDefending = false;
oldPos = gameObject.transform.position;
newPos = gameObject.transform.position;
m_battleSystem = FindObjectOfType <BattleSystem>();
r_damageNumbers = GetComponentInChildren <DamageNumbers>();
if (gameObject.tag == "Player")
{
CharacterSheet stats = r_characterSheet;
m_spriteR = stats.m_spriteR;
m_spriteL = stats.m_spriteL;
GetComponent <SpriteRenderer>().sprite = m_spriteL;
m_facingLeft = true;
m_level = stats.m_level;
m_name = stats.name;
m_maxHP = stats.m_maxHP;
m_HP = stats.m_currentHP;
m_maxSP = stats.m_maxSP;
m_SP = stats.m_currentSP;
m_maxAP = stats.m_maxAP;
m_AP = stats.m_currentAP;
m_attack = stats.m_strength;
m_defence = stats.m_fortitude;
m_magic = stats.m_wisdom;
m_magicDefence = stats.m_resistance;
m_speed = stats.m_agility;
m_x = stats.m_x;
m_y = stats.m_y;
}
if (gameObject.tag == "Enemy")
{
EnemySheet stats = r_enemySheet;
m_spriteR = stats.m_spriteR;
m_spriteL = stats.m_spriteL;
GetComponent <SpriteRenderer>().sprite = m_spriteR;
m_facingLeft = false;
m_level = stats.m_level;
m_maxHP = stats.m_maxHP;
m_HP = stats.m_HP;
m_maxSP = stats.m_maxSP;
m_SP = stats.m_SP;
m_maxAP = stats.m_maxAP;
m_AP = stats.m_AP;
m_attack = stats.m_attack;
m_defence = stats.m_defence;
m_magic = stats.m_magic;
m_magicDefence = stats.m_magicDefence;
m_speed = stats.m_speed;
foreach (BattlePawn pawn in m_battleSystem.m_charactersInBattle)
{
if (pawn.gameObject.tag == "Player")
{
r_playerPawns.Add(pawn);
}
}
r_targetPlayer = r_playerPawns[0];
}
}
abstract public bool UseSkill(BattlePawn user, int targetX, int targetY);
abstract public bool UseItem(BattlePawn user, int targetX, int targetY);
void calcLandingSquare()
{
int throwMax;
int range;
int i = 0;
switch (m_throwDirection)
{
case Direction.DIRECTION_NONE:
break;
case Direction.DIRECTION_UP:
//calculate the throw range so it cant go out of bounds
throwMax = 3 - m_target.m_y;
if (throwMax < THROWRANGE)
{
range = throwMax;
}
else
{
range = THROWRANGE;
}
if (m_target.m_y == 3)
{
m_hitPawn = null;
m_hasCollided = false;
m_landingDist = 1;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y];
break;
}
//loop through all squares in the throw path
for (i = 1; i <= range; i++)
{
//if there is an enemy in one, set it so thay will be hit and stop one tile short
if (m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y + i].m_occupied == true)
{
m_hitPawn = m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y + i].m_pawn;
m_hasCollided = true;
m_landingDist = i - 1;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y + i - 1];
return;
}
}
//if an enemy won't be hit, stop at the end of the range
m_hitPawn = null;
m_hasCollided = false;
m_landingDist = range;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y + i - 1];
break;
case Direction.DIRECTION_DOWN:
//calculate the throw range so it cant go out of bounds
throwMax = 0 + m_target.m_y;
if (throwMax < THROWRANGE)
{
range = throwMax;
}
else
{
range = THROWRANGE;
}
if (m_target.m_y == 0)
{
m_hitPawn = null;
m_hasCollided = false;
m_landingDist = 1;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y];
break;
}
//loop through all squares in the throw path
for (i = 1; i <= range; i++)
{
//if there is an enemy in one, set it so thay will be hit and stop one time short
if (m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y - i].m_occupied == true)
{
m_hitPawn = m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y - i].m_pawn;
m_hasCollided = true;
m_landingDist = i - 1;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y - i + 1];
return;
}
}
//if an enemy won't be hit, stop at the end of the range
m_hitPawn = null;
m_hasCollided = false;
m_landingDist = range;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y - i + 1];
break;
case Direction.DIRECTION_RIGHT:
//calculate the throw range so it cant go out of bounds
throwMax = 7 - m_target.m_x;
if (throwMax < THROWRANGE)
{
range = throwMax;
}
else
{
range = THROWRANGE;
}
m_user.GetComponent <SpriteRenderer>().sprite = m_user.m_spriteR;
if (m_target.m_x == 7)
{
m_hitPawn = null;
m_hasCollided = false;
m_landingDist = 1;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y];
break;
}
//loop through all squares in the throw path
for (i = 1; i <= range; i++)
{
//if there is an enemy in one, set it so thay will be hit and stop one time short
if (m_user.m_battleSystem.m_battleSpaces[m_target.m_x + 1, m_target.m_y].m_occupied == true)
{
m_hitPawn = m_user.m_battleSystem.m_battleSpaces[m_target.m_x + i, m_target.m_y].m_pawn;
m_hasCollided = true;
m_landingDist = i - 1;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x + i - 1, m_target.m_y];
return;
}
}
//if an enemy won't be hit, stop at the end of the range
m_hitPawn = null;
m_hasCollided = false;
m_landingDist = range;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x + i - 1, m_target.m_y];
break;
case Direction.DIRECTION_LEFT:
//calculate the throw range so it cant go out of bounds
throwMax = 0 + m_target.m_x;
if (throwMax < THROWRANGE)
{
range = throwMax;
}
else
{
range = THROWRANGE;
}
m_user.GetComponent <SpriteRenderer>().sprite = m_user.m_spriteL;
if (m_target.m_x == 0)
{
m_hitPawn = null;
m_hasCollided = false;
m_landingDist = 1;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x, m_target.m_y];
break;
}
//loop through all squares in the throw path
for (i = 1; i <= range; i++)
{
//if there is an enemy in one, set it so thay will be hit and stop one time short
if (m_user.m_battleSystem.m_battleSpaces[m_target.m_x - i, m_target.m_y].m_occupied == true)
{
m_hitPawn = m_user.m_battleSystem.m_battleSpaces[m_target.m_x - i, m_target.m_y].m_pawn;
m_hasCollided = true;
m_landingDist = i - 1;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x - i + 1, m_target.m_y];
return;
}
}
//if an enemy won't be hit, stop at the end of the range
m_hitPawn = null;
m_hasCollided = false;
m_landingDist = range;
m_landingSquare = m_user.m_battleSystem.m_battleSpaces[m_target.m_x - i + 1, m_target.m_y];
break;
default:
break;
}
}
abstract public bool ValidTarget(BattlePawn user, int targetX, int targetY);
