public BattleAbilityUseHandler(ref BaseCharacterClass character, int playerTargetIndex, ref BaseCharacterClass[] alliedCharacters, ref BaseEnemy[] enemies)
{
this.character = character;
this.playerTargetIndex = playerTargetIndex;
this.alliedCharacters = alliedCharacters;
this.enemies = enemies;
}
void Awake()
{
detector = gameObject.GetComponent<RangeDetector> ();
detector.range = 2;
character = detector.target.transform.GetComponent<BaseCharacterClass>();
}
/*
For testing purposes. Attacks the unit with highest presence
*/
public static Entity biggestPresenceStrategy(BaseCharacterClass[] characters, BaseEnemy[] enemies)
{
BaseCharacterClass target = characters[0];
for (int i = 1; i < characters.Length; i++)
{
if (target.presence < characters[i].presence)
{
target = characters[i];
}
}
return target;
}
public void PrepareBattle3()
{
TurnBasedCombatStateMachine.turnCount = 1;
//create enemy
Enemy1 = CreateMeleeEnemy();
Enemy2 = CreateHealerEnemy();
Enemy3 = CreateHealerEnemy();
//apply buffs or specs here
//Who's turn?
TurnBasedCombatStateMachine.currentState = TurnBasedCombatStateMachine.BattleStates.PLAYERCHOICE;
}
private void RetrieveBaseStatPoints()
{
BaseCharacterClass characterClass = GameInformation.PlayerClass;
pointsToAllocate[0] = characterClass.Rhetoric;
baseStatPoints[0] = characterClass.Rhetoric;
pointsToAllocate[1] = characterClass.Image;
baseStatPoints[1] = characterClass.Image;
pointsToAllocate[2] = characterClass.Diplomacy;
baseStatPoints[2] = characterClass.Diplomacy;
}
public static bool RunAwayFromCombat(BaseCharacterClass player, BaseCharacterClass enemy)
{
bool isRunningAwayFromCombat = false;
if ((player.agility * Random.Range(MinMaxRandomEscape.x, MinMaxRandomEscape.y)) < (enemy.agility * Random.Range(MinMaxRandomEscape.x, MinMaxRandomEscape.y) * EnemyNerfValueForEscape)) //Agil
{
isRunningAwayFromCombat = true;
}
return(isRunningAwayFromCombat);
}
public void LoadPlayer(string player)
{
LoadStats(player);
transform.GetComponent<Animator>().SetBool("death", false);
LoadScale();
if (character == "Warrior")
{
playerClass = new BaseWarriorClass();
}
pause = 0;
}
// Left Button Function - Display Previous Character
public void LeftButton()
{
currentIndex--;
// Prevent Array out of bound
if (currentIndex < 0)
{
currentIndex = 0;
}
currentCharacter.overrideSprite = characterSprites [currentIndex];
currentClass = classDatabase.GetClass(currentIndex);
DisplayStat();
}
// Right Button Function - Display Next Character
public void RightButton()
{
currentIndex++;
// Prevent Array out of Bound
if (currentIndex >= characterSprites.Length)
{
currentIndex = characterSprites.Length - 1;
}
currentCharacter.overrideSprite = characterSprites [currentIndex];
currentClass = classDatabase.GetClass(currentIndex);
DisplayStat();
}
public static void ApplyDoping(BaseCharacterClass target)
{
if (target.Buffed == 0)
{
target.IsDoping = true;
target.Buffed = 3;
target.Defense = (float)Math.Ceiling(target.Defense *= target.ability3.multiplier);
target.Magicdefense = (float)Math.Ceiling(target.Magicdefense *= target.ability3.multiplier);
target.MaxHealth += 10;
}
else if (target.Buffed > 0)
{
target.Buffed = 3;
}
}
public void Init(int enemyType)
{
if (enemyType == orc)
{
bcc = new Orc();
}
else if (enemyType == elemental)
{
bcc = new Elemental();
}
else
{
bcc = new Boss();
}
}
private void RetrieveStatBaseStatPoints()
{
BaseCharacterClass cClass = GameInformation.PlayerClass;
pointsToAllocate[0] = cClass.Strength;
baseStatPoints[0] = cClass.Strength;
pointsToAllocate[1] = cClass.Dexterity;
baseStatPoints[1] = cClass.Dexterity;
pointsToAllocate[2] = cClass.Intellegence;
baseStatPoints[2] = cClass.Intellegence;
pointsToAllocate[3] = cClass.Charisma;
baseStatPoints[3] = cClass.Charisma;
pointsToAllocate[4] = cClass.Luck;
baseStatPoints[4] = cClass.Luck;
}
// Confirm Button Function - Confirm Player's Character Selection
public void SelectCharacter()
{
selectClass = currentClass;
pm._playerName = playerName.text;
pm._playerClass = selectClass.ClassName;
pm._playerLevel = 0;
pm._playerExp = 0;
pm._playerHP = 10;
pm._playerVit = selectClass.Vitality;
pm._playerStr = selectClass.Strength;
pm._playerDef = selectClass.Defense;
pm._playerLuck = selectClass.Luck;
pm._playerPosX = 0;
pm._playerPosY = 0;
pm._playerPosZ = 0;
}
private void RetrieveBaseStatPoints()
{
BaseCharacterClass cClass = GameInformation.PlayerClass;
pointsToAllocate [0] = cClass.Stamina;
baseStatPoints [0] = cClass.Stamina;
pointsToAllocate [1] = cClass.Endurance;
baseStatPoints [1] = cClass.Endurance;
pointsToAllocate [2] = cClass.Intellect;
baseStatPoints [2] = cClass.Intellect;
pointsToAllocate [3] = cClass.Strength;
baseStatPoints [3] = cClass.Strength;
}
public BaseCharacterClass ChargerPlayer(BaseCharacterClass player)
{
player.characterClass = OmniPlayer.Instance.characterClass;
player.characterLevel = OmniPlayer.Instance.characterLevel;
player.experience = OmniPlayer.Instance.experience;
player.maxExperience = OmniPlayer.Instance.maxExperience;
player.strenght = OmniPlayer.Instance.strenght;
player.endurance = OmniPlayer.Instance.endurance;
player.intelligence = OmniPlayer.Instance.intelligence;
player.agility = OmniPlayer.Instance.agility;
player.currentHP = OmniPlayer.Instance.currentHP;
player.maxHP = OmniPlayer.Instance.maxHP;
player.currentMana = OmniPlayer.Instance.currentMana;
player.maxMana = OmniPlayer.Instance.maxMana;
return(player);
}
void incrementAllyHealth()
{
foreach (PartyLayout ally in gameLoop.partyManager.listOfAllies)
{
BaseCharacterClass currentChar = ally.friendlyPrefab.GetComponent <BaseCharacterClass>();
List <string> keys = new List <string>(battleSystemRef.healthManager.Keys);
foreach (string key in keys)
{
if (currentChar.CharacterClassName == key)
{
battleSystemRef.healthManager[key] = battleSystemRef.healthManager[key] + healthRestore;
if (battleSystemRef.healthManager[key] >= currentChar.MaxHealth)
{
battleSystemRef.healthManager[key] = currentChar.MaxHealth;
}
}
}
}
}
//dohvata poene za odredjenu klasu i upisuje ih u niz koji se zatim prikazuje na guiu i pravi niz koji cemo da editujemo i cuvamo u bazi
private void RetrieveStatBaseStatPoints()
{
BaseCharacterClass cClass = GameInformation.PlayerClass;
pointsToAllcoate [0] = cClass.Stamina;
baseStatPoints [0] = cClass.Stamina;
pointsToAllcoate [1] = cClass.Endurance;
baseStatPoints [1] = cClass.Endurance;
pointsToAllcoate [2] = cClass.Strenght;
baseStatPoints [2] = cClass.Strenght;
pointsToAllcoate [3] = cClass.Agility;
baseStatPoints [3] = cClass.Agility;
pointsToAllcoate [4] = cClass.Intelect;
baseStatPoints [4] = cClass.Intelect;
pointsToAllcoate [5] = cClass.Resistance;
baseStatPoints [5] = cClass.Resistance;
pointsToAllcoate [6] = cClass.MagicResistance;
baseStatPoints [6] = cClass.MagicResistance;
}
public static void RemoveDivineLight(BaseCharacterClass target1, BaseCharacterClass target2, BaseCharacterClass target3)
{
if (target1.BuffedH == 0 && target1.IsDivLit)
{
target1.IsDivLit = false;
target1.Defense = (float)Math.Ceiling(target1.Defense /= PlayerParty.Healer.ability4.multiplier);
target1.Magicdefense = (float)Math.Ceiling(target1.Magicdefense /= PlayerParty.Healer.ability4.multiplier);
target1.MaxHealth -= 5;
target2.IsDivLit = false;
target2.Defense = (float)Math.Ceiling(target2.Defense /= PlayerParty.Healer.ability4.multiplier);
target2.Magicdefense = (float)Math.Ceiling(target2.Magicdefense /= PlayerParty.Healer.ability4.multiplier);
target2.MaxHealth -= 5;
target3.IsDivLit = false;
target3.Defense = (float)Math.Ceiling(target3.Defense /= PlayerParty.Healer.ability4.multiplier);
target3.Magicdefense = (float)Math.Ceiling(target3.Magicdefense /= PlayerParty.Healer.ability4.multiplier);
target3.MaxHealth -= 5;
}
}
/*
Attacks based on presence
*/
public static Entity purePresenceStrategy(BaseCharacterClass[] characters, BaseEnemy[] enemies)
{
int totalPresence = 0;
foreach (BaseCharacterClass c in characters) {
totalPresence += c.presence;
}
int random = Random.Range(0, totalPresence);
int presenceAccumulator = 0;
foreach (BaseCharacterClass c in characters)
{
int characterPresence = c.presence;
if (random <= characterPresence + presenceAccumulator)
{
return c;
}
presenceAccumulator += characterPresence;
}
// Should never reach this case!
return null;
}
public static float Attack(BaseCharacterClass attacker, BaseCharacterClass defender)
{
float damageDealt = 0;
AttackType atkType;
if (!EvadeAttack())
{
atkType = (attacker.isPhysicalAttacker) ? AttackType.Physical : AttackType.Magic;
if (atkType == AttackType.Physical)
{
if (CriticalHit())
{
damageDealt = (attacker.strenght - defender.endurance) * CritRatio;
}
else
{
damageDealt = (attacker.strenght - defender.endurance);
}
}
else
{
if (CriticalHit())
{
damageDealt = (attacker.intelligence - defender.intelligence) * CritRatio;
}
else
{
damageDealt = (attacker.intelligence - defender.intelligence);
}
}
}
if (damageDealt < 0)
{
damageDealt = 0;
}
return(damageDealt);
}
public CharClass(characterClass thisClass)
{
switch (thisClass)
{
case characterClass.WARRIOR:
Statistics = new BaseCharacterClass(BaseCharacterClass.mainStat.STR_MAIN);
className = "Warrior";
classDescription = "A very strong character that uses brute force to fight enemies";
break;
case characterClass.MAGE:
Statistics = new BaseCharacterClass(BaseCharacterClass.mainStat.INT_MAIN);
className = "Mage";
classDescription = "Physically weak character that can cast powerful spells";
break;
case characterClass.ARCHER:
Statistics = new BaseCharacterClass(BaseCharacterClass.mainStat.AGI_MAIN);
className = "Archer";
classDescription = "Very agile character that shots enemies with bow and arrows";
break;
}
}
private void RetrieveStatBaseStatPoints()
{
BaseCharacterClass cClass = GameInformation.PlayerClass;
pointsToAllocate [0] = cClass.Stamina;
pointsToAllocate [1] = cClass.Endurance;
pointsToAllocate [2] = cClass.Intellect;
pointsToAllocate [3] = cClass.Strength;
pointsToAllocate [4] = cClass.Overpower;
pointsToAllocate [5] = cClass.Luck;
pointsToAllocate [6] = cClass.Mastery;
pointsToAllocate [7] = cClass.Charisma;
baseStatPoints [0] = cClass.Stamina;
baseStatPoints [1] = cClass.Endurance;
baseStatPoints [2] = cClass.Intellect;
baseStatPoints [3] = cClass.Strength;
baseStatPoints [4] = cClass.Overpower;
baseStatPoints [5] = cClass.Luck;
baseStatPoints [6] = cClass.Mastery;
baseStatPoints [7] = cClass.Charisma;
}
public static void ApplyDivineLight(BaseCharacterClass target1, BaseCharacterClass target2, BaseCharacterClass target3)
{
if ((target1.BuffedH == 0) && (target2.BuffedH == 0) && (target3.BuffedH == 0))
{
target1.BuffedH = target2.BuffedH = target3.BuffedH = 3;
target1.IsDivLit = target2.IsDivLit = target3.IsDivLit = true;
target1.Defense = (float)Math.Ceiling(target1.Defense *= PlayerParty.Healer.ability4.multiplier);
target1.Magicdefense = (float)Math.Ceiling(target1.Magicdefense *= PlayerParty.Healer.ability4.multiplier);
target1.MaxHealth += 5;
target2.Defense = (float)Math.Ceiling(target2.Defense *= PlayerParty.Healer.ability4.multiplier);
target2.Magicdefense = (float)Math.Ceiling(target2.Magicdefense *= PlayerParty.Healer.ability4.multiplier);
target2.MaxHealth += 5;
target3.Defense = (float)Math.Ceiling(target3.Defense *= PlayerParty.Healer.ability4.multiplier);
target3.Magicdefense = (float)Math.Ceiling(target3.Magicdefense *= PlayerParty.Healer.ability4.multiplier);
target3.MaxHealth += 5;
}
else if (target1.BuffedH > 0)
{
target1.BuffedH = target2.BuffedH = target3.BuffedH = 3;
}
}
public void Init()
{
inputManager = new InputManager();
rb2D = GetComponent <Rigidbody2D>();
anim = GetComponent <Animator>();
//classe du player selon le choix .... pour linstant 1 = guerrier, 2 = mage;
if (OmniPlayer.Instance.characterLevel != 0) //get previous scene data
{
bcc = new BaseCharacterClass();
bcc.characterClass = OmniPlayer.Instance.characterClass;
bcc.characterLevel = OmniPlayer.Instance.characterLevel;
bcc.experience = OmniPlayer.Instance.experience;
bcc.maxExperience = OmniPlayer.Instance.maxExperience;
bcc.strenght = OmniPlayer.Instance.strenght;
bcc.endurance = OmniPlayer.Instance.endurance;
bcc.intelligence = OmniPlayer.Instance.intelligence;
bcc.agility = OmniPlayer.Instance.agility;
bcc.currentHP = OmniPlayer.Instance.currentHP;
bcc.maxHP = OmniPlayer.Instance.maxHP;
bcc.currentMana = OmniPlayer.Instance.currentMana;
bcc.maxMana = OmniPlayer.Instance.maxMana;
gameObject.transform.position = OmniPlayer.Instance.position;
}
else
{
if (isWarrior)
{
bcc = new Warrior();
}
else
{
bcc = new Wizard();
}
}
SavePlayer();
}
// Add any amount of exp
public void GiveExpToCharacter(int exp, BaseCharacterClass character)
{
character.level.AddExp(exp);
}
// Add any amount of exp
public void GiveExpToCharacter(int exp, BaseCharacterClass character)
{
character.level.AddExp (exp);
}
// use the difference in the level, any buffs, states, or other
// parameters to calculate the exp to give the killer based on
// the variable value.
public void KillExpToGive(BaseCharacterClass killed, BaseCharacterClass killer)
{
float percent = (float)killed.level.level / killer.level.level;
int exp = (int)(value * percent);
killer.level.AddExp(exp);
}
public void TakeDamageFromCharacter([NotNull] BaseCharacterClass baseCharacter)
{
CurrentHealth -= (int)baseCharacter.BaseStats.Power;
if (CurrentHealth <= 0)
isDead = true;
}
/*
Changes the text of the UI to reflect the current character abilities and overall items.
It also updates the text to show possible targets.
*/
public void personaliseMenuToCharacter(BaseCharacterClass c)
{
this.allyTurnReady = c;
characterName.text = allyTurnReady.getName();
changeMenuText();
}
void Awake()
{
player = gameObject.GetComponent<BaseCharacterClass> ();
}
private BaseAbility ChooseHealerEnemyAbility(BaseCharacterClass enemy)
{
return(enemy.ability2);
}
//battle 2
private void EnemyAction(BaseCharacterClass Enemy1, BaseCharacterClass Enemy2, BaseCharacterClass Enemy3)
{
//ability
//damage
//end
}
public Game()
{
knight = new BaseCharacterClass();
rogue = new BaseCharacterClass();
wizard = new BaseCharacterClass();
}
void MageClicked()
{
createdCharacter = new BaseMageClass();
UpdateCharacterDetailsView();
}
public void RestoreHealth(BaseCharacterClass bs)
{
CurrentHealth += (int)bs.BaseStats.Power;
}
// ...
public void SetModel(BaseCharacterClass chr)
{
healthText.text = chr.Health.ToString();
manaText.text = chr.Mana.ToString();
// ...
}
void Awake()
{
player = gameObject.GetComponent <BaseCharacterClass> ();
}
private void checkIfAllyTurnReadyIsDead()
{
if (allyTurnReady != null && allyTurnReady.isDead())
{
this.allyTurnReady = null;
}
}
/*
Simplest of strategies, attacks a random character.
*/
public static Entity randomStrategy(BaseCharacterClass[] characters, BaseEnemy[] enemies)
{
return characters[Random.Range(0, characters.Length - 1)];
}
/* Update is called once per frame
The function works like this:
- The turnQueue is queried to see if someone's turn should begin
- Depending on the state of the battle, a turn is executed, nothing happens...etc
- Finally, the waiting times are updated according to Time.Delta
*/
void Update () {
//The current battle state determines what actions can be taken.
checkForTurn();
checkEndOfBattle();
switch(currentState)
{
case BattleState.START:
// Start of the battle.
UIStateController.Instance.enableMenu("waiting");
UIStateController.Instance.updateCharacterAndEnemiesText();
currentState = BattleState.WAITING;
break;
case BattleState.WAITING:
// Idle phase, nothing happens.
/* DIFFERENTS EFFECTS COUlD BE APPLIED:
- Check if buffs / debuffs end (speed up, poison...)
- Apply effects such as poison
- Regeneration (Perhaps armor fell off and is being regenerated)
*/
break;
case BattleState.PLAYERTURN:
// Player turn starts and
// Start GUI showing the "initial" menu state.
if (allyTurnReady == null)
{
QueuedEntity allyqe = turnQueue.Dequeue();
allyTurnReady = (BaseCharacterClass)allyqe.entity;
UIStateController.Instance.enableMenu("initial");
UIStateController.Instance.personaliseMenuToCharacter(allyTurnReady);
}
currentState = BattleState.WAITING;
break;
case BattleState.ENEMYTURN:
// Enemy's turn starts
QueuedEntity enemyqe = turnQueue.Dequeue();
BaseEnemy enemy = (BaseEnemy)enemyqe.entity;
// To ensure that dead units are not targeted, filter them out.
Entity target = enemy.strategy(Array.FindAll(alliedCharacters, e => !e.isDead()),
Array.FindAll(enemies, e => !e.isDead()));
Debug.Log(enemy.getName() + " Attacks " + target.getName() + " for " + enemy.attack + " damage");
target.takeDamage(enemy.attack);
turnQueue.Enqueue(new QueuedEntity(enemy), enemy.speed);
UIStateController.Instance.updateCharacterAndEnemiesText();
currentState = BattleState.WAITING;
break;
case BattleState.CALCDAMAGE:
// Calculates dmg to target(s)
BattleAbilityUseHandler abilityHandler = new BattleAbilityUseHandler(ref allyTurnReady, playerTargetIndex,
ref alliedCharacters, ref enemies);
abilityHandler.calculateDamage();
int castingTIme = abilityHandler.calculateCastingTime();
this.playerTargetIndex = -1;
turnQueue.Enqueue(new QueuedEntity(allyTurnReady), castingTIme);
this.allyTurnReady = null;
currentState = BattleState.WAITING;
UIStateController.Instance.updateCharacterAndEnemiesText();
break;
case BattleState.ADDSTATUSEFFECT:
// Adds special status such as poison.
break;
case BattleState.WIN:
/* All enemies have been defeated, we store the relevant information in GameInformation
and we get back to the map */
//GameInformation.alliedCharacters = alliedCharacters;
Debug.Log("GAME WON");
break;
case BattleState.LOSE:
// All allied characters have been defeated.
Debug.Log("GAME LOST");
break;
default:
break;
}
// If it's a character's turn, check if he / she has died
checkIfAllyTurnReadyIsDead();
// Update the turnque in order to reflect time passing.
updateTurnQueue(Time.deltaTime);
}
public void Initialize()
{
uiActionContainer = CombatFlow.cl.uiActionContainer;
//utilisation du viewport de la camera pour placer les characters
playerStartingPosition = CombatFlow.cl.camera.ViewportToWorldPoint(new Vector2(.2f, .5f));
ennemiStartingPosition = CombatFlow.cl.camera.ViewportToWorldPoint(new Vector2(.8f, .5f));
playerHp = CombatFlow.cl.playerHp; //pointeur vers le composant text des HP du joueur
playerMana = CombatFlow.cl.playerMana; //pointeur vers le composant text de la mana du joueur
ennemiHP = CombatFlow.cl.ennemiHP; //pointeur vers le composant text des HP de l'ennemi
ennemiMana = CombatFlow.cl.ennemiMana; //pointeur vers le composant text de la mana de l'ennemi
playerHpImage = CombatFlow.cl.playerHpImage; //pointeur vers le composant image des HP du joueur
playerManaImage = CombatFlow.cl.playerManaImage; //pointeur vers le composant image de la mana du joueur
ennemiHPImage = CombatFlow.cl.ennemiHPImage; //pointeur vers le composant image des HP de l'ennemi
ennemiManaImage = CombatFlow.cl.ennemiManaImage; //pointeur vers le composant image de la mana de l'ennemi
playerImage = CombatFlow.cl.playerImage; //pointeur vers le composant image du portrait du joueur
ennemiImage = CombatFlow.cl.ennemiImage; //pointeur vers le composant image du portrait de l'ennemi
switch (OmniPlayer.Instance.characterClass)
{
case CharacterClasses.Warrior:
player = new Warrior();
playerImage.sprite = GameObject.Instantiate <Sprite>(Resources.Load <Sprite>("Sprites/Gladiator_Portrait"));
playerObj = GameObject.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/Warrior"));
break;
case CharacterClasses.Wizard:
player = new Wizard();
playerImage.sprite = GameObject.Instantiate <Sprite>(Resources.Load <Sprite>("Sprites/Wizards_Portrait"));
playerObj = GameObject.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/Wizard"));
break;
default:
Debug.Log("Unhandeled character class : " + player.characterClass);
break;
}
CombatFlow.cl.PlayerCharacter = ChargerPlayer(player);
switch (OmniEnemy.Instance.characterClass)
{
case CharacterClasses.Orc:
ennemi = new Orc();
ennemiImage.sprite = GameObject.Instantiate <Sprite>(Resources.Load <Sprite>("Sprites/Orc_Portrait"));
ennemiObj = GameObject.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/Orc"));
break;
case CharacterClasses.Elemental:
ennemi = new Elemental();
ennemiImage.sprite = GameObject.Instantiate <Sprite>(Resources.Load <Sprite>("Sprites/Elemental_Portrait"));
ennemiObj = GameObject.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/Elemental"));
break;
case CharacterClasses.Boss:
ennemi = new Boss();
ennemiImage.sprite = GameObject.Instantiate <Sprite>(Resources.Load <Sprite>("Sprites/Golem_Portrait"));
ennemiObj = GameObject.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/Boss"));
break;
default:
Debug.Log("Unhandeled character class : " + player.characterClass);
break;
}
CombatFlow.cl.EnemyCharacter = ennemi;
playerObj.transform.position = CombatFlow.cl.playerPosition = playerStartingPosition;
playerObj.transform.localScale *= CHARACTER_SIZE;
playerAnimator = playerObj.GetComponent <Animator>();
ennemiObj.transform.position = ennemiStartingPosition;
ennemiObj.transform.localScale *= CHARACTER_SIZE;
ennemiAnimator = ennemiObj.GetComponent <Animator>();
playerEffect = playerObj.GetComponentsInChildren <ParticleSystem>();
ennemiEffect = playerObj.GetComponentsInChildren <ParticleSystem>();
}
// ...
void WarriorClicked()
{
createdCharacter = new BaseWarriorClass();
UpdateCharacterDetailsView();
}