public GenericCharacter createGeneric(Vector2 position, Team team, Color color)
{
Animation stand = new Animation(Res.stand);
Animation run = new Animation(Res.run, 8);
Animation strafe = new Animation(Res.strafe, 8);
GenericCharacter character = new GenericCharacter(position, team, run, run, strafe, strafe, stand);
character.color = color;
return character;
}
public override void DoAttack(GenericCharacter attacker)
{
if (!_ready)
{
return;
}
//_ready = false;
//_attacker = attacker;
//PlayAnimation(attacker);
//StartCoroutine(AttackRoutine());
base.DoAttack(attacker);
GetComponent <Collider>().enabled = true;
}
//Expose UseAction()
// -> Have it look at the information from the action and do stuff based on it.
public void PerformAction(PerformActionDataModel aPerformActionDataModel)
{
Debug.Log("Performing Action");
//TODO: Maybe make null checks around this
GenericActionModel action = ActionData.ABILITY_DICTIONARY[aPerformActionDataModel.GetActionID()];
GenericCharacter actionUser = aPerformActionDataModel.GetAttackerData();
GenericCharacter actionDefender = aPerformActionDataModel.GetDefenderData();
if (action != null)
{
switch (aPerformActionDataModel.GetTargetAmount())
{
case GenericActionModel.ACTION_TARGET_AMOUNT.SINGLE_TARGET:
if (actionUser != actionDefender)
{
PerformActionSingle(action, actionUser, actionDefender);
}
else if (actionUser == actionDefender)
{
PerformSelfAction(action, actionUser);
}
break;
case GenericActionModel.ACTION_TARGET_AMOUNT.ALL_TARGETS:
PerformActionAll(action, actionUser);
break;
case GenericActionModel.ACTION_TARGET_AMOUNT.MULTI_TARGET_OFFENSIVE:
PerformMultiOffensiveAction(action, actionUser);
break;
case GenericActionModel.ACTION_TARGET_AMOUNT.MULTI_TARGET_DEFENSIVE:
PerformMultiDefensiveAction(action, actionUser);
break;
default:
Debug.Log("Error: Action does not have a target amount type, or is set to none.");
break;
}
}
else
{
Debug.Log("ERROR: Action is null/does not exist!");
}
}
public void Init()
{
GenericCharacter genericCharacter = new GenericCharacter();
genericCharacter.SetIsPlayerControlled(true);
genericCharacter.SetCharacterName("Argonn");
genericCharacter.SetCharacterMana(50);
genericCharacter.SetSpriteFileName("elf_male.png");
genericCharacter.SetSpriteFilePath("Test_Assets");
genericCharacter.AddActionIDToUsableActionList(ActionData.ACTION_LIST_ID.HEAL_TARGET);
genericCharacter.AddActionIDToUsableActionList(ActionData.ACTION_LIST_ID.MULTI_STRIKE);
genericCharacter.AddActionIDToUsableActionList(ActionData.ACTION_LIST_ID.STRIKE);
SetCharacterStats(genericCharacter);
GameManager.GetPlayerManager.AddCharacterToList(genericCharacter);
}
public DemoLevel() : base()
{
initialiseTeams();
gun = new GenericGun(Vector2.Zero, new Animation(Res.pistol));
player = createGeneric(Vector2.Zero, blueTeam, Color.Blue);
player.weapon = gun;
blueTeam.characters.Add(player);
genericObjects.Add(gun);
spawnCharacters(10);
spawnDestructableEnvironment(10, 100, 100);
// spawnSolidEnvironment(10, 200, 200);
spawnBackground(10);
gun.muzzleVelocity = 10;
DestructableTerrain test = new DestructableTerrain(new Vector2(10, 0), Graphics.dictionary[Res.crate]);
List <Vector2> list = test.getVectorCollisions(new Vector2(10, 5), 1);
}
public DemoLevel()
: base()
{
initialiseTeams();
gun = new GenericGun(Vector2.Zero, new Animation(Res.pistol));
player = createGeneric(Vector2.Zero, blueTeam, Color.Blue);
player.weapon = gun;
blueTeam.characters.Add(player);
genericObjects.Add(gun);
spawnCharacters(10);
spawnDestructableEnvironment(10, 100, 100);
// spawnSolidEnvironment(10, 200, 200);
spawnBackground(10);
gun.muzzleVelocity = 10;
DestructableTerrain test = new DestructableTerrain(new Vector2(10, 0), Graphics.dictionary[Res.crate]);
List<Vector2> list = test.getVectorCollisions(new Vector2(10, 5), 1);
}
public void InitChar(bool aIsPlayerControlled)
{
if (m_Character != null)
{
m_Character.SetIsPlayerControlled(aIsPlayerControlled);
m_Character.SetCharacterHealth(150);
m_Character.SetCharacterName(TestRandomNameGen.GenerateName(Random.Range(1, 10)));
}
else
{
m_Character = new GenericCharacter();
m_Character.SetIsPlayerControlled(aIsPlayerControlled);
m_Character.SetCharacterHealth(150);
m_Character.SetCharacterName(TestRandomNameGen.GenerateName(Random.Range(1, 10)));
}
AddInitialTestActions();
}
public virtual void DoAttack(GenericCharacter attacker)
{
if (!_ready)
{
return;
}
_ready = false;
_attacker = attacker;
PlayAnimation(attacker);
if (selfAS != null && sound != null && !playSoundInCoroutine)
{
selfAS.PlayOneShot(sound);
}
StartCoroutine(AttackRoutine());
}
public void Init()
{
GenericCharacter genericCharacter = new GenericCharacter();
genericCharacter.SetIsPlayerControlled(false);
genericCharacter.SetCharacterName("Enemy_Wolf");
genericCharacter.SetCharacterMana(40);
genericCharacter.SetCharacterHealth(500);
genericCharacter.SetSpriteFileName("wolf.png");
genericCharacter.SetSpriteFilePath("Test_Assets");
genericCharacter.AddActionIDToUsableActionList(ActionData.ACTION_LIST_ID.MULTI_STRIKE);
genericCharacter.AddActionIDToUsableActionList(ActionData.ACTION_LIST_ID.STRIKE);
SetCharacterStats(genericCharacter);
//We do not do this with enemies. Add it in combat manager
//GameManager.GetPlayerManager.AddCharacterToList(genericCharacter);
}
private void ApplyAffix(GenericCharacter aAffixReceiver, GenericAffixModel aAffix)
{
Debug.Log("Action: " + aAffix.GetActionName() + "is being used on Target: " + aAffixReceiver.GetCharacterName());
Dictionary <GenericCharacter, List <GenericAffixModel> > actionUsersWithAffixes = GameManager.GetCombatManager.m_ActionUsersWithAffixes;
if (actionUsersWithAffixes.ContainsKey(aAffixReceiver))
{
bool bDoesAffixExist = false;
int indexFound = 0;
for (int i = 0; i < actionUsersWithAffixes[aAffixReceiver].Count; i++)
{
if (actionUsersWithAffixes[aAffixReceiver][i].GetAffixID() == aAffix.GetAffixID())
{
bDoesAffixExist = true;
indexFound = i;
break;
}
}
if (bDoesAffixExist == true)
{
if (aAffix.GetIsStackable())
{
actionUsersWithAffixes[aAffixReceiver][indexFound].AddStackAmount(1);
}
else
{
actionUsersWithAffixes[aAffixReceiver][indexFound].RefreshAffix();
}
}
else
{
actionUsersWithAffixes[aAffixReceiver].Add(aAffix);
}
}
else
{
List <GenericAffixModel> affixModelList = new List <GenericAffixModel>();
affixModelList.Add(aAffix);
actionUsersWithAffixes.Add(aAffixReceiver, affixModelList);
}
}
public void PerformMultiDefensiveAction(GenericActionModel aAction, GenericCharacter aDefender)
{
Debug.Log("Performing multi defensive action");
Debug.Log("Action name from dictionary: " + aAction.GetActionName());
int hitTracking = 0;
for (int i = 0; i < GameManager.GetPlayerManager.GetCharacterList().Count; i++)
{
GenericCharacter genericCharacter = GameManager.GetPlayerManager.GetCharacterList()[i];
if (genericCharacter.IsPlayerControlled() == true)
{
if (aAction.GetDoesActionDamage())
{
ApplyDamage(genericCharacter, aDefender, aAction);
hitTracking++;
}
if (aAction.GetDoesActionHeal())
{
ApplyHeal(genericCharacter, aDefender, aAction);
hitTracking++;
}
if (aAction.GetDoesActionHaveAffix())
{
List <ActionData.AFFIX_LIST_ID> affixList = aAction.GetListOfAffixes();
if (affixList.Count != 0)
{
for (int j = 0; j < affixList.Count; j++)
{
ApplyAffix(genericCharacter, ActionData.AFFIX_DICTIONARY[affixList[j]]);
}
}
}
}
}
Debug.Log("Action hit " + hitTracking + " times");
}
public GenericCharacter GetRandomPlayerCharacter()
{
GenericCharacter character = null;
bool bCharFound = false;
while (bCharFound == false)
{
int randIndex = Random.Range(0, GameManager.GetCombatManager.m_CharacterCombatList.Count);
if (GameManager.GetCombatManager.m_CharacterCombatList[randIndex].GetComponent <GenericCharacterController>().GetCharacterStats().IsPlayerControlled() &&
GetComponentInParent <GenericCharacterController>().GetCharacterStats() != GameManager.GetCombatManager.m_CharacterCombatList[randIndex].GetComponent <GenericCharacterController>().GetCharacterStats())
{
bCharFound = true;
character = GameManager.GetCombatManager.m_CharacterCombatList[randIndex].GetComponent <GenericCharacterController>().GetCharacterStats();
}
}
return(character);
}
//TODO: Change this to actually work properly. Need to add a current health, and a max health type of variable in generic character
private void ProcessDamageTaken(GenericCharacter aGenericCharacter, int aDamageValue)
{
int currentDamage = aDamageValue;
aDamageValue -= aGenericCharacter.GetCharacterTotalStats()[(int)GenericCharacter.STAT_INDEX.SHIELD];
if (aDamageValue < 0)
{
aDamageValue = 0;
}
int currentHP = aGenericCharacter.GetCharacterTotalStats()[(int)GenericCharacter.STAT_INDEX.HEALTH] -= aDamageValue;
if (currentHP < 0)
{
currentHP = 0;
}
aGenericCharacter.SetCurrentHealth(currentHP);
}
public void TestAddBaseEquippableToCharacterAndTestStrengthDualWeild()
{
GenericCharacter GC = GenericCharacter.GCFactory();
BaseEquipable BE = new BaseEquipable(1, "BaseSword", 10);
BE.EquipEffects.Add("Strength", 1);
BE.TargetBodyParts.Add(new Arm());
GC.AddEquipment(BE);
BaseEquipable BE2 = new BaseEquipable(2, "BaseSword", 10);
BE2.EquipEffects.Add("Strength", 1);
BE2.TargetBodyParts.Add(new Arm());
GC.AddEquipment(BE2);
Assert.AreEqual(5, GC.myStats.Strength.Value);
}
//TODO: Deprecate
private void UpdateNextCharacter()
{
m_TurnQueueIndex++;
if (m_TurnQueueIndex > m_AllActionUsers.Count)
{
m_TurnQueueIndex = 0;
}
m_CurrentActionUser = m_AllActionUsers[m_TurnQueueIndex];
if (m_CurrentActionUser.IsPlayerControlled() == true)
{
m_CurrentPlayer = m_CurrentActionUser;
}
else
{
m_CurrentPlayer = null;
}
}
//DEPRECATED. DO NOT USE
/*
* public void AddAffixToCharacter(GenericAffixModel aAffix, GenericCharacter aCharacter)
* {
* if (m_ActionUsersWithAffixes.ContainsKey(aCharacter))
* {
* bool bDoesAffixExist = false;
* int indexFound = 0;
*
* for (int i = 0; i < m_ActionUsersWithAffixes[aCharacter].Count; i++)
* {
* if (m_ActionUsersWithAffixes[aCharacter][i].GetAffixID() == aAffix.GetAffixID())
* {
* bDoesAffixExist = true;
* indexFound = i;
* break;
* }
* }
*
* if (bDoesAffixExist == true)
* {
* if (aAffix.GetIsStackable())
* {
* m_ActionUsersWithAffixes[aCharacter][indexFound].AddStackAmount(1);
* }
* else
* {
* m_ActionUsersWithAffixes[aCharacter][indexFound].RefreshAffix();
* }
* }
* else
* {
* m_ActionUsersWithAffixes[aCharacter].Add(aAffix);
* }
* }
* else
* {
* List<GenericAffixModel> affixModelList = new List<GenericAffixModel>();
* affixModelList.Add(aAffix);
* m_ActionUsersWithAffixes.Add(aCharacter, affixModelList);
* }
* }
*/
//TODO: Get rid of this because it's not being used anymore
// Not doing a turnbased in order of whoever, it's now, you select them
public void ResetInitialActionUser()
{
m_CurrentActionUser = null;
m_TurnQueueIndex = 0;
//Start by setting the player to be the main user
for (int i = 0; i < m_AllActionUsers.Count; i++)
{
if (m_AllActionUsers[i].IsPlayerControlled())
{
m_CurrentActionUser = m_AllActionUsers[i];
m_CurrentPlayer = m_AllActionUsers[i];
}
if (m_CurrentActionUser == null &&
(i >= m_AllActionUsers.Count))
{
Debug.LogError("ERROR: There is no player controlled action user in the current combat");
break;
}
}
}
private void ApplyHeal(GenericCharacter aHealReceiver, GenericCharacter aAttacker, Action aAction)
{
Debug.Log("Action: " + aAction.GetActionName() + " - is being used on Target: " + aHealReceiver.GetCharacterName());
int actionHealValue = 0;
if (aAction.GetType() == typeof(GenericAffixModel))
{
Debug.Log("Action is GenericAffixModel type, attempting to stack.");
GenericAffixModel affixAction = (GenericAffixModel)aAction;
if (affixAction.GetIsStackable())
{
Debug.Log("Affix is stackable. Multiplying healing by " + affixAction.GetStackAmount() + " .");
actionHealValue = affixAction.GetHealAmount() * affixAction.GetStackAmount();
}
}
else
{
actionHealValue = ComputeHealValue(aAttacker, aAction);
}
ProcessHealingTaken(aHealReceiver, actionHealValue);
}
public void TestCreateCharacter()
{
GenericCharacter GC = GenericCharacter.GCFactory();
Assert.IsInstanceOfType(GC, typeof(ACharacter));
}
public void SetCurrentSelectedCharacter(GenericCharacter aCharacter)
{
m_CurrentSelectedCharacter = aCharacter;
}
public void OnCharacterSelected(GenericCharacter aGenericCharacter)
{
if (m_CombatState == COMBAT_STATE.PLAYER_TURN)
{
//If it is the players turn, and we are selecting a player party member
if (aGenericCharacter.IsPlayerControlled())
{
//Do we have something selected already and is it not equal to the new selection?
if (m_CurrentSelectedCharacter != aGenericCharacter)
{
//If we don't have a selected action and are just swapping characters
if (m_CurrentSelectedAction == ActionData.ACTION_LIST_ID.NONE)
{
m_CurrentSelectedCharacter = aGenericCharacter;
m_CombatUIController.GetInterfaceModel().UpdateListOfActions();
}
else
{
//If we have an action and users selected...
//Create perform action data and send it to be used
//If it's single target, do this, else, the rest will be automatically sorted
if (ActionData.ABILITY_DICTIONARY[m_CurrentSelectedAction].GetActionTargetAmount() == GenericActionModel.ACTION_TARGET_AMOUNT.SINGLE_TARGET)
{
PerformActionDataModel performActionDataModel = new PerformActionDataModel(m_CurrentSelectedAction, GenericActionModel.ACTION_TARGET_AMOUNT.SINGLE_TARGET,
m_CurrentSelectedCharacter, aGenericCharacter);
m_ActionController.PerformAction(performActionDataModel);
}
else if (ActionData.ABILITY_DICTIONARY[m_CurrentSelectedAction].GetActionTargetAmount() == GenericActionModel.ACTION_TARGET_AMOUNT.MULTI_TARGET_DEFENSIVE)
{
PerformActionDataModel performActionDataModel = new PerformActionDataModel(m_CurrentSelectedAction, GenericActionModel.ACTION_TARGET_AMOUNT.MULTI_TARGET_DEFENSIVE,
m_CurrentSelectedCharacter);
m_ActionController.PerformAction(performActionDataModel);
}
else
{
//Won't attack everyone on your team, perhaps change this?
if (ActionData.ABILITY_DICTIONARY[m_CurrentSelectedAction].GetActionTargetAmount() == GenericActionModel.ACTION_TARGET_AMOUNT.MULTI_TARGET_OFFENSIVE &&
!aGenericCharacter.IsPlayerControlled())
{
PerformActionDataModel performActionDataModel = new PerformActionDataModel(m_CurrentSelectedAction, ActionData.ABILITY_DICTIONARY[m_CurrentSelectedAction].GetActionTargetAmount(),
m_CurrentSelectedCharacter);
}
else
{
Debug.Log("Can't offensive on teammates");
}
}
m_CurrentSelectedAction = ActionData.ACTION_LIST_ID.NONE;
//TODO: Clean this up
m_CombatUIController.SetAllUIInactive();
m_CombatUIController.SetEndTurnUIActive();
m_CombatUIController.SetMainSelectionState();
}
}
}
//If it's the player turn, and we are selecting an enemy
else
{
if (m_CurrentSelectedCharacter != null)
{
if (m_CurrentSelectedCharacter != aGenericCharacter)
{
//If we don't have something selected
if (m_CurrentSelectedAction == ActionData.ACTION_LIST_ID.NONE)
{
//do nothing I guess...?
}
else
{
if (ActionData.ABILITY_DICTIONARY[m_CurrentSelectedAction].GetActionTargetAmount() == GenericActionModel.ACTION_TARGET_AMOUNT.SINGLE_TARGET)
{
PerformActionDataModel performActionDataModel = new PerformActionDataModel(m_CurrentSelectedAction, ActionData.ABILITY_DICTIONARY[m_CurrentSelectedAction].GetActionTargetAmount(),
m_CurrentSelectedCharacter, aGenericCharacter);
m_ActionController.PerformAction(performActionDataModel);
}
else
{
if (ActionData.ABILITY_DICTIONARY[m_CurrentSelectedAction].GetActionTargetAmount() == GenericActionModel.ACTION_TARGET_AMOUNT.MULTI_TARGET_OFFENSIVE)
{
PerformActionDataModel performActionDataModel = new PerformActionDataModel(m_CurrentSelectedAction, ActionData.ABILITY_DICTIONARY[m_CurrentSelectedAction].GetActionTargetAmount(),
m_CurrentSelectedCharacter);
m_ActionController.PerformAction(performActionDataModel);
}
else
{
Debug.Log("Can't use defensive on enemies.");
}
}
m_CurrentSelectedAction = ActionData.ACTION_LIST_ID.NONE;
//TODO: Clean this up
m_CombatUIController.SetAllUIInactive();
m_CombatUIController.SetEndTurnUIActive();
m_CombatUIController.SetMainSelectionState();
}
}
}
}
}
}
public void InitCharacterWithJSON(string aJSONFilePath)
{
TextAsset file = Resources.Load(aJSONFilePath) as TextAsset;
JSONNode characterJSON = JSON.Parse(file.ToString());
Debug.Log(characterJSON);
if (m_CharacterStats == null)
{
m_CharacterStats = new GenericCharacter();
}
m_CharacterStats.SetIsPlayerControlled(characterJSON["isPlayerControlled"]);
m_CharacterStats.SetIsCharacterDead(characterJSON["isCharacterDead"]);
m_CharacterStats.SetCharacterHasMana(characterJSON["doesCharacterHaveMana"]);
m_CharacterStats.SetCharacterName(characterJSON["characterName"]);
m_CharacterStats.SetSpriteFilePath(characterJSON["spriteFilePath"]);
m_CharacterStats.SetSpriteFileName(characterJSON["spriteName"]);
m_CharacterStats.SetCharacterHealth(characterJSON["characterStats"]["maxHealth"]);
m_CharacterStats.SetCurrentHealth(characterJSON["characterStats"]["currentHealth"]);
m_CharacterStats.SetShield(characterJSON["characterStats"]["shield"]);
m_CharacterStats.SetStrength(characterJSON["characterStats"]["strength"]);
m_CharacterStats.SetSpellPower(characterJSON["characterStats"]["spellPower"]);
if (characterJSON["actionListIDs"].IsArray)
{
for (int i = 0; i < characterJSON["actionListIDs"].AsArray.Count; i++)
{
//TODO: Check if ability is in the dictionary first before trying to add to character
//NOTE: I might already be doing that in another function that gets called when I add it.
//What in the C# wizardy f**k is this
ActionData.ACTION_LIST_ID action = (ActionData.ACTION_LIST_ID)System.Enum.Parse(typeof(ActionData.ACTION_LIST_ID), characterJSON["actionListIDs"][i]);
m_CharacterStats.AddActionIDToUsableActionList(action);
}
}
//Oh god here we go again with the magic
m_CharacterStats.AddEquipmentToCharacter(
(ItemData.ITEM_ID)System.Enum.Parse(typeof(ItemData.ITEM_ID), characterJSON["equipmentSlots"]["chest"])
);
m_CharacterStats.AddEquipmentToCharacter(
(ItemData.ITEM_ID)System.Enum.Parse(typeof(ItemData.ITEM_ID), characterJSON["equipmentSlots"]["helm"])
);
m_CharacterStats.AddEquipmentToCharacter(
(ItemData.ITEM_ID)System.Enum.Parse(typeof(ItemData.ITEM_ID), characterJSON["equipmentSlots"]["weapon"])
);
m_CharacterStats.AddEquipmentToCharacter(
(ItemData.ITEM_ID)System.Enum.Parse(typeof(ItemData.ITEM_ID), characterJSON["equipmentSlots"]["ring"])
);
//Unload this somewhere....? at some point in time? Not sure where, but somewhere...
string spritePath = m_CharacterStats.GetSpriteFilePath() + "/" + m_CharacterStats.GetSpriteFileName();
m_SpriteRenderer.sprite = Resources.Load <Sprite>(spritePath);
Resources.UnloadAsset(file);
GameManager.GetPlayerManager.AddCharacterToList(m_CharacterStats);
}
/**
/* @name: resetChosen
/* @version: 1.5
/* @Descrition: Reinicia os valores de personagemEscolhido e Objetivo de movimetação para que não exista lixo entre ações. E desfaz a area de ação anterior.
*/
private void resetChosen()
{
desfazAreaDeAcao();
this.personagemEscolhido.estadoAtual = CharacterState.idle;
this.personagemEscolhido = null;
this.acaoEscolhida = playersActions.Andar;
this.objetivo = null;
}
/**
/* @name: escolhaDePersonagem
/* @version: 1.0
/* @Descrition: responsavel por atualizar a variavel personagemEscolhido e por aplicar um highlight usando shader.
*/
private void escolhaDePersonagem(GameObject novoPersonagem)
{
//Se o jogador já escolheu um personagem, seu shader é retornado ao normal
if (this.personagemEscolhido != null)
{
desfazAreaDeAcao();
this.personagemEscolhido.estadoAtual = CharacterState.idle;
}
//Então a variavel de personagem escolhido é atualizada
this.personagemEscolhido = novoPersonagem.GetComponent<GenericCharacter>();
this.personagemEscolhido.estadoAtual = CharacterState.selecionado;
fazAreaDeAcao();
}
public void SetDefenderData(GenericCharacter aAttackerData)
{
m_AttackerData = aAttackerData;
}
public void spotTarget(GenericCharacter basicChar)
{
target = basicChar;
}
//Pass in the ID and then create a new object of that affix model to store.
public void AddAffixToCharacter(ActionData.AFFIX_LIST_ID aAffixID, GenericCharacter aCharacter)
{
Debug.Log("Applying Affix To Character");
}
void Awake()
{
genericCharacter = GetComponentInChildren <GenericCharacter>();
screensTransitionManager.OnReturnToTitle += DetachAllCharacters;
}
public void TestCreateCharacterName()
{
GenericCharacter GC = GenericCharacter.GCFactory();
Assert.AreEqual("Vanessa", GC.Name);
}
void Start()
{
self = GetComponent <GenericCharacter>();
baseIntel = self.GetCharac().intelligence;
equipement = GetComponent <Equipement>();
}
// Use this for initialization
void Start()
{
//Change to who we are initializing it to here
m_CharacterStats = new GenericCharacter();
//Possibly have it take an ID for the character we want to initialize as. Have a way to look up the values for that ID
}
public void shoot(GenericCharacter shooter, ParticleGun particleGun, ObjectList bullets)
{
if (MOUSE.LeftDown && particleGun.readyToFire)
{
bullets.Add(particleGun.Fire());
}
}
public void SetCharacterStats(GenericCharacter aGenericCharacter)
{
m_CharacterStats = aGenericCharacter;
}
void RetrieveChildCharacter()
{
genericCharacter = GetComponentInChildren <GenericCharacter>();
}
public void AddCharacterToList(GenericCharacter aCharacter)
{
m_ListOfCharacters.Add(aCharacter);
}
private void ProcessHealingTaken(GenericCharacter aGenericCharacter, int aHealingValue)
{
aGenericCharacter.SetCurrentHealth(aGenericCharacter.GetCharacterHealth() + aHealingValue);
}
//Used mostly for 1 on 1 actions
//TODO: Refactor the if statment in these functions and put it into a single function
//TODO: Change this to use the perform action model for parameters
public void PerformActionSingle(GenericActionModel aAction, GenericCharacter aAttacker, GenericCharacter aDefender)
{
Debug.Log("Performing 1 on 1 action");
Debug.Log("Action name from dictionary: " + aAction.GetActionName());
if (aAction.GetDoesActionDamage())
{
ApplyDamage(aDefender, aAttacker, aAction);
}
if (aAction.GetDoesActionHeal())
{
ApplyHeal(aDefender, aAttacker, aAction);
}
if (aAction.GetDoesActionHaveAffix())
{
List <ActionData.AFFIX_LIST_ID> affixList = aAction.GetListOfAffixes();
if (affixList.Count != 0)
{
for (int i = 0; i < affixList.Count; i++)
{
ApplyAffix(aDefender, ActionData.AFFIX_DICTIONARY[affixList[i]]);
}
}
}
}
public AI(GenericCharacter character)
{
this.character = character;
destination = character._position;
}
